Re: Generators/coroutines in future Ada?

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

"J-P. Rosen" <rosen@adalog.fr> writes:
> AFAIU, generators are functions with states, where the returned value at
> one call depends on the state that was left behind by the previous call.
> This can easily be achieved with a function within a package, where the
> package serves to protect and hide the function's state.

It's not always so easy though.  Generators can yield from other
generators, so doing them as functions with states can require the
states to be stacks or collections of stacks.  Doing it with tasks is
more natural, but Ada tasks can be heavyweight, e.g. mapping to Posix
threads.

In Haskell, generators aren't even explicit: every list is automatically
a generator.  Here's an example which would be quite messy in Ada:
a 5-smooth number a/k/a Hamming number is a number with no prime factors
greater than 5.  The first 20 of them are:

  1,2,3,4,5,6,8,9,10,12,15,16,18,20,24,25,27,30,32,36

Problem: find the 1500th Hamming number (answer: 859963392).  This is a
classic Haskell problem solved by merging corecursively generated lists:

    hamming = 1 : m 2 `merge` m 3 `merge` m 5 where
      m k = map (k *) hamming
      xxs@(x:xs) `merge` yys@(y:ys) = case x `compare` y of
        LT -> x : (xs `merge` yys)
        EQ -> x : (xs `merge` ys)
        GT -> y : (xxs `merge` ys)

    main = print (hamming !! 1499)

This prints the answer instantly (0.004 seconds elapsed, mostly in the
operating system).  I remember doing it in C++ and it was a page or so
of ugly code.