복붙노트

[SCALA] 무엇 스칼라 연속 요청은 왜 그들을 사용?

SCALA

무엇 스칼라 연속 요청은 왜 그들을 사용?

난 그냥 스칼라 프로그래밍 완료, 나는 스칼라 2.7과 2.8 사이의 변화를 조사했습니다. 가장 중요한 것 같다 하나는 연속 요청이 플러그인이지만, 나는 그것이 나 작동 방식에 유용 이해하지 않습니다. 나는 비동기 I / O를위한 그것의 좋은,하지만 난 이유를 찾을 수 없어 것을 보았다. 주제에 더 인기있는 자원의 일부는 다음과 같습니다

그리고 스택 오버플로이 질문 :

불행하게도, 이러한 참조 중 어느 것도 시프트 / 리셋 기능은 어떻게해야 무엇 연속성을가하거나을 정의하려고하지, 난 할 참조를 발견하지 않았습니다. 내가 링크 된 문서 작업 (또는 그들이 무엇을 할)의 예제의 도움을 날 수있는 한 가지 방법이 될 수 있도록 그 샘플 중 하나를 통해 라인 별을 이동하는 방법을 추측 할 수 없었다. 세 번째 기사에서이 간단한 일 :

reset {
    ...
    shift { k: (Int=>Int) =>  // The continuation k will be the '_ + 1' below.
        k(7)
    } + 1
}
// Result: 8

왜 결과 8? 그건 아마 내가 시작하는 데 도움이 될 것이다.

해결법

  1. ==============================

    1.내 블로그는 다시 읽기 할 수 있도록, 리셋 및 이동이하는 일을 설명한다.

    내 블로그는 다시 읽기 할 수 있도록, 리셋 및 이동이하는 일을 설명한다.

    나는 또한 내 블로그에 가리키는 또 다른 좋은 소스는, 계속 통과 스타일에 위키 백과 항목입니다. 이 스칼라 구문을 사용하지 않습니다하지만 그 하나는, 주제에 가장 명확하고 지금까지,이고, 계속 명시 적으로 전달됩니다.

    내 블로그에 링크하지만 깨진 될 것으로 보인다 구분 연속성을에 용지가 사용의 많은 예제를 제공합니다.

    그러나 나는 구분의 연속 요청 개념의 가장 좋은 예는 스칼라 떼라고 생각합니다. 그것에서, 라이브러리는 한 지점에서 코드의 실행을 정지하고, 나머지 연산은 계속된다. 다른 호스트로 계산 전사,이 경우, 그리고 정지 된 연산의 결과 (액세스 된 변수의 값)을 반환 - 라이브러리는 일을한다.

    지금, 당신은 나의 블로그를 읽습니까, 스칼라 페이지도 간단한 예제를 이해하지 않습니다. 그것에서 나는 결과 만 8 이유의 이러한 기초를 설명하는 우려하고있다.

  2. ==============================

    2.나는 희망을보다 개념을 설명 덜 효과적인 것으로 기존의 설명을 발견했다. 나는이 사람이 분명 희망 (그리고 올바른.) 아직 연속성을 사용하지 않았습니다.

    나는 희망을보다 개념을 설명 덜 효과적인 것으로 기존의 설명을 발견했다. 나는이 사람이 분명 희망 (그리고 올바른.) 아직 연속성을 사용하지 않았습니다.

    연속 함수 CF가 호출되는 경우 :

    그래서이 예에서는 A로부터 Z까지 문자를 따라

    reset {
  // A
  shift { cf: (Int=>Int) =>
    // B
    val eleven = cf(10)
    // E
    println(eleven)
    val oneHundredOne = cf(100)
    // H
    println(oneHundredOne)
    oneHundredOne
  }
  // C execution continues here with the 10 as the context
  // F execution continues here with 100
  + 1
  // D 10.+(1) has been executed - 11 is returned from cf which gets assigned to eleven
  // G 100.+(1) has been executed and 101 is returned and assigned to oneHundredOne
}
// I

    이 인쇄 :

    11
101
  3. ==============================

    3.약간 수정, 스칼라의 구분 연속성을위한 연구 논문에서 정식 예를 감안할 때 그렇게 변화로 기능 입력 F 이름이 주어지지 때문에 더 이상 익명입니다.

    약간 수정, 스칼라의 구분 연속성을위한 연구 논문에서 정식 예를 감안할 때 그렇게 변화로 기능 입력 F 이름이 주어지지 때문에 더 이상 익명입니다.

    def f(k: Int => Int): Int = k(k(k(7)))
