List of Dictionary's vs Sequence of Dictionary's - f#

Question

I am having trouble understanding the difference between F#'s List and Seq in this example. I thought that the main difference was that Seq was kind of lazy, but I must be missing something.
This code snippet:
open System.Collections.Generic
let arr =
["a"; "b"; "c"]
|> Seq.map (fun a -> let dic = Dictionary () in dic.Add("key", a); dic) in
arr
|> Seq.iter (fun a ->
printfn "here";
a.["key"] <- "something"
);
arr
|> Seq.iter (fun a -> printfn "%s" a.["key"])
Gives
here
here
here
a
b
c
Whereas (replacing the first Seq with List)
open System.Collections.Generic
let arr =
["a"; "b"; "c"]
|> List.map (fun a -> let dic = Dictionary () in dic.Add("key", a); dic) in
arr
|> Seq.iter (fun a ->
a.["key"] <- "something"
);
arr
|> Seq.iter (fun a -> printfn "%s" a.["key"])
Gives
something
something
something
Why do the Dictionary values not change when I use Seq? The elements are clearly visited as the here is printed.
Thanks in advance.

Answer 1

The reason is precisely that Seq is "kind of lazy", as you put it.
It's "lazy" in the sense that it gets evaluated every single time you ask it to. All of it. Up to the last non-lazy thing.
In particular, the call to Seq.map is lazy. It does not create a new structure in memory that is full of dictionaries. Instead, it creates something that you could call a "pipeline". This pipeline starts with your list ["a"; "b"; "c"] and then there is an instruction: every time somebody tries to iterate over this sequence, create a new dictionary for every element. The "every time" bit is important there - since you're iterating over the sequence twice (once to print "here" and another time to print the values), the dictionaries get created twice as well. The dictionary into which you push "something" and the dictionary from which you obtain "key" are not the same dictionary.
To illustrate further, try this:
let s = ["a";"b";"c"] |> Seq.map( fun x -> printfn "got %s" x; x )
s |> Seq.iter(printfn "here's %s")
s |> Seq.iter(printfn "again %s")
This will print the following:
got a
here's a
got b
here's b
got c
here's c
got a
again a
got b
again b
got c
again c
See how the "got" output happens twice for each element? That's because Seq.map works every time you iterate, not just once.
Not so with lists. Every time you List.map, you create a whole new list in memory. It just sits there forever (where "forever" is defined "until garbage collector gets to it") and waits for you to do something with it. If you do multiple things with it, it's still the same list, it doesn't get re-created. That is why your dictionaries are always the same dictionaries, they don't get created anew, like the ones in Seq. That is why you can modify them and see the modifications next time you look.
You can achieve a similar, though not quite identical effect with sequences with the help of Seq.cache. This function takes a regular on-demand-evaluating sequence and returns you a sequence that is identical, except every element only gets evaluated once.
Unlike a list though, Seq.cache will not evaluate the whole sequence the moment it's called. Instead, it will create a mutable cache, which gets updated every time you evaluate.
This is useful for cases when a sequence is very large, or even infinite, but you only need to work with a small finite number of elements at the start of it.
Illustration:
let s = ["a";"b";"c"]
|> Seq.map( fun x -> printfn "got %s" x; x )
|> Seq.cache
s |> Seq.iter(printfn "here's %s")
s |> Seq.iter(printfn "again %s")
Output:
got a
here's a
got b
here's b
got c
here's c
again a
again b
again c

Answer 2

I added some printfns to both examples so you can see the difference:
let arr =
["a"; "b"; "c"]
|> Seq.map (fun a -> printfn "seq: %s" a
let dic = Dictionary ()
dic.Add("key", a)
dic)
arr
|> Seq.iter (fun a ->
printfn "here seq"
a.["key"] <- "something"
)
arr
|> Seq.iter (fun a -> printfn "%s" a.["key"])
produces the following output:
seq: a
here seq
seq: b
here seq
seq: c
here seq
seq: a
a
seq: b
b
seq: c
c
While this one:
let arr =
["a"; "b"; "c"]
|> List.map (fun a -> printfn "list: %s" a
let dic = Dictionary ()
dic.Add("key", a)
dic)
arr
|> Seq.iter (fun a ->
printfn "here list";
a.["key"] <- "something"
)
arr
|> Seq.iter (fun a -> printfn "%s" a.["key"])
produces this output:
list: a
list: b
list: c
here list
here list
here list
something
something
something
As you can see the behavior is quite different.
Seq.map is lazy which means it remains as a function to be invoked later only when strictly necessary. Every time it is invoked it starts from the beginning mapping each element as they are needed. Seq.map gets called twice, one for each Seq.iter and every time it creates a new Dictionary for each element which then is discarded by the garbage collector.
On the other hand, List.map gets invoked only once and it goes over the whole input list creating a new list of dictionaries only one time.