fpinscala | go along with the book `` Functional Programming | Learning library

1. No. If you put a breakpoint on the println you'll find that the method is actually being called when you first create the Stream. The line Stream(printAndReturn, ... actually calls your method however many times you put it there. Why? Consider the type signatures for cons and apply:

I note that your Cons class already has a public tail member. I'd be tempted to start there and just make it universal...

As @jwvh already pointed out, get is a method defined in object State. The get-method is neither applied to any Machine nor is a Machine used as parameter, because the function has the following signature:

Well, you seem to be mostly comprehensive to me. Nevertheless, I would clarify some points:

• I'd rather say "so I suppose f.curried is working because A => (B => B) is the same as (A => B => B)" (it is ambiguous here and you're talking about f.curried result type basically, not with z)
• I'd rather put a point instead of a comma here: "foldMap is expecting a function f: A => B . In foldRight, ... " and pretty much every where else. Shorter phrases, clearer explanation.
• what could be an error, (and what is confusing to you?) is that (f.curried)(z) doesn't work on its own and is not called after foldMap(as, endoMonoid[B]). It's first foldMap(as, endoMonoid[B])(f.curried) which is called and then (z). The first returns B => B and called with the second returns B.

You've written an implementation that has the same signature as foldRight, but it doesn't have the right semantics when the combination operation isn't commutative. To take one example, a right fold with the empty list as zero and cons as the combination operation should be identity:

OK, after a long investigation I believe I have an answer. The full story is long but I'll try to shorten it by simplifying and avoiding many details.

Note: Potentially Scala can be compiled to various different target platforms but this particular issue happened on the Java/JVM as the target so this is what this answer is about.

The deadlock you see has nothing to do with the size of the thread pool. Actually it is the outer fork call that hangs. It is related to a combination of REPL implementation details and multi-threading but it takes learning a few pieces to understand how it happens:

• how Scala REPL works
• how Scala compiles objects to Java/JVM
• how Scala emulates the by-name parameters on Java/JVM
• how Java/JVM runs the static initializers of classes

A short(er) version (see also Summary at the end) is that this code hangs under a REPL because when it is being executed by the REPL, it is logically similar to the following code:

supply a function as a lazy argument

For the fork function has a lazy argument a: => Par[A], that's means a will not eval when fork(a) until it's submitted to ExecutorService with a Callable, since a's response type also Par[A], it will also asynchronously eval again, and also can recursively fork execute with the same ExecutorService.

So for my understanding, the fork with lazy argument a: => Par[A], it will have the ability of parallel and recursively fork tasks.

In Scala, lazy function: it means lazy evaluation until invoke this function. for your example, you are declaring a lazy function a: => Par[A], so when you call fork method like: fork(myFunction()), this will not evaluate myFunction immediately, it only will eval when a(es).get executed.

Example:

The tuple is the argument to the foldRight call: (z, Stream(z)). The first value in the tuple is the result of the scan so far. The second value is the Stream that will be the eventual result of the scanRight call.

Each pass of the fold updates the result of the scan by calling f on the current value in the sequence (a) and the previous scan value (the first element in the tuple). The result is added to the stream (in the second element of the tuple) using cons. Both values are passed on to the next iteration of the fold as a new tuple.

When the fold finishes it returns the tuple, but only the second element is required by scanRight so is extracted from that tuple (._2) and returned.

I think it is because with the lazy implementation, you are creating the object only once, and memoizing it, so when you call constant, you are referring to the same object over and over again, something like this: