User:Duplode/Haskell TODO

See also: Haskell/To do.


  • Deliberate on what to do about chapter/section/unit/track/book/tome/testament/... terminology.
I think: each URL is a chapter in this case, it's ok that some are short. There are the main tracks. Each track has sections (e.g. Elementary, Intermediate are sections in the beginning track)Backfromquadrangle (discusscontribs) 19:07, 14 May 2014 (UTC)


  • Should example templates be retained, or is it better to use source tags alone?
Better to use source tags that have syntax highlighting. Indentation is another matter, as overall the Wikibook could use more whitespace to signify things and make it more visually appealing.Backfromquadrangle (discusscontribs) 19:09, 14 May 2014 (UTC)
  • Change all ../ links to Haskell/ (for the benefit of the print version).


  • Prelude cheat sheets (adjusting the templates, choosing priorities, actually doing them).
  • Working with lists (study feasibility of the comprehension-based approach, attempt a draft. If it fails, consider removing the red link).   Not done


  • Control structures (evaluate renaming).
  • Using GHCi effectively (including less obvious things).


  • Modules (some reordering, a proper introduction pointing to Haskell in Practice).   Done
    • Moving "Standalone programs" to the Beginner's Track helps a lot.
  • Indentation (some refactoring; consider fusing it with some other page or moving to Elementary Haskell).
  • More on datatypes (consider moving the Enumerations section to the Enum class discussion, and the implications of doing so).
  • Other data structures (placement feels a bit random ATM. Decide what to do with the catamorphisms).
    • It is just silly that we do not say a word here about Data.Map, Data.Array, Data.Sequence...
  • Class declarations / Classes and types (fuse both, prune redundancies, refactor for clarity).   Done
    • Possibly discuss newtype here.   Not done - Better done with proper context (as of now, in the chapter on the State monad).
  • Applied classes (new page, displaying actual instance implementation while introducing Functors).   Done
  • Number classes (potential new page - can it stand on its own, or is it better left to a cheat sheet of some sort?)
  • Derived classes (potential new page - without thinking too much it could make sense to factor it away from Class declarations).


  • General structure
    • Understanding monads
    • Maybe
    • List
    • do notation
    • State
    • IO
    • MonadPlus
    • Writer
    • Monad transformers
    • Reader (or: using a simple monad to speak of complex stuff)
    • Practical monads

  • Foreword (potential, but unlikely, new page).   Not done
  • Understanding monads (remove the foreword and other fluffier passages).   Done
    • Tone down a bit the allusions to monoids.   Done
    • Recreate the foreword in a very brief, meta-book, non-scary version ("monads are abstract, but not otherwordly", "we will adopt a cut-to-the-chase approach in this introduction, and then sweeten it with a lot examples).
    • Add remarks on how the chapters on specific monads are semi-optional ("you will notice that among the following chapters some are about general topics while others are dedicated to specific monads", "you don't need to go through the specific-monad chapters following the TOC systematically, though it would be sane to spend some time on IO and State due to useful library functions shown in action therein, and also to have at least a glance at the others").   Not done - We introduce important practices through the concrete monad chapters, so they are not really optional (the order doesn't matter much though).
    • Incorporate the links from Haskell/Advanced monads.
  • Understanding monads subpages about State, Maybe, etc. (try to find a way to integrate them to the main TOC).   Done
    • ./Reader, ./Writer, perhaps ./Error too.
  • State
    • Fix and transfer the exercises from the main page to ./State .
    • Incorporate those nice pictures to the discussion of the State bind and return.
  • IO
    • Introduce monadic "control structures" in ./IO   Done
  • List
    • Add one or two lines explaining what guard does a little better in ./List.   Done
    • Pick a simpler example for the list comprehensions part, possibly one with just two lists and no guard.   Done
  • do notation (a bit redundant, but probably should be kept anyway).   Done - Cleaned up.
    • Add a brief foreword alluding to IO actions of Haskell Basics, as a teaser for the chapter on IO.   Done
  • Advanced monads (merge it completely into the Understanding monads subpages).   Done
    • Decide what to do with the part on State (thus far, ignored).
  • Additive monads (try to find a more natural way to talk about monoids).   Done
    • Fix small details - the usage of newtype, the exercises formatting, the external links.
    • Review the code samples in the comprehensions section.
  • Monadic parser combinators (I know parsers are important, but once finished will this really belong here?)   Done - Now in limbo.
  • Monad transformers (this is a key one. Could it be made more accessible?)   Done
    • Explain what the Identity monad is at some point.   Done
    • How to tackle commutativity?
  • Value recursion (this seems out of place, move to advanced).   Done
  • Practical monads (I find this one slightly baffling, but it seems all right to have it here - cf. my proposed chapter on Functors).
    • The structure of the lv. 2 headers can stay the way it is now, only the contents would need to be adjusted.
    • Parsers: move the WYAS import to the Practical Track (perhaps merging it with the independent ParseExps tutorial there). Retain only a few general considerations (expanding on a bit on the points raised in MonadPlus, following part of that Functional Pearls paper), plus the links and the pointers to the Practical Track of course.
    • PMD: show how monads are general enough that even a dummy monad like Identity can be turned into something sensible with a few tweaks.
    • Statefulness and concurrency: polish the example, and talk a bit more about concurrency so that it doesn't feel scary.


  • Monoids (de-stubify)   Done
Expand some (all?) of the examples further.
Add exercises and solutions.
Could the bits about Foldable and Traversable become a new chapter?

Libraries ReferenceEdit

  • Data.List (switch the focus to the functions not in Prelude).
  • Data.Map (maybe include a nod to packages such as hashmap).
  • Control.Monad (this is sorely missed).
  • bytestring (could be useful).

General PracticesEdit

  • cabal and hackage (pointers on how to install packages, etc. Not sure whether here is the proper place for it, but important anyway).