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
andfold
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
No comments:
Post a Comment
Note: Only a member of this blog may post a comment.