Cont stands for Continuation. A continuation basically represents a 'suspended' computation with an intermediate result of type 'a' and final result of type 'r'

    type Cont r a = (a -> r) -> r

Cont is a type constructor that takes two type arguments, r and a. This means that Cont r a can always be substituted by (a -> r) -> r. For example, Cont String Int is equivalent to (Int -> String) -> String

(a -> r) is the type of a function from a to r. For example, Int -> Bool is the type of a function from Int to Bool. (a -> r) -> r is the type of a function that takes a function from (a -> r) as its argument and returns an r. So Cont String Int takes a function from Int to String as its argument and finally returns a String.

http://www.haskellforall.com/2012/12/the-continuation-monad.... https://begriffs.com/posts/2015-06-03-haskell-continuations....

My eyes glazed over as they usually do when trying to grok Haskell, but is that somehow related to partial computation and partial functions?

Not really to do with partial evaluation or the unrelated idea of a partial function.

A key motivating (non-Haskell) example behind continuations is the idea of replacing "return" with a function call. This is continuation passing style, and obviously when you call a subroutine in CPS, you need to give it a function to call when it completes: a "continuation" which is contrived to be equivalent to what would happen when that particular subroutine "returned" in normal direct style

read the right hand side as roughly:

    func(func(a): b): b

> I'm reading it as 'Container' passed 'r' and 'a' performs 'a' to 'r' which returns 'r'. (I'm guessing on verbs here).

This is an equation; it's a relating/defining one thing in terms of other things. In particular, there's no concept of "performing" (e.g. there's no time, state, etc. here)

In this case "Cont" is just a name; we can tell that, since the equation tells us that "Cont r a" is equal to some other thing involving "r" and "a", so we could just as well use that other thing (that's what it means for two things to be equal!). Hence, "Cont r a" is just a shorthand for "(a -> r) -> r".

So what is "(a -> r) -> r"? In general, for any types "x" and "y", the type "x -> y" is the type of functions which take an "x" as input and return a "y".

So "a -> r" is a function which takes an "a" and returns an "r".

So "(a -> r) -> r" is a function which takes a function from "a" to "r", and returns an "r".

Cont is one of the trickier monads to "get".

Cont r a is a computation that knows how to produce an "a" but, instead of returning it directly, passes it to a function that takes the "a" and produces an "r".

Compared to typical sequential execution, this gives more power to the "current" phase of the computation, because it might choose to invoke the passed a -> r function more than one time, none at all, inspect the resulting "r" and change course based on the result, etc.

I read this as 'A cont of type r a is a function that, given a function of type a to r, returns an r'.

Cont refers to the continuation monad. For details see http://www.haskellforall.com/2012/12/the-continuation-monad....