Corecursion is useful for taking a recursive algorithm and transforming it to a stream-like output pattern.
But this is ridiculously inefficient.
Well...you might be surprised in the general case. Because of lazy evaluation, Haskell won't necessarily implode on non-TCO recursive functions (example: http://stackoverflow.com/questions/13042353/does-haskell-hav...), and will actually sometimes cause a stack overflow on "optimized" functions.
Until now, the only "principled" way I knew of to transform this into something sensible was through memoization, but that's still very wasteful.
I think "real" Haskell code usually favors operations of lists over recursive functions. That said, the standard way to transform your recursive structure into something "sensible" is to use a tail-recursive function. In basically any other functional language, you'd go with that approach.
To get the same "benefit" in Haskell, you'd have to force strict evaluation inside of a tail-recursive function. This prevents a thunk from causing problems. That said, Haskell doesn't always build up a normal stack on a regular recursive call.
Otherwise, you'd just use a list structure.
(Someone correct me if I've said something stupid.)
ref:
http://www.haskell.org/haskellwiki/Tail_recursion
But this is ridiculously inefficient.
Well...you might be surprised in the general case. Because of lazy evaluation, Haskell won't necessarily implode on non-TCO recursive functions (example: http://stackoverflow.com/questions/13042353/does-haskell-hav...), and will actually sometimes cause a stack overflow on "optimized" functions.
Until now, the only "principled" way I knew of to transform this into something sensible was through memoization, but that's still very wasteful.
I think "real" Haskell code usually favors operations of lists over recursive functions. That said, the standard way to transform your recursive structure into something "sensible" is to use a tail-recursive function. In basically any other functional language, you'd go with that approach.
To get the same "benefit" in Haskell, you'd have to force strict evaluation inside of a tail-recursive function. This prevents a thunk from causing problems. That said, Haskell doesn't always build up a normal stack on a regular recursive call.
Otherwise, you'd just use a list structure.
(Someone correct me if I've said something stupid.)
ref:
http://www.haskell.org/haskellwiki/Tail_recursion