reset(
  shift(f) + 1   // replace from here down with `f(k)` and move to `k`
) * 2

    스칼라 플러그인 변환 리셋 호출 각 시프트에서 시작 (리셋 입력 인자 내에서) 계산 함수 (예를 들어, F)의 시프트에 대한 입력으로 대체되도록 예.

    교체 된 계산 함수 (K)에 (즉, 이동) 이동된다. k는 치환 연산 포함 입력 함수 f 함수 K, K 입력 X : INT, 및 K의 계산은, X와 시프트 (F)를 대체한다.

    f(k) * 2
def k(x: Int): Int = x + 1

    어떤의 효과는 :

    k(k(k(7))) * 2
def k(x: Int): Int = x + 1

    입력 변수 (X) (K, 즉 유형의 서명)의 종류 지능 참고 F의 입력 변수의 입력 서명으로 주어졌다.

    개념적으로 추상화와 동등한 다른 차용 예, 즉 판독 시프트 기능 입력 :

    def read(callback: Byte => Unit): Unit = myCallback = callback
reset {
  val byte = "byte"

  val byte1 = shift(read)   // replace from here with `read(callback)` and move to `callback`
  println(byte + "1 = " + byte1)
  val byte2 = shift(read)   // replace from here with `read(callback)` and move to `callback`
  println(byte + "2 = " + byte2)
}

    나는이가 동등한 논리로 번역 될 것입니다 생각 :

    val byte = "byte"

read(callback)
def callback(x: Byte): Unit {
  val byte1 = x
  println(byte + "1 = " + byte1)
  read(callback2)
  def callback2(x: Byte): Unit {
    val byte2 = x
    println(byte + "2 = " + byte1)
  }
}

    나는이 다소이 두 사례의 사전 프리젠 테이션으로 난독 화 된 일관된 공통의 추상화를 해명 바랍니다. 예를 들어, 정규 첫 번째 예는 따라서 그것은 바로이 빌린 두 번째 예제에서 읽기에 추상적으로 비슷한 것을 일부 독자들에게 명확하지 않았다, 대신에 내 이름이 F의, 익명의 함수로 연구 논문에서 제시되었다.

    따라서 구분 연속성을가 반전-의 제어에서의 환상을 만드는 "나는 다시 내부 전화"를 "당신은 다시 외부에서 내게 전화".

    F의 리턴 타입 참고하지만, K, 즉 F 리셋 한 F 복귀와 같은 형태로 K에 대한 리턴 타입을 선언 할 수있는 자유를 갖는, 리셋 복귀 유형과 같을 필요하지 않다. 읽기 및 캡처 동감 (아래도 ENV 참조).

    구분 연속성을 상태, 예를 들어,의 제어 반전하지 암시 할 읽고 순수 함수는 콜백하지 않습니다. 따라서 호출자는 선언적 (일명 투명) 제어가 필수적 의미를 목적으로하지 않습니다 따라서 referentially 투명 표현을 만들고 수 없습니다.

    우리는 명시 적으로 구분 연속성을 순수 기능을 달성 할 수있다.

    def aread(env: ENV): Tuple2[Byte,ENV] {
  def read(callback: Tuple2[Byte,ENV] => ENV): ENV = env.myCallback(callback)
  shift(read)
}
def pure(val env: ENV): ENV {
  reset {
    val (byte1, env) = aread(env)
    val env = env.println("byte1 = " + byte1)
    val (byte2, env) = aread(env)
    val env = env.println("byte2 = " + byte2)
  }
}

    나는이가 동등한 논리로 번역 될 것입니다 생각 :

    def read(callback: Tuple2[Byte,ENV] => ENV, env: ENV): ENV =
  env.myCallback(callback)
