Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
Comments on How to implement `map` using the fish (>=>, Kleisli composition) operator in F#?
Parent
How to implement `map` using the fish (>=>, Kleisli composition) operator in F#?
I'm learning monadic composition through Scott Wlaschin's Railway-oriented Programming post. Oncebind, 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
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.
Is there a "cleaner" implementation similar to map's?
Notes
I used the following example to test the maps 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)
Post
The following users marked this post as Works for me:
| User | Comment | Date |
|---|---|---|
| toraritte |
Thread: Works for me Wow, the simplicity of this blew my mind. Did you come up with this on the spot or is this a well known formula in other (pure) functional programming ... |
Apr 2, 2024 at 22:11 |
Is there a "cleaner" implementation similar to
map's?
Yes:
let map f = id >=> switch f
This follows from two of your other equations:
map f = bind (switch f)
g >=> h = g >> bind h
So if you want to get bind (switch f) out of (>=>), you can start by making h = switch f, then get rid of the superfluous composition by letting g be id and you're done.
g >=> h = g >> bind h <------ (h = switch f)
g >=> switch f = g >> bind (switch f)
g >=> switch f = g >> map f <------ (g = id)
id >=> switch f = id >> map f
id >=> switch f = map f
0 comment threads