ksavelev

I'll throw my opinion in here, but take it with a pretty large grain of salt as I've done no professional development in a functional language yet. Just tinkering with (quite a few of) them in my spare time. Some of the patterns I spotted are irrespective of type systems (static, dynamic).

• lists, sequences or similar primitives are ubiquitous
• abstract away duplicate code using higher-order functions
• no iteration constructs, recursion is the only way to traverse lists
• watch out your recursion, be sure it's tail-recursive
• abstract over this tail-recursive pattern with a higher-order function: foldLeft or foldRight. So, know your language's equivalent of foldLeft/foldRight and prefer these over explicit recursion.
• abstract over folds in an even more general way and provide folding functions for arbitrary data structures, not just list, e.g., trees.
• provide a few convenience higher-order functions (implementable using fold) like: map, filter, any/some, all/every, zip, `zipWith