Map and Bind and Apply, a summary
Well, this series turned out to be longer than I originally planned. Thanks for making it to the end!
I hope that this discussion has been helpful in understanding the various function transformations like map
and bind
, and given you
some useful techniques for dealing with worldcrossing functions – maybe even demystified the mword a bit!
If you want to start using these kinds of functions in your own code, I hope that you can see how easy they are to write, but you should also consider using one of the excellent F# utility libraries that contain these and much more:

ExtCore (source, NuGet). ExtCore provides extensions to the F# core library (FSharp.Core) and aims to help you build industrialstrength F# applications. These extensions include additional functions for modules such as Array, List, Set, and Map; immutable IntSet, IntMap, LazyList, and Queue collections; a variety of computation expressions (workflows); and “workflow collections” – collections modules which have been adapted to work seamlessly from within workflows.

FSharpx.Extras (home page). FSharpx.Extras is part of the FSharpx series of libraries. It implements several standard monads (State, Reader, Writer, Either, Continuation, Distribution), validation with applicative functors, general functions like flip, and some asynchronous programming utilities, and functions to make C#  F# interop easier.
For example, the monadic traverse List.traverseResultM
that I implemented in this post is already available in ExtCore
here.
And if you liked this series, I have posts explaining the State monad in my series on “Dr Frankenfunctor and the Monadster” and the Either monad in my talk “Railway Oriented Programming”.
As I said at the very beginning, writing this up has been a learning process for me too. I am not an expert, so if I have made any errors please do let me know.
Thanks!
Here’s a list of shortcuts to the various functions mentioned in this series:
 Part 1: Lifting to the elevated world
 Part 2: How to compose worldcrossing functions
 Part 3: Using the core functions in practice
 Part 4: Mixing lists and elevated values
 Part 5: A realworld example that uses all the techniques
 Part 6: Designing your own elevated world
 Part 7: Summary
Unlike OO languages, functional programming languages are known for their strange operators, so I thought it would be helpful to document the ones that have been used in this series, with links back to the relevant discussion.
Operator  Equivalent function  Discussion 

>> 
Lefttoright composition  Not part of this series, but discussed here 
<< 
Righttoleft composition  As above 
`  >`  Lefttoright piping 
`<  `  Righttoleft piping 
<!> 
map 
Discussed here 
<$> 
map 
Haskell operator for map, but not a valid operator in F#, so I’m using <!> in this series. 
<*> 
apply 
Discussed here 
<* 
  One sided combiner. Discussed here 
*> 
  One sided combiner. Discussed here 
>>= 
Lefttoright bind 
Discussed here 
=<< 
Righttoleft bind 
As above 
>=> 
Lefttoright Kleisli composition  Discussed here 
<=< 
Righttoleft Kleisli composition  As above 
Alternative tutorials:
 You Could Have Invented Monads! (And Maybe You Already Have).
 Functors, Applicatives and Monads in pictures.
 Kleisli composition à la UpGoer Five. I think this one is funny.
 Eric Lippert’s series on monads in C#.
For the academically minded:
 Monads for Functional Programming (PDF), by Philip Wadler. One of the first monad papers.
 Applicative Programming with Effects (PDF), by Conor McBride and Ross Paterson.
 The Essence of the Iterator Pattern (PDF), by Jeremy Gibbons and Bruno Oliveira.
F# examples:
 F# ExtCore and FSharpx.Extras have lots of useful code.
 FSharpx.Async has
map
,apply
,liftN
(called “Parallel”),bind
, and other useful extensions forAsync
.  Applicatives are very well suited for parsing, as explained in these posts: