News for hackers. Stuff that matters.
Re:Clojure Don’ts: Lazy Effects (2015) by kerkeslager on Saturday March 03, 2018 @11:48AM (#16510112)
I don't think it really makes sense to call the way side effects happen in Haskell "lazy".

The way I think about it is that it's not so much that your program executes a lazy stream of side effects, it's that your program doesn't execute side effects at all. Instead, your program returns a pure structure which describes how side effects should be executed, and the runtime executes a program based on this description. By the time the runtime is executing that program, the pure structure which describes how the side effects should be executed has already been forced, so the side effects happen eagerly within that context.

That said, I'm not much of a Haskell-er, so I'd be interested to hear from more experienced Haskell programmers on whether there's a better way to think about this.

Re:Clojure Don’ts: Lazy Effects (2015) by wz1000 on Saturday March 03, 2018 @12:48PM (#16510473)
Haskell does have lazy side effects(unsafeInterleaveIO and its derivatives), which is a major source of complaints about the haskell standard library(lazy IO). There is a huge library ecosystem(conduit, pipes, streaming, machines, what have you) to solve this problem.

For example, this code will fail because the file handle is closed prematurely by withFile as hGetContents returns immediately without actually reading the file, deferring that part until the data is forced.

    main = do
      contents <- withFile "foo.txt" ReadMode hGetContents
      putStrLn $ length contents
Re:Clojure Don’ts: Lazy Effects (2015) by taeric on Saturday March 03, 2018 @01:46PM (#16510818)
I'm assuming there is a more idiomatic (nay, correct?) way of doing this in Haskell?
Re:Clojure Don’ts: Lazy Effects (2015) by danidiaz on Saturday March 03, 2018 @02:29PM (#16511048)
One possible solution is to take a "beautiful fold" http://hackage.haskell.org/package/foldl-1.3.7/docs/Control-... and connect it to an effectful stream of bytes http://hackage.haskell.org/package/pipes-bytestring-2.1.6/do... inside the callback of "withFile".

Not unlike the Streams/Collectors framework in Java.

Re:Clojure Don’ts: Lazy Effects (2015) by taeric on Saturday March 03, 2018 @02:35PM (#16511090)
But... does that work? Doesn't that leave you open to having something evaluate the end of the "withFile" before you evaluated something in the callback?

That is, the only reason what you said is accurate, is because you said "effectful stream of bytes" meaning "eagerly effectful." Right? If you do all of that lazily, you can just as easily shoot yourself in the foot here.

(Please nobody take this as a damning criticism of Haskell. I'm not intending it that way.)

Re:Clojure Don’ts: Lazy Effects (2015) by danidiaz on Saturday March 03, 2018 @03:20PM (#16511339)
The streams/sinks work in the IO monad and that induces an ordering of the effects, yes. Within the callback, you can still do things like filtering or taking only a part of the stream.

Returning the stream itself from the "withFile" and trying to run it later still is still a bug.

I like this approach better that conventional Haskell lazy I/O, which I personally find quite confusing.

Re:Clojure Don’ts: Lazy Effects (2015) by taeric on Saturday March 03, 2018 @05:40PM (#16512102)
I guess it just surprises me that having to worry about the state of a stream is a thing I have to do. More, it sounds like I can't really use the typesystem to help here. At least, not from the sound of it.
Re:Clojure Don’ts: Lazy Effects (2015) by Tarean on Saturday March 03, 2018 @08:05PM (#16512704)
In praxis a streaming library like pipes, streaming or conduit handles the file handles for you so application code is safe. Safe-ish in the case of streaming but that is a conscious tradeoff between convenience and safety.

You could argue that libraries shouldn't contain unsafe code either and go with a substructural type system, use indexed monads, fake regions or something similar. Whether the extra complexity is worth it is arguable, though.

Re:Clojure Don’ts: Lazy Effects (2015) by willtim on Saturday March 03, 2018 @12:46PM (#16510461)
> I don't think it really makes sense to call the way side effects happen in Haskell "lazy".

I didn't actually say this. I was suggesting a lazy chain of IO actions for such problems. For example, ListT a IO, instead of a regular lazy list with hidden side-effects. The Haskell types help make the distinction clear.

> Instead, your program returns a pure structure which describes how side effects should be executed

Yes exactly, the pure structure can still be computed lazily on demand, providing IO actions.

My favourite Hackage streaming library for Haskell is "streaming" and it can work exactly this way.

Re:Clojure Don’ts: Lazy Effects (2015) by Tarean on Saturday March 03, 2018 @08:10PM (#16512723)
Worth noting that ListTs bind isn't associative for most base monads including IO and it is deprecated for a reason.

Also, by it's nature ListT can't stream IO unless you use lazy IO aka lazyRead aka unsafeInterleaveIO which deserves its name.

Re:Clojure Don’ts: Lazy Effects (2015) by willtim on Sunday March 04, 2018 @02:22AM (#16513651)
I am assuming "ListT done right" not the deprecated one (which is not even a chain of actions). Here is a definition, to be completely clear:

newtype ListT m a = ListT (m (Maybe (a, ListT m a)))

It is a nice simple example of an effectful streaming type.

> Also, by it's nature ListT can't stream IO

This is only true of the deprecated one, which is also misnamed. The community is rightly re-using the name for the behaviour shown above. See list-t on hackage, or the implementation that comes with Pipes.