PFDScala | Scala implementations for various exercises | Functional Programming library

Plain old natural numbers will not do the trick, because you can't calculate the natural number length of an infinite list in finite time. However, lazy natural numbers can do it.

The execution engine starts off with a pointer to your loop, and lazily expands it as it needs to find out what IO action to execute next. With your definition of forever, here's what a few iterations of the loop like like in terms of "objects stored in memory":

In Haskell these kinds of things aren't the most trivial ones, indeed. You would really like to have some in-place mutations going on to save up on memory and time, so I don't see any better way than equipping the frightening ST monad.

This could be done over various data structures, arrays, vectors, repa tensors. I chose HashTable from hashtables because it is the simplest to use and is performant enough to make sense in my example.

First of all, introduction:

Haskell values have types. Each value has a type. One type. It can't be two different types at the same time.

Thus, since x is returned as the result of if's consequent, the type of the whole if ... then ... else ... expression is the same as x's type.

An if expression has a type. Thus both its consequent and alternative expression must have that same type, since either of them can be returned, depending on the value of the test. Thus both must have the same type.

Since x is also used in the test, it must be Bool. Then so must be y.

Dyalog APL does not officially support function arrays, you can awkwardly emulate them by creating an array of namespaces with identically named functions.

To expand on the answer given in the comments, the first p is an immutable value, while the second p is a function. If you refer to an immutable value multiple times, then (obviously) its value doesn't change over time. But if you invoke a function multiple times, it executes each time, even if the arguments are the same each time.

Note that this is true even for pure functional languages, such as Haskell. If you want to avoid this execution cost, there's a specific technique called memoization that can be used to return cached results when the same inputs occur again. However, memoization has its own costs, and I'm not aware of any mainstream functional language that automatically memoizes all function calls.

Reader's type parameters aren't in the right order for that to be contramap for it. A Contravariant functor always needs to be contravariant in its last type parameter, but Reader is contravariant in its first type parameter. But you can do this:

Laziness isn't all-or-nothing, but some implementations of seq operate on 'chunks' of the input sequence (see here for an explanation). This is the case for vector which you can test for with chunked-seq?:

Lists in Haskell are special in syntax, but not fundamentally.

Fundamentally, Haskell list is defined like this: