That's not generally true (but I will give my guess about your assumption after this). See the example in the article I linked:

```

import Data.Char(toUpper)

main = do 
       inpStr <- readFile "input.txt"
       writeFile "output.txt" (map toUpper inpStr)
```

Here, `inputStr` has to be evaluated in order to run `map toUpper` on it,
but it's done character by character. Character is read, `toUpper` is run on it, it's written to the file.
(Though it might not be a character unless we use `NoBuffering`, it's going to be lines or blocks)

Now, I guess your assumption _might_ be true in my case, because `show` might not be able to
generate the string character by character (which is very likely), in this case, show will give us the whole string in one
piece, leading to an out-of-memory error as the big string is getting loaded to memory in order to be used by `writeFile`.

This is just a guess, I would appreciate it if someone could actually prove it.

What do you think Imants?

-----Original Message-----
From: beginners-request <beginners-request@haskell.org>
To: beginners <beginners@haskell.org>
Sent: Sat, Oct 29, 2016 3:44 pm
Subject: Beginners Digest, Vol 100, Issue 20

Send Beginners mailing list submissions to beginners@haskell.org To subscribe or unsubscribe via the World Wide Web, visit http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners or, via email, send a message with subject or body 'help' to beginners-request@haskell.org You can reach the person managing the list at beginners-owner@haskell.org When replying, please edit your Subject line so it is more specific than "Re: Contents of Beginners digest..." Today's Topics: 1. Writing huge result of `show` to file results in out of memory (Mahdi Dibaiee) 2. Re: Writing huge result of `show` to file results in out of memory (Imants Cekusins)
Attached Message
From Mahdi Dibaiee <mdibaiee@aol.com>
To beginners@haskell.org
Subject [Haskell-beginners] Writing huge result of `show` to file results in out of memory
Date Fri, 28 Oct 2016 12:57:22 -0400
I know that there are other ways of doing it, I just want to understand
where lies the problem here.

I just read the realworldhaskell book by O'Reilly, in one section, Lazy I/O [0], it's explained
that there should be no problem writing big strings, without consuming the whole string
to files, however big they are.

I would appreciate it if someone could point out the problem there.

Thanks

[0]: http://book.realworldhaskell.org/read/io.html#io.lazy
Attached Message
From Imants Cekusins <imantc@gmail.com>
To The Haskell-Beginners Mailing List - Discussion of primarily beginner-level topics related to Haskell <beginners@haskell.org>
Subject Re: [Haskell-beginners] Writing huge result of `show` to file results in out of memory
Date Fri, 28 Oct 2016 19:13:23 +0200
> there should be no problem writing big strings, without consuming the whole string
lazy means evaluated when needed. However when a string is evaluated, it is evaluated fully, I guess.
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners