The slow-witted OCamler Introduction TL;DR Article explains stuff from 'The little MLer' in ordinary prose. Uses OCaml for examples. Readers can suggest improvements. Dear reader, near the end of 2010 I read Felleisen and Friedman's 'The little MLer' to learn functional programming in general and OCaml in particular. Looking back I must say that I could have had it much easier with another book. To be honest I had to read it twice to make sense of it and on some occasions it made me feel dumb, in fact so much so, that on the second reading I summarized the whole book, just to make sure I understood every important detail and not to go astray. I called the resulting notes 'The slow-witted OCamler' for no other reason than to remind myself of the Kafkaesque intellectual experience I had gone through. Let me emphasize that it was also a rewarding experience. Not because I eventually defeated the book. Rather because the book didn't defeat me, which is different. But I also noticed while working through the book and gathering information from other sources to tackle it, that I was only scratching on a surface through which the authors wouldn't let me see. In other words, while many things are obvious and quite easy to understand, sometimes they throw a piece of code at you without bothering to explain its theoretical background and practical purpose. Well, at present I can make assumptions about these things but not much more. Yes, I've seen the references at the end of the book, but at this point I don't feel like reading through five tomes about mathematical logic, category theory and automatic proof just yet. I'd be more interested in simple and practical applications of some constructs presented in the book. That's one reason why I dumped my notes here. First of all because there are a few open questions concerning things ranging from more trivial and less important things like OCaml syntax to the problems I just mentioned, e.g. the thing in ch 7: Is that a monad? Is it used for lazy evaluation? Does anybody use it and why? Below the TOC you find some pointers that lead directly to questions you could look at and help me finding answers. The TOC points to the sections of my notes, each corresponding to a chapter of the book. The first chapters are easy and the notes are short. The latter chapters are difficult and the notes are more verbose. If you think you are also in need for a Kafkaesque experience, I urge you to read through the whole set of notes and then point out things I didn't understand, propose changes or additional information I could integrate, or suggest how I could make the text more useful for others. Although these pages are static, the content is kind of interactive. Just send oldfashioned email to d at d12k dot org. TOC Less interesting: Chapter 1: Types, variants, parametrized types, recursive types, polymorphic types. Chapter 2, Chapter 3: Recursive functions, pattern matching. Chapter 4, Chapter 5: Tuples, lists. More interesting: Chapter 6: Trees, symbolic expressions, mutual reference, mutual recursion. Chapter 7: Functions' types, higher-order functions, monads(?). Chapter 8: Functional abstraction, type inference and type variables, currying and recursion, intension vs. extension of functions. Chapter 9: Exceptions. Chapter 10: Modules. Questions: 1: Can I match several constructors of a type with one pattern and extract a nested value? 2: When pattern matching, why shouldn't I compact several values to be matched when they are not adjacent in their definition? 3: Does type 'chain' define a monad? 4: Are monads used to implement lazy evaluation? 5: Regarding the intensional approximation of extensionally equivalent but intensionally different functions. 6: Your thoughts on the last example in ch. 8. 7: Unqualified alias for qualified names? 8: Explicit signature and structure definitions in separate files?