स्कैला में "कॉल-सीसी" पैटर्न?

Question

मुझे एक अच्छा article मिला, लगभग call with current continuation पैटर्न। जैसा कि मैं समझता हूं, वे योजना और undelimited continuations का उपयोग करते हैं। क्या लेख से पैटर्न स्कैला में लागू किए जा सकते हैं? क्या स्कैला में delimited continuations पैटर्न के बारे में कोई लेख है?

Answer 1

हां, वे बिल्कुल कर सकते हैं। callCC स्काला में इस तरह दिखता है:

def callCC[R, A, B](f: (A => Cont[R, B]) => Cont[R, A]): Cont[R, A] = 
    Cont(k => f(a => Cont(_ => k(a))) run k) 

कहाँ Cont एक डेटा संरचना है कि एक निरंतरता कब्जा है:

def divExcpt[R](x: Int, y: Int, h: String => Cont[R, Int]): Cont[R, Int] = 
    callCC[R, Int, String](ok => for { 
    err <- callCC[R, String, Unit](notOK => for { 
      _ <- if (y == 0) notOK("Denominator 0") else Cont[R, Unit](_(())) 
      r <- ok(x/y) 
      } yield r) 
    r <- h(err) 
    } yield r) 

:

case class Cont[R, A](run: (A => R) => R) { 
    def flatMap[B](f: A => Cont[R, B]): Cont[R, B] = 
    Cont(k => run(a => f(a) run k)) 
    def map[B](f: A => B): Cont[R, B] = 
    Cont(k => run(a => k(f(a)))) 
} 

यहाँ कैसे आप इसका इस्तेमाल कर सकते हैं जांचे हुए अपवादों अनुकरण करने के लिए है आप इस फ़ंक्शन को निम्नानुसार कॉल करेंगे:

scala> divExcpt(10, 2, error) run println 
5 

scala> divExcpt(10, 0, error) run println 
java.lang.RuntimeException: Denominator 0 

Answer 2

स्कैला में टाइप की गई सीमित निरंतरता का कार्यान्वयन होता है जिसे कंपाइलर और मानक लाइब्रेरी के साथ भेज दिया जाता था, लेकिन इसे external module पर निकाला गया था और तब से बहुत सड़ने के लिए छोड़ दिया गया था। यह एक बड़ी शर्म की बात है, और मैं उन सभी को प्रोत्साहित करता हूं जो सीमित निरंतरताओं में दिलचस्पी रखते हैं ताकि वे यह दिखा सकें कि वे इसका अस्तित्व और योगदान करके इसका अस्तित्व रखते हैं।