Post History

How to implement `map` using the fish (>=>, Kleisli composition) operator in F#?

I'm learning monadic composition through Scott Wlaschin's [Railway-oriented Programming](https://fsharpforfunandprofit.com/posts/recipe-part2/) post. Once`bind`, `switch`, and `>=>` functions are defined, he introduces `map` to show how to "_turn a one-track function into a two-track function_". That is:

```
f: a -> b     =>    f': T<a,c> -> T<b,c>
```

The implementation in the article is the following:

```
let map oneTrackFunction twoTrackInput =
    match twoTrackInput with
    | Success s -> Success (oneTrackFunction s)
    | Failure f -> Failure f
```

Did an an equivalent implementation using `switch` and `bind` as an exercise,

```
let map' f = bind (switch f)
```

but when I tried to implement `map` with `>=>`, I arrived at this ugly mess:

```
let map'' f result =
    match result with
        | Ok o -> ((fun _ -> result) >=> (switch f)) o
        | Error e -> Error e
```

<sup>**Note to self**: `o` could be any value of type `'a` (if `result : Result<'a,'c>`), because `f`'s input is already saved in the closure used as `>=>`'s first operand, but this was the only way I could think of to keep it more generic.</sup>

Is there a "cleaner" implementation similar to `map'`s? 

---

### Notes

I used the following example to test the `map`s above:

```
map  ((+) 2) ((Ok 27) : Result<int,string>)
```

Used implementations of `bind`, `switch`, `>=>`:

```
let bind
    (     f : 'a -> Result<'b,'c>)
    (result :       Result<'a,'c>)
    =
    match result with 
   |    Ok o -> f o
   | Error e -> Error e

let switch
   (f : 'a -> 'b)
   (x : 'a      )
   =
   f x |> Ok

let (>=>)
    (f : 'a -> Result<'b,'error>)
    (g : 'b -> Result<'c,'error>)
    =
    f >> (bind g)
```