Why does iterating previously read-in sequence trigger a new read?

Question

In this SO post, adding

 inSeq 
    |> Seq.length
    |> printfn "%d lines read"

caused the lazy sequence in inSeq to be read in.

OK, I've expanded on that code and want to first print out that sequence (see new program below).

When the Visual Studio (2012) debugger gets to

inSeq |> Seq.iter (fun x -> printfn "%A" x)

the read process starts over again. When I examine inSeq using the debugger, inSeq appears to have no elements in it.

If I have first read elements into inSeq, how can I see (examine) those elements and why won't they print out with the call to Seq.iter?

open System
open System.Collections.Generic
open System.Text
open System.IO
#nowarn "40"


let rec readlines () =
    seq {
        let line = Console.ReadLine()
        if not (line.Equals("")) then
            yield line
            yield! readlines ()
}

[<EntryPoint>]
let main argv = 
    let inSeq = readlines ()

    inSeq 
    |> Seq.length
    |> printfn "%d lines read"

    inSeq |> Seq.iter (fun x -> printfn "%A" x)
    // This will keep it alive enough to read your output
    Console.ReadKey() |> ignore    
    0

I've read somewhere that results of lazy evaluation are not cached. Is that what is going on here? How can I cache the results?

Answer 1

Sequence is not a "container" of items, rather it's a "promise" to deliver items sometime in the future. You can think of it as a function that you call, except it returns its result in chunks, not all at once. If you call that function once, it returns you the result once. If you call it second time, it will return the result second time.

Because your particular sequence is not pure, you can compare it to a non-pure function: you call it once, it returns a result; you call it second time, it may return something different.

Sequences do not automatically "remember" their items after the first read - exactly same way as functions do not automatically "remember" their result after the first call. If you want that from a function, you can wrap it in a special "caching" wrapper. And so you can do for a sequence as well.

The general technique of "caching return value" is usually called "memoization". For F# sequences in particular, it is implemented in the Seq.cache function.