Topics

Over the past year and a bit, I've written a number of functional programming posts that all kind of fit together (or at least they're all based on the same slowly-growing codebase). When I started this, I didn't realize that I would be coming back to this well so frequently, so I was naming posts "Introduction to functional programming in Java - Part n", with nothing in the title to suggest what would actually be covered in a given post. In fact, as I write later posts, I find it really annoying to have to check each of my previous posts in order to link back to earlier material.

So, this page will serve as a sort of "table of contents" for earlier posts, so you can easily find topics that you might find interesting.

Functional Programming Fundamentals

• I asked "What is functional?" here. While this post was written after many of the others, it's actually not a bad starting point.
• First-class and higher-order functions were covered in this post.
• Currying and partial application, as well as map and fold were covered in this post.
• Lazy evaluation and memoization were covered here. While lazy evaluation comes up in several later posts (especially the ones dealing with concurrent execution), I kind of regret the effort (and damage to the API) put in for memoization.

Immutable data structures

• Before launching into the functional programming series of posts, I wrote a two-parter on immutable binary trees here and here.
• I covered immutable lists and Options here. That post also covers tail recursion (and gives a tiny explanation of tail-call optimization) and covers some nice higher-order methods on collections. It's a ridiculously long post, that should have been split at least once.
• Tuples were covered here.
• Hash trie maps were covered here.

Concurrency

• I covered concurrent evaluation of lazy results here.
• Asynchronous chaining of evaluations was covered here