Re: If not Ada, what else...

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

Georg Bauhaus <bauhaus@futureapps.invalid> writes:
> Aren't these features (tail recursion, strict, ...) among the reasons
> why Haskell got lazy strategies in the first place?

Tail recursion is a standard FP thing and you have to do it in Scheme
and ML as well.  Haskell's lazy evaluation was an interesting experiment
that has its good and bad points.  The interesting next-generation FP
languages like Idris seem to have gone back to strict evaluation, though
there's stuff happening in the theory community that might show up in
languages further down the road, that might allow strict/lazy
combinations whose behavior is tracked by type systems better than has
been done in the past.

>> p2 xs m = sum . map head . takeWhile (not . null) . iterate (drop m) $ xs
> (Nitpick: This loops when m<=0, try "p2 [1] 0". (*)).  

Yeah, it was supposed to only be illustrative of how to compute the sum
without all that explicit recursion.  To handle the non-positve case, add
   p2 _ m | m <= 0 = 0

> {-# LANGUAGE BangPatterns #-}, news to me, thanks!), I waited minutes after
> intense disk swapping for
> *Main> p2 [1 .. 123456789] 6

OK, yeah, as predicted, the problem is that ghci isn't noticing it can
optimize sum as strict.  ghc -O would probably do it.  Try writing:

    import Data.List (foldl1')
    p2 :: [Int] -> Int -> Int
    p2 _ m | m <= 0 = 0
    p2 xs m = foldl1' (+)
              . map head
              . takeWhile (not . null)
              . iterate (drop m)
              $ xs

(Mostly the same thing, except for the formatting).

> Seems another feature of prototyping is apparent: can't use larger data sets.
> I guess I have also missed some way or other of controlling the prototyping
> interpreter (GHCi) that would make it produce more efficient code, ways that
> would be "obvious" to ... of course ;-)

I usually run ghci in an emacs window so I can kill the window (which
also kills the ghci process) if it goes berserk.  Also run "w" in
another window so you can see the memory consumption climbing in the
case of a space leak.  You can usually ctrl-c out of it if you do it
before the system is pushed into swapping.  Or you could use ulimit to
bound the memory footprint, or run in a VM, or whatever.