def pure(val env: ENV): ENV {
  read(callback,env)
  def callback(x: Tuple2[Byte,ENV]): ENV {
    val (byte1, env) = x
    val env = env.println("byte1 = " + byte1)
    read(callback2,env)
    def callback2(x: Tuple2[Byte,ENV]): ENV {
      val (byte2, env) = x
      val env = env.println("byte2 = " + byte2)
    }
  }
}

    이 때문에 명시 적 환경의 시끄러운지고 있습니다.

    접선 노트, 스칼라, 따라서 지금까지의 내가 상태 모나드의 장치에 암시 적 해제를 지원하지 수 알고 (명시 적 환경을 숨기기위한 하나 개의 가능한 전략으로) 하스켈의 글로벌 타입 추론을하지 않고 하스켈의 글로벌 (힌들리 - 밀너) 형 때문에 추론은 다이아몬드 여러 가상 상속을 지원하지에 따라 달라집니다.

  4. ==============================

    4.연속 촬영은 계산의 상태는 나중에 호출 할 수 있습니다.

    연속 촬영은 계산의 상태는 나중에 호출 할 수 있습니다.

    시프트 식을 남기고 함수로서 식 리셋을두고 사이 계산 생각. 이 함수를 K라고 시프트 식 내부는 연속이다. 당신은 한 번 이상, 나중에 호출을 주위에 전달할 수 있습니다.

    나는 다시 표현에 의해 반환되는 값이 =>하지만 이것에 대해 내가 아주 확실하지 않다 애프터 시프트 식 내부 식의 값이라고 생각합니다.

    그래서 연속성을 사용하면 함수의 코드 다소 임의 및 로컬이 아닌 조각을 마무리 할 수 ​​있습니다. 이는 예컨대 coroutining 또는 되돌아 비표준 제어 흐름을 구현하기 위해 사용될 수있다.

    연속 요청은 시스템 레벨에서 사용되어야합니다 그래서. 응용 프로그램 코드를 통해를 뿌리는 것은 지금까지 수 고토를 사용하여 최악의 스파게티 코드보다 훨씬 더 악몽에 대한 확실한 조리법 될 것입니다.

    면책 조항 : 나는 스칼라의 연속성을 이해 깊이 더있다, 난 그냥 예보고 제도에서 연속성을 아는에서 그것을 유추합니다.

  5. ==============================

    5.내 관점에서 최선의 설명은 여기에 주어졌다 : http://jim-mcbeath.blogspot.ru/2010/08/delimited-continuations.html

    내 관점에서 최선의 설명은 여기에 주어졌다 : http://jim-mcbeath.blogspot.ru/2010/08/delimited-continuations.html

    예 중 하나 :

    reset {
    println("A")
    shift { k1: (Unit=>Unit) =>
        println("B")
        k1()
        println("C")
    }
    println("D")
    shift { k2: (Unit=>Unit) =>
        println("E")
        k2()
        println("F")
    }
    println("G")
}

    A
B
D
E
G
F
C
  6. ==============================

    6.또 다른 (최근 - 2016 년 5 월) 스칼라 연속 요청에 대한 기사입니다 : "스칼라의 시간 여행 : 스칼라에서 CPS (스칼라의 계속)"에 의해 Shivansh 스리 바스타 바 (shiv4nsh). 또한 드미트리 Bespalov의 대답에 언급 된 짐 McBeath의 기사를 의미합니다.

    또 다른 (최근 - 2016 년 5 월) 스칼라 연속 요청에 대한 기사입니다 : "스칼라의 시간 여행 : 스칼라에서 CPS (스칼라의 계속)"에 의해 Shivansh 스리 바스타 바 (shiv4nsh). 또한 드미트리 Bespalov의 대답에 언급 된 짐 McBeath의 기사를 의미합니다.

    그러나 그 전에, 그렇게 같은 Continuations를 설명합니다 :

    스칼라 2.11.0-RC1을 위해 2014 년 4 월 발표로 즉, 말했다되고

    7. from https://stackoverflow.com/questions/1512930/what-are-scala-continuations-and-why-use-them by cc-by-sa and MIT license

'SCALA' 카테고리의 다른 글

[SCALA] 간단한 경우 클래스에 대한 주문을 정의하기 쉬운 관용적 방법  (0) 2019.11.10
[SCALA] 방법에 대한-함축 스칼라와 루프 최적화?  (0) 2019.11.10
[SCALA] HLists는 튜플을 작성하는 뒤얽힌 방식보다 더 아무것도?  (0) 2019.11.10
[SCALA] 스파크 작업을 작성할 때 SparkContext.getOrCreate를 사용하지 않는 이유가 있나요?  (0) 2019.11.10
[SCALA] UDF 함수는 충분히 큰 입력 변수에 동의하지 스파크 DataFrames  (0) 2019.11.10
,

티스토리툴바