[scala] Scala 연속 형이란 무엇이며 왜 사용합니까?

의미있는 예제를 통한 스칼라 연속

from0to100에서 10까지 반복의 개념을 표현 하는 것을 정의합시다 .

def from0to10() = shift { (cont: Int => Unit) =>
   for ( i <- 0 to 10 ) {
     cont(i)
   }
}

지금,

reset {
  val x = from0to10()
  print(s"$x ")
}
println()

인쇄물:

0 1 2 3 4 5 6 7 8 9 10

실제로 다음은 필요하지 않습니다 x.

reset {
  print(s"${from0to10()} ")
}
println()

동일한 결과를 인쇄합니다.

과

reset {
  print(s"(${from0to10()},${from0to10()}) ")
}
println()

모든 쌍을 인쇄합니다.

(0,0) (0,1) (0,2) (0,3) (0,4) (0,5) (0,6) (0,7) (0,8) (0,9) (0,10) (1,0) (1,1) (1,2) (1,3) (1,4) (1,5) (1,6) (1,7) (1,8) (1,9) (1,10) (2,0) (2,1) (2,2) (2,3) (2,4) (2,5) (2,6) (2,7) (2,8) (2,9) (2,10) (3,0) (3,1) (3,2) (3,3) (3,4) (3,5) (3,6) (3,7) (3,8) (3,9) (3,10) (4,0) (4,1) (4,2) (4,3) (4,4) (4,5) (4,6) (4,7) (4,8) (4,9) (4,10) (5,0) (5,1) (5,2) (5,3) (5,4) (5,5) (5,6) (5,7) (5,8) (5,9) (5,10) (6,0) (6,1) (6,2) (6,3) (6,4) (6,5) (6,6) (6,7) (6,8) (6,9) (6,10) (7,0) (7,1) (7,2) (7,3) (7,4) (7,5) (7,6) (7,7) (7,8) (7,9) (7,10) (8,0) (8,1) (8,2) (8,3) (8,4) (8,5) (8,6) (8,7) (8,8) (8,9) (8,10) (9,0) (9,1) (9,2) (9,3) (9,4) (9,5) (9,6) (9,7) (9,8) (9,9) (9,10) (10,0) (10,1) (10,2) (10,3) (10,4) (10,5) (10,6) (10,7) (10,8) (10,9) (10,10)

자, 어떻게 작동합니까?

있다 라는 코드 , from0to10및 호출 코드 . 이 경우 뒤에 오는 블록입니다 reset. 호출 된 코드에 전달 된 매개 변수 중 하나는 호출 코드의 어떤 부분이 아직 실행되지 않았는지 보여주는 반환 주소입니다 (**). 호출 코드의 해당 부분은 연속 입니다. 호출 된 코드는 해당 매개 변수로 제어를 전달하거나 무시하거나 여러 번 호출 할 수 있습니다. 여기서는 from0to100..10 범위의 각 정수에 대한 연속을 호출합니다.

def from0to10() = shift { (cont: Int => Unit) =>
   for ( i <- 0 to 10 ) {
     cont(i) // call the continuation
   }
}

그러나 계속은 어디에서 끝날까요? return연속 의 마지막 이 호출 된 코드로 제어를 반환 하기 때문에 이것은 중요 합니다 from0to10. Scala에서는 reset블록이 끝나는 곳 (*)에서 끝납니다.

이제 연속이 cont: Int => Unit. 왜? 우리는 호출 from0to10로 val x = from0to10(), 그리고 Int에 간다 값의 유형이다 x. Unit이후 블록 reset은 값을 반환하지 않아야 함을 의미합니다 (그렇지 않으면 유형 오류가 발생 함). 일반적으로 함수 입력, 연속 입력, 연속 결과, 함수 결과의 4 가지 타입 시그니처가 있습니다. 네 가지 모두 호출 컨텍스트와 일치해야합니다.

위에서 우리는 값 쌍을 인쇄했습니다. 곱셈표를 인쇄 해 보겠습니다. 그러나 \n각 행 후에 어떻게 출력 합니까?

이 함수를 back사용하면 제어가 다시 호출 될 때 수행해야하는 작업을 연속에서 호출 한 코드까지 지정할 수 있습니다.

def back(action: => Unit) = shift { (cont: Unit => Unit) =>
  cont()
  action
}

back먼저 연속을 호출 한 다음 작업 을 수행합니다 .

reset {
  val i = from0to10()
  back { println() }
  val j = from0to10
  print(f"${i*j}%4d ") // printf-like formatted i*j
}

다음을 인쇄합니다.

   0    0    0    0    0    0    0    0    0    0    0
   0    1    2    3    4    5    6    7    8    9   10
   0    2    4    6    8   10   12   14   16   18   20
   0    3    6    9   12   15   18   21   24   27   30
   0    4    8   12   16   20   24   28   32   36   40
   0    5   10   15   20   25   30   35   40   45   50
   0    6   12   18   24   30   36   42   48   54   60
   0    7   14   21   28   35   42   49   56   63   70
   0    8   16   24   32   40   48   56   64   72   80
   0    9   18   27   36   45   54   63   72   81   90
   0   10   20   30   40   50   60   70   80   90  100

글쎄, 이제는 두뇌 트위스터를 할 때입니다. 의 두 가지 호출이 from0to10있습니다. 첫 번째 연속은 무엇입니까 from0to10? 그것은의 호출은 다음과 from0to10에서 바이너리 코드를 하지만, 소스 코드에서 또한 할당 문을 포함한다 val i =. 그것은 reset블록 이 끝나는 곳에서 끝나지만 블록의 끝은 reset제어를 첫 번째 from0to10. 의 최종 reset블록 반환 2에 제어를 from0to10차례로 결국 제어를 반환, back하고는 back반환의 첫 번째 호출을 제어하는 from0to10. 첫 번째 (예! 첫 번째!)가 from0to10종료되면 전체 reset블록이 종료됩니다.

제어를 되 돌리는 이러한 방법을 역 추적 이라고하며 , 이는 적어도 Prolog 및 AI 지향 Lisp 파생물 시대부터 알려진 매우 오래된 기술입니다.

이름 reset과 shift잘못된 이름입니다. 이러한 이름은 비트 연산을 위해 남겨 두는 것이 좋습니다. reset연속 경계를 정의 shift하고 호출 스택에서 연속을 가져옵니다.

메모)

(*) Scala에서 연속은 reset블록이 끝나는 곳에서 끝납니다. 또 다른 가능한 접근 방식은 함수가 끝나는 곳에서 끝나도록하는 것입니다.

(**) 호출 된 코드의 매개 변수 중 하나는 호출 코드의 어떤 부분이 아직 실행되지 않았는지 보여주는 반환 주소입니다. 음, Scala에서는 일련의 반환 주소가 사용됩니다. 얼마나? reset블록에 들어간 이후 호출 스택에있는 모든 반환 주소 .

---

UPD 파트 2
연속 삭제 : 필터링

def onEven(x:Int) = shift { (cont: Unit => Unit) =>
  if ((x&1)==0) {
    cont() // call continuation only for even numbers
  }
}
reset {
  back { println() }
  val x = from0to10()
  onEven(x)
  print(s"$x ")
}

이것은 다음을 인쇄합니다.

0 2 4 6 8 10

두 가지 중요한 작업을 고려해 보겠습니다. 연속을 버리고 ( fail()) 제어를 전달 ( succ())합니다.

// fail: just discard the continuation, force control to return back
def fail() = shift { (cont: Unit => Unit) => }
// succ: does nothing (well, passes control to the continuation), but has a funny signature
def succ():Unit @cpsParam[Unit,Unit] = { }
// def succ() = shift { (cont: Unit => Unit) => cont() }

succ()(위) 의 두 버전 모두 작동합니다. shift재미있는 서명이있는 것으로 밝혀졌고 succ()아무것도하지 않지만 유형 균형을 위해 해당 서명이 있어야합니다.

reset {
  back { println() }
  val x = from0to10()
  if ((x&1)==0) {
    succ()
  } else {
    fail()
  }
  print(s"$x ")
}

예상대로 인쇄됩니다.

0 2 4 6 8 10

함수 내에서 succ()필요하지 않습니다.

def onTrue(b:Boolean) = {
  if(!b) {
    fail()
  }
}
reset {
  back { println() }
  val x = from0to10()
  onTrue ((x&1)==0)
  print(s"$x ")
}

다시, 그것은 인쇄

0 2 4 6 8 10

이제 다음을 onOdd()통해 정의하겠습니다 onEven().

// negation: the hard way
class ControlTransferException extends Exception {}
def onOdd(x:Int) = shift { (cont: Unit => Unit) =>
  try {
    reset {
      onEven(x)
      throw new ControlTransferException() // return is not allowed here
    }
    cont()
  } catch {
    case e: ControlTransferException =>
    case t: Throwable => throw t
  }
}
reset {
  back { println() }
  val x = from0to10()
  onOdd(x)
  print(s"$x ")
}

위에서 x짝수이면 예외가 발생하고 연속이 호출되지 않습니다. 경우 x홀수 예외가 발생되지 않고 계속 호출됩니다. 위의 코드는 다음을 인쇄합니다.

1 3 5 7 9