Re: How to get Ada to ?cross the chasm??

[Paul Rubin <no.email@nospam.invalid>]

Niklas Holsti <niklas.holsti@tidorum.invalid> writes:
>>     x = 1 : 2 : 3 : x
> Can you construct such a list in Haskell without using and setting
> explicit references?

If you mean writing the list without using x on both sides of the equal
sign, you could use a fixpoint combinator:
   
    Prelude Control.Monad.Fix> let f = fix ([1,2,3]++)
    Prelude Control.Monad.Fix> take 20 f
    [1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2]

But fix is written something like this:

   fix f = x where x = f x

and there's an explicit reference there.  There's a corresponding object
called the Y combinator in untyped lambda calculus that can be written
without such a reference, but I think it's not possible to write it that
way in a typed system, because of the "strong normalization" property of
typed lambda calculus.  There's some discussion here:

https://en.wikibooks.org/wiki/Haskell/Fix_and_recursion


> Is there some kind of "letrec" for recursive data objects (as opposed
> to recursive functions)?

There's no letrec per se, since ordinary let is allowed to be recursive.
Mathematically when self-reference happens in data rather than functions
it's called "corecursion" rather than recursion, but most people just
call such data recursive, slightly incorrectly I think.  Fwiw, recursive
data is supposedly called "codata".

There's an argument for eliminating unrestricted recursion from
programming so that all functions must eventually return, so codata is
the only way to implement non-termination (like if you wanted to write
an OS).  You get a programming language that's non-Turing-complete (you
can tell by inspection whether a given program halts, based on whether
it uses codata) but the claim is that Turing completeness is not that
useful in practice:

http://www.jucs.org/jucs_10_7/total_functional_programming