आईओ मोनड

Question

के साथ स्कालाज़ का ट्रैवर्स_ मैं आईओ मोनड का उपयोग करना चाहता हूं।

लेकिन यह कोड बड़ी फ़ाइल के साथ नहीं चला है। मुझे एक स्टैक ओवरफ्लो एरर मिल रहा है। मैंने -DXss विकल्प का प्रयास किया, लेकिन यह वही त्रुटि फेंकता है।

val main = for { 
    l <- getFileLines(file)(collect[String, List]).map(_.run) 
    _ <- l.traverse_(putStrLn) 
} yield() 

मैं यह कैसे कर सकता हूं?

---

मैंने आईटेरेट लिखा जो सभी तत्वों का उत्पादन करता है।

def putStrLn[E: Show]: IterV[E, IO[Unit]] = { 
    import IterV._ 
    def step(i: IO[Unit])(input: Input[E]): IterV[E, IO[Unit]] = 
    input(el = e => Cont(step(i >|> effects.putStrLn(e.shows))), 
     empty = Cont(step(i)), 
      eof = Done(i, EOF[E])) 
    Cont(step(mzero[IO[Unit]])) 
} 
val main = for { 
    i <- getFileLines(file)(putStrLn).map(_.run) 
} yield i.unsafePerformIO 

यह भी वही परिणाम है।

मुझे लगता है कि आईओ कार्यान्वयन के कारण होना चाहिए।

Answer 1

ऐसा इसलिए है क्योंकि स्केलैकloop को getReaderLines के अंदर पूंछ कॉल के लिए अनुकूलित नहीं कर रहा है। loop पूंछ रिकर्सिव है लेकिन मुझे लगता है कि case अज्ञात फ़ंक्शन सिंटैक्स रास्ते में आता है।

संपादित करें: असल में यह पूंछ रिकर्सिव (आईओ मोनैड में रैपिंग) भी रिकर्सिव कॉल के बाद कम से कम एक और कॉल का कारण बनता है। जब मैं कल अपना परीक्षण कर रहा था, तो मैं इसी तरह के कोड का उपयोग कर रहा था लेकिन मैंने आईओ मोनैड गिरा दिया था और फिर इटरेटे पूंछ को रिकर्सिव बनाना संभव था। नीचे दिया गया पाठ, कोई IO monad मानता है ...

मुझे कलरेट्स के साथ प्रयोग करते समय यह पता चला। मैं इस के लिए loop के हस्ताक्षर को बदलने लगता है कि मदद मिलेगी (समय के लिए तो किया जा रहा है आप reimplement को getFilesLines और getReaderLines हो सकता है:

@annotations.tailrec 
def loop(it: IterV[String, A]): IO[IterV[String, A]] = it match { 
    // ... 
} 

हम शायद इस scalaz लोक करने के लिए (रिपोर्ट करना चाहिए और एक वृद्धि टिकट खुला हो सकता है । स्केला) के लिए

इससे पता चलता है क्या थोड़ा getReaderLines.loop के समान (कोड) होता है:?

@annotation.tailrec 
def f(i: Int): Int = i match { 
    case 0 => 0 
    case x => f(x - 1) 
} 
// f: (i: Int)Int 

@annotation.tailrec 
def g: Int => Int = { 
    case 0 => 0 
    case x => g(x - 1) 
} 
/* error: could not optimize @tailrec annotated method g: 
it contains a recursive call not in tail position 
     def g: Int => Int = { 
         ^
*/