Editing Talk:Corecursion (section)

== Major expansion: non-technical introduction, imperative examples (Python) ==

I’ve just completed a significant expansion (more than doubling) of the article, as of [http://en.wikipedia.org/w/index.php?title=Corecursion&oldid=504128625 this edit]. This consists essentially of:
* Rewriting and expanding the non-technical lede (introduction),
* Giving two detailed example, contrasting with recursion: factorial and tree traversal, implemented imperatively in Python,
(together with various cleanup and formatting, and a brief note on history, AFAICT).

Corecursion seems a very interesting topic, and perhaps a useful fundamental viewpoint, which appears to be only recently appreciated and not yet widely-known (certainly not outside functional programming community). I am no expert on this subject – I just reworked the existing article (discussion and Haskell examples), expanding the wording and giving explicit examples, and looked at the references. The non-technical discussion is perhaps a bit glib (it very sharply delimits the recursion/corecursion duality), but hopefully accurate and readable. The key points – corecursion useful for infinite data, and works ''forward'' (''synthetically,'' in contrast to ''analytically,'' as regular recursion) – seem easy enough to state clearly in non-technical terms.

As for the examples:
* Factorial is very simple – it’s basic recursion example, and simpler than Fibonacci, so seems a good base case from the recursion point of view
* Tree traversal seems a great contrast example – depth-first traversal is fundamental non-trivial example of recursion (and very well-known), while breadth-first traversal is a basic motivating example of corecursion, which thus should have similar prominence.
As this topic is potentially very abstract, and functional programming is often unfamiliar, concrete examples with imperative code (the Python is virtually pseudo-code, with the only confusing point being “yield”) should clarify it.

Hope this helps, and please improve as you see fit!
:—Nils von Barth ([[User:Nbarth|nbarth]]) ([[User talk:Nbarth|talk]]) 17:50, 25 July 2012 (UTC)

: In my opinion the difference between recursion and corecursion is best demonstrated in languages that make an explicit distinction between them (e.g. Coq or Agda). In Haskell the distinction is vague (because&mdash;ignoring strictness annotations&mdash;all data is codata), imperative language are perhaps even worse because recursion is less "natural" in those languages and they don't have algebraic data types. In Coq a "recursive function" is one that operates by structural recursion over data (i.e. its domain is data), while a "corecursive function" is one that has codata as it's result/range and operates by guarded recursion. Perhaps a strict function language such as ML or Scheme work better as all data their data is data and have to codata by explicit delay and forces. —''[[User:Ruud Koot|Ruud]]'' 19:22, 25 July 2012 (UTC)