PTV/book-monads
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update alternatives to new model

Browse Source
This commit is contained in:
AF 2023-05-30 18:01:06 +00:00
parent 8e9ea6c8e0
commit b4051ba32c
1 changed files with 27 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/ch04/s01-alternatives.md
View File

@ -9,17 +9,15 @@ without extra (sub)traits like `WeakFunctor`, `Pure`, `ApplicativeLA2`, etc. .
trait Functor<'a>: 'a {
type F<A: 'a>: 'a;
fn fmap<'a, A: 'a, B: 'a>(
f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>,
) -> Self::F<'a, B>
where
Self: 'a;
fn fmap<A: 'a, B: 'a>(
fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B,
) -> Self::F<B>;
}
fn fmap<'a, T: 'a + Functor, A: 'a, B: 'a>(
fn fmap<'a, T: Functor<'a>, A: 'a, B: 'a>(
f: impl 'a + FnOnce(A) -> B,
) -> impl FnOnce(T::F<'a, A>) -> T::F<'a, B> {
|fa| T::fmap(f, fa)
) -> impl FnOnce(<T as Functor<'a>>::F<A>) -> <T as Functor<'a>>::F<B> {
|fa| T::fmap(fa, f)
}
```
@ -28,22 +26,18 @@ fn fmap<'a, T: 'a + Functor, A: 'a, B: 'a>(
This is probably the closest representation to what Haskell views as a category of its types.
```rust
trait Functor: Clone {
type F<'a, A: 'a + Clone>: 'a + Clone
where
Self: 'a;
trait Functor<'a>: 'a + Clone {
type F<A: 'a + Clone>: 'a + Clone;
fn fmap<'a, A: 'a + Clone, B: 'a + Clone>(
f: impl 'a + Clone + Fn(A) -> B, fa: Self::F<'a, A>,
) -> Self::F<'a, B>
where
Self: 'a;
fn fmap<A: 'a + Clone, B: 'a + Clone>(
fa: Self::F<A>, f: impl 'a + Clone + Fn(A) -> B,
) -> Self::F<B>;
}
fn fmap<'a, T: 'a + Functor, A: 'a + Clone, B: 'a + Clone>(
fn fmap<'a, T: Functor<'a>, A: 'a + Clone, B: 'a + Clone>(
f: impl 'a + Clone + Fn(A) -> B,
) -> impl 'a + Clone + Fn(T::F<'a, A>) -> T::F<'a, B> {
move |fa| T::fmap(f.clone(), fa)
) -> impl 'a + Clone + Fn(<T as Functor<'a>>::F<A>) -> <T as Functor<'a>>::F<B> {
move |fa| T::fmap(fa, f.clone())
}
```
@ -57,16 +51,12 @@ We view use of `FnMut` for category's morphisms as somewhat controversial[^e].
sequential application (`<*>` in Haskell, `seq` in RADN) *difficult*.
```rust
trait Functor: Clone {
type F<'a, A: 'a + Clone>: 'a + Clone
where
Self: 'a;
trait Functor<'a>: 'a + Clone {
type F<A: 'a + Clone>: 'a + Clone;
fn fmap<'a, A: 'a + Clone, B: 'a + Clone>(
f: impl 'a + FnMut(A) -> B, fa: Self::F<'a, A>,
) -> Self::F<'a, B>
where
Self: 'a;
fn fmap<A: 'a + Clone, B: 'a + Clone>(
fa: Self::F<A>, f: impl 'a + FnMut(A) -> B,
) -> Self::F<B>;
}
```
@ -75,21 +65,17 @@ trait Functor: Clone {
## `Copy`-`Fn` category functors
```rust
trait Functor: Copy {
type F<'a, A: 'a + Copy>: 'a + Copy
where
Self: 'a;
trait Functor<'a>: 'a + Copy {
type F<A: 'a + Copy>: 'a + Copy;
fn fmap<'a, A: 'a + Copy, B: 'a + Copy>(
f: impl 'a + Copy + Fn(A) -> B, fa: Self::F<'a, A>,
) -> Self::F<'a, B>
where
Self: 'a;
fn fmap<A: 'a + Copy, B: 'a + Copy>(
fa: Self::F<A>, f: impl 'a + Copy + Fn(A) -> B,
) -> Self::F<B>;
}
fn fmap<'a, T: 'a + Functor, A: 'a + Copy, B: 'a + Copy>(
fn fmap<'a, T: Functor<'a>, A: 'a + Copy, B: 'a + Copy>(
f: impl 'a + Copy + Fn(A) -> B,
) -> impl 'a + Copy + Fn(T::F<'a, A>) -> T::F<'a, B> {
move |fa| T::fmap(f, fa)
) -> impl 'a + Copy + Fn(<T as Functor<'a>>::F<A>) -> <T as Functor<'a>>::F<B> {
move |fa| T::fmap(fa, f)
}
```