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.

Post History

50%

+0 −0

Q&A Why does `let map f = id >=> switch f` work in F#?

Asked How to implement map using the fish (>=>, Kleisli composition) operator in F#? a couple of hours ago, and r~~'s answer blew my mind: let map f = id >=> switch f It is perfect ...

1 answer · posted 1mo ago by toraritte‭ · edited 1mo ago by Alexei‭

Question f# functional-programming monads monadic-composition

#4: Post edited by

Alexei‭ · 2024-04-10T15:22:44Z (about 1 month ago)
added relevant tag

Copy Link

Raw

Markdown

functional-programming monads monadic-composition

f# functional-programming monads monadic-composition

#3: Post edited by

toraritte‭ · 2024-04-03T18:02:31Z (about 1 month ago)

Copy Link

Raw

Markdown

Asked [How to implement `map` using the fish (>=>, Kleisli composition) operator in F#?](https://software.codidact.com/posts/291227) a couple of hours ago, and [r~~'s answer blew my mind](https://software.codidact.com/posts/291227/291228#answer-291228):
```
let map f = id >=> switch f
```
It is perfect in its simplicity, but when I look at the type signatures, it is not supposed to work. I've been at it for almost an hour now, so I'm probably missing something fundamental how F# evaluates expressions...
For the record, these are the implementations of `bind`,`switch`, and `>=>`:
```
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)
```
My next attempt was using an alternative implementation for `>=>`:
```
let (>=>>)
(f : 'a -> Result<'b,'error>)
(g : 'b -> Result<'c,'error>)
x
=
match (f x) with
| Ok o -> g o
| Error e -> Error e
```
Here's the test invocation on `dotnet fsi`:
```
(id >=>> (switch ((+) 2) : int -> Result<int,string>))
((Ok 27) : Result<int,string>)
//=> Ok 29
```
I'm already stuck at why `>=>>` does not blow up on `id` as its first argument?
This is how I would think evaluation goes, but apparently this is not it:
```
id >=>> switch ((+) 2)
|
V
(>=>>) id (switch ((+) 2))
|
V
match (id x) with
| Ok o -> (switch ((+) 2)) o
| Error e -> Error e
```
---
Note to future self:...
```
(>=>>) (>=>>)
(f : 'a -> Result<'b,'error>) id
(g : 'b -> Result<'c,'error>) (Ok << ((+) 2) : int -> Result<int,string>))
x ((Ok 27) : Result<int,string>)
~~```~~

Asked [How to implement `map` using the fish (>=>, Kleisli composition) operator in F#?](https://software.codidact.com/posts/291227) a couple of hours ago, and [r~~'s answer blew my mind](https://software.codidact.com/posts/291227/291228#answer-291228):
```
let map f = id >=> switch f
```
It is perfect in its simplicity, but when I look at the type signatures, it is not supposed to work. I've been at it for almost an hour now, so I'm probably missing something fundamental how F# evaluates expressions...
For the record, these are the implementations of `bind`,`switch`, and `>=>`:
```
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)
```
My next attempt was using an alternative implementation for `>=>`:
```
let (>=>>)
(f : 'a -> Result<'b,'error>)
(g : 'b -> Result<'c,'error>)
x
=
match (f x) with
| Ok o -> g o
| Error e -> Error e
```
Here's the test invocation on `dotnet fsi`:
```
(id >=>> (switch ((+) 2) : int -> Result<int,string>))
((Ok 27) : Result<int,string>)
//=> Ok 29
```
I'm already stuck at why `>=>>` does not blow up on `id` as its first argument?
This is how I would think evaluation goes, but apparently this is not it:
```
id >=>> switch ((+) 2)
|
V
(>=>>) id (switch ((+) 2))
|
V
match (id x) with
| Ok o -> (switch ((+) 2)) o
| Error e -> Error e
```
---
Note to future self:...
```
(>=>>) (>=>>)
(f : 'a -> Result<'b,'error>) id
(g : 'b -> Result<'c,'error>) (Ok << ((+) 2) : int -> Result<int,string>))
x ((Ok 27) : Result<int,string>)
```
(... and make sure to convert a point-free function if it does not make sense at first.)

#2: Post edited by

toraritte‭ · 2024-04-03T10:10:43Z (about 1 month ago)

Copy Link

Raw

Markdown

Asked [How to implement `map` using the fish (>=>, Kleisli composition) operator in F#?](https://software.codidact.com/posts/291227) a couple of hours ago, and [r~~'s answer blew my mind](https://software.codidact.com/posts/291227/291228#answer-291228):
```
let map f = id >=> switch f
```
It is perfect in its simplicity, but when I look at the type signatures, it is not supposed to work. I've been at it for almost an hour now, so I'm probably missing something fundamental how F# evaluates expressions...
For the record, these are the implementations of `bind`,`switch`, and `>=>`:
```
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)
```
My next attempt was using an alternative implementation for `>=>`:
```
let (>=>>)
(f : 'a -> Result<'b,'error>)
(g : 'b -> Result<'c,'error>)
x
=
match (f x) with
| Ok o -> g o
| Error e -> Error e
```
Here's the test invocation on `dotnet fsi`:
```
(id >=>> (switch ((+) 2) : int -> Result<int,string>))
((Ok 27) : Result<int,string>)
//=> Ok 29
```
I'm already stuck at why `>=>>` does not blow up on `id` as its first argument?
This is how I would think evaluation goes, but apparently this is not it:
```
id >=>> switch ((+) 2)
|
V
(>=>>) id (switch ((+) 2))
|
V
match (id x) with
| Ok o -> (switch ((+) 2)) o
| Error e -> Error e
```

Asked [How to implement `map` using the fish (>=>, Kleisli composition) operator in F#?](https://software.codidact.com/posts/291227) a couple of hours ago, and [r~~'s answer blew my mind](https://software.codidact.com/posts/291227/291228#answer-291228):
```
let map f = id >=> switch f
```
It is perfect in its simplicity, but when I look at the type signatures, it is not supposed to work. I've been at it for almost an hour now, so I'm probably missing something fundamental how F# evaluates expressions...
For the record, these are the implementations of `bind`,`switch`, and `>=>`:
```
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)
```
My next attempt was using an alternative implementation for `>=>`:
```
let (>=>>)
(f : 'a -> Result<'b,'error>)
(g : 'b -> Result<'c,'error>)
x
=
match (f x) with
| Ok o -> g o
| Error e -> Error e
```
Here's the test invocation on `dotnet fsi`:
```
(id >=>> (switch ((+) 2) : int -> Result<int,string>))
((Ok 27) : Result<int,string>)
//=> Ok 29
```
I'm already stuck at why `>=>>` does not blow up on `id` as its first argument?
This is how I would think evaluation goes, but apparently this is not it:
```
id >=>> switch ((+) 2)
|
V
(>=>>) id (switch ((+) 2))
|
V
match (id x) with
| Ok o -> (switch ((+) 2)) o
| Error e -> Error e
```
---
Note to future self:...
```
(>=>>) (>=>>)
(f : 'a -> Result<'b,'error>) id
(g : 'b -> Result<'c,'error>) (Ok << ((+) 2) : int -> Result<int,string>))
x ((Ok 27) : Result<int,string>)
```

#1: Initial revision by

toraritte‭ · 2024-04-02T22:08:47Z (about 1 month ago)

Copy Link

Raw

Markdown

Why does `let map f = id >=> switch f` work in F#?

Asked [How to implement `map` using the fish (>=>, Kleisli composition) operator in F#?](https://software.codidact.com/posts/291227) a couple of hours ago, and [r~~'s answer blew my mind](https://software.codidact.com/posts/291227/291228#answer-291228):

```
let map f = id >=> switch f
```

It is perfect in its simplicity, but when I look at the type signatures, it is not supposed to work. I've been at it for almost an hour now, so I'm probably missing something fundamental how F# evaluates expressions...

For the record, these are the implementations of `bind`,`switch`, and `>=>`:

```
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)
```

My next attempt was using an alternative implementation for `>=>`:

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

Here's the test invocation on `dotnet fsi`:

```
(id >=>> (switch ((+) 2) : int -> Result<int,string>))
((Ok 27) : Result<int,string>)
//=> Ok 29
```

I'm already stuck at why `>=>>` does not blow up on `id` as its first argument?

This is how I would think evaluation goes, but apparently this is not it: 

```
id >=>> switch ((+) 2)
          |
          V
(>=>>) id (switch ((+) 2))
          |
          V
    match (id x) with
    |    Ok o -> (switch ((+) 2)) o
    | Error e -> Error e
```

functional-programming monads monadic-composition

Communities

Post History