Skip to content

Commit 9a66a35

Browse files
author
Grant Wuerker
committed
monad
1 parent 680e3a9 commit 9a66a35

File tree

6 files changed

+441
-91
lines changed

6 files changed

+441
-91
lines changed

Diff for: ‎library/core/src/monad copy.fe

+173
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,173 @@
1+
// use self::option::Option
2+
3+
// trait Applicative
4+
// where Self: * -> *
5+
// {
6+
// fn pure<T>(t: T) -> Self<T>
7+
// }
8+
9+
// impl Applicative for Option {
10+
// fn pure<T>(t: T) -> Self<T> {
11+
// Option::Some(t)
12+
// }
13+
// }
14+
15+
// trait Monad: Applicative
16+
// where Self: * -> *
17+
// {
18+
// fn bind<T, F, U>(self: Self<T>) -> Self<U> where F: Fn<T, Self<U>>
19+
// }
20+
21+
// impl Monad for Option {
22+
// fn bind<T, F, U>(self: Self<T>) -> Self<U> where F: Fn<T, Self<U>> {
23+
// match self {
24+
// Self::Some(self) => F::exec(t: self)
25+
// Self::None => Self::None
26+
// }
27+
// }
28+
// }
29+
30+
// fn foo<F>(f: F)
31+
// where F: Fn(u8, u8, u8) -> u8 {
32+
// where F: Fn<{u8, u8, u8}, u8>
33+
34+
// }
35+
36+
// fn f(u8, u8, u8) -> u8 {} // (u8, u8, u8) -> u8
37+
// fn g((u8, u8, u8)) -> u8 {} //((u8,u8,u8)) -> u8
38+
39+
// fn main() {
40+
// f(1, 2, 3) // f.exec((1, 2, 3))
41+
42+
// let x = (1, 2, 3)
43+
// f(x)
44+
// g(x)
45+
46+
// let args = {1, 2, 3}
47+
// args.push(1)
48+
49+
// let args = (1, 2, 3)
50+
// f (1, 2, 3)
51+
// f args
52+
53+
// let x = ((u8, u8, u8))
54+
// let x = ((u8, u8, u8),)
55+
56+
// f(args..) // f(x, y) f (
57+
// }
58+
// (u8, u8, u8) -> u8
59+
// u8 -> u8 -> u8 -> u8
60+
61+
62+
63+
// impl Fn<((u8, u8, u8)), u8> for G
64+
65+
// impl Fn<(u8, u8, u8), u8> for Foo {
66+
67+
// }
68+
69+
// trait Fn<T, U> where T: FnArgs {
70+
// fn exect(&self, t: T) -> U
71+
// }
72+
73+
// trait Fn<Arg, Ret, const Arity: usize>
74+
// where Arg: Tuple<Arity>
75+
// {
76+
// fn call(self, arg : Arg) -> Ret
77+
// }
78+
79+
// trait FnMut<T, U> where T: FnArgs {
80+
// fn exect(&mut self, t: T) -> U
81+
// }
82+
83+
// trait Tuple<const N: usize>;
84+
85+
// fn map<T, U,F>(t: T, f: F) -> U
86+
// where F: Fn(T) -> U {...}
87+
88+
// type MyFn = ()
89+
90+
// impl<T, U> Fn<T, U> for Foo {
91+
// fn exec(&self, t: T) -> U {
92+
// t.element(0)
93+
// t.len()
94+
// }
95+
// }
96+
97+
// impl Fn<(u8, u8>, Option<u8>> for MyFn {
98+
// fn exec(t: (bool, bool)) -> Option<u8> {
99+
// let (a, b) = t
100+
// f(a, b)
101+
// }
102+
// }
103+
104+
// #test
105+
// fn my_test() {
106+
// let f: MyFn = ()
107+
// let a = Option::Some(true).bind<_, _, _>(f)
108+
// let a: Option<u8> = Option::Some(true).bind(f)
109+
// }
110+
111+
112+
// sub x y = x - y
113+
// f = sub 1 // f 2 == 1 - 2
114+
// g = `sub` 1 // g 2 == 2 - 1
115+
116+
117+
// enum Result<T, E> {
118+
// Ok(T)
119+
// Err(E)
120+
// }
121+
// impl<E> Functor for Result<*, E> { // or Result<_, E> maybe?
122+
// fn map<A, B, F: Fn<A, B>>(self: Self<A>, _ f: F) -> Self<B> {
123+
// match self {
124+
// Result::Ok(a) => {
125+
// return Result::Ok(f(a))
126+
// }
127+
// Result::Err(e) => {
128+
// return Result::Err(e)
129+
// }
130+
// }
131+
// }
132+
// }
133+
134+
135+
// enum Res<E, T> { // Result<T, E>
136+
// Err(E)
137+
// Ok(T)
138+
// }
139+
// impl Functor for Res<MyError> {
140+
// fn map<A, B, F: Fn<A, B>>(self: Self<A>, _ f: F) -> Self<B> {
141+
// match self {
142+
// Result::Ok(a) => {
143+
// return Result::Ok(f(a))
144+
// }
145+
// Result::Err(e) => {
146+
// return Result::Err(e)
147+
// }
148+
// }
149+
// }
150+
// }
151+
152+
153+
154+
// fn main() {
155+
// let r = foo()
156+
// r.map(|t| ...)
157+
// }
158+
159+
160+
// enum Result1<E, T>
161+
162+
// Result<_, E>
163+
164+
// Flip (Result)
165+
166+
167+
168+
// ((+) `foldl` 0) [1..5]
169+
// ((`foldl` 0) [1..5]) (+)
170+
171+
// flip :: (a -> b -> c) -> b -> a -> c
172+
// f :: a -> b -> c -> d -> e
173+
// flip f :: b -> a -> c -> d -> e

Diff for: ‎library/core/src/monad.fe

+176
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,176 @@
1+
use self::option::Option
2+
use super::num::Num
3+
use super::num::arith::HAdd
4+
5+
trait Tuple<const N: u8> { }
6+
7+
trait Fn<const Arity: u8, Args, Ret> where Args: Tuple<Arity> {
8+
fn exec(self, args: Args) -> Ret
9+
}
10+
11+
pub enum Option<T> {
12+
Some(T),
13+
None
14+
}
15+
16+
trait Applicative
17+
where Self: * -> *
18+
{
19+
fn pure<T>(t: T) -> Self<T>
20+
}
21+
22+
impl Applicative for Option {
23+
fn pure<T>(t: T) -> Self<T> {
24+
Option::Some(t)
25+
}
26+
}
27+
28+
trait Monad: Applicative
29+
where Self: * -> *
30+
{
31+
fn bind<Source, Target, Morph>(self: Self<Source>, morph: Morph) -> Self<Target>
32+
where Morph: Fn<1, (Source), Self<Target>>, (Source): Tuple<1>
33+
}
34+
35+
impl Monad for Option {
36+
fn bind<Source, Target, Morph>(self: Self<Source>, morph: Morph) -> Self<Target>
37+
where Morph: Fn<1, (Source), Self<Target>>, (Source): Tuple<1>
38+
{
39+
match self {
40+
Self::Some(self) => morph.exec(args: (self, ))
41+
Self::None => Self::None
42+
}
43+
}
44+
}
45+
46+
struct BindAdd<N> { n: N }
47+
48+
impl<M: * -> *, N> Fn<1, (N), M<N>> for BindAdd<N>
49+
where M: Monad, N: HAdd<N, N>, (N): Tuple<1>
50+
{
51+
fn exec(self, args: (N)) -> M<N> {
52+
M::pure(t: args.0.add(rhs: self.n))
53+
}
54+
}
55+
56+
impl<M: * -> *, N> HAdd<N, M<N>> for M<N>
57+
where M: Monad, N: HAdd<N, N>, (N): Tuple<1>
58+
{
59+
fn add(self, rhs: N) -> M<N> {
60+
let bind_add = BindAdd { n: rhs }
61+
self.bind<N, N, BindAdd<N>>(morph: bind_add)
62+
}
63+
}
64+
65+
// impl HAdd<u8, Option<u8>> for Option<u8> {
66+
// fn add(self, rhs: u8) -> Option<u8> {
67+
// let bind_add = BindAdd { n: rhs }
68+
// self.bind<u8, u8, BindAdd<u8>>(morph: bind_add)
69+
// }
70+
// }
71+
72+
impl Tuple<1> for (u8) { }
73+
74+
fn test_monadd() {
75+
let a: Option<u8> = Option::Some(42)
76+
let b: u8 = 26
77+
let c: Option<u8> = a.add(rhs: b)
78+
}
79+
80+
// type MyFn = ()
81+
82+
// impl<T> Fn<1, (bool), Option<u8>> for MyFn {
83+
// fn exec(self, args: (bool)) -> Option<u8> {
84+
// Option::Some(0)
85+
// }
86+
// }
87+
88+
// impl Tuple<1> for (bool) { }
89+
90+
// #test
91+
// fn my_test() {
92+
// let f: MyFn = ()
93+
// let a = Option::Some(true).bind<bool, u8, MyFn>(f)
94+
// }
95+
96+
// fn map<T, U,F>(t: T, f: F) -> U
97+
// where F: Fn(T) -> U {...}
98+
99+
// type MyFn = ()
100+
101+
// impl<T, U> Fn<T, U> for Foo {
102+
// fn exec(&self, t: T) -> U {
103+
// t.element(0)
104+
// t.len()
105+
// }
106+
// }
107+
108+
// impl Fn<(u8, u8>, Option<u8>> for MyFn {
109+
// fn exec(t: (bool, bool)) -> Option<u8> {
110+
// let (a, b) = t
111+
// f(a, b)
112+
// }
113+
// }
114+
115+
// sub x y = x - y
116+
// f = sub 1 // f 2 == 1 - 2
117+
// g = `sub` 1 // g 2 == 2 - 1
118+
119+
120+
// enum Result<T, E> {
121+
// Ok(T)
122+
// Err(E)
123+
// }
124+
// impl<E> Functor for Result<*, E> { // or Result<_, E> maybe?
125+
// fn map<A, B, F: Fn<A, B>>(self: Self<A>, _ f: F) -> Self<B> {
126+
// match self {
127+
// Result::Ok(a) => {
128+
// return Result::Ok(f(a))
129+
// }
130+
// Result::Err(e) => {
131+
// return Result::Err(e)
132+
// }
133+
// }
134+
// }
135+
// }
136+
137+
138+
// enum Res<E, T> { // Result<T, E>
139+
// Err(E)
140+
// Ok(T)
141+
// }
142+
// impl Functor for Res<MyError> {
143+
// fn map<A, B, F: Fn<A, B>>(self: Self<A>, _ f: F) -> Self<B> {
144+
// match self {
145+
// Result::Ok(a) => {
146+
// return Result::Ok(f(a))
147+
// }
148+
// Result::Err(e) => {
149+
// return Result::Err(e)
150+
// }
151+
// }
152+
// }
153+
// }
154+
155+
156+
157+
// fn main() {
158+
// let r = foo()
159+
// r.map(|t| ...)
160+
// }
161+
162+
163+
// enum Result1<E, T>
164+
165+
// Result<_, E>
166+
167+
// Flip (Result)
168+
169+
170+
171+
// ((+) `foldl` 0) [1..5]
172+
// ((`foldl` 0) [1..5]) (+)
173+
174+
// flip :: (a -> b -> c) -> b -> a -> c
175+
// f :: a -> b -> c -> d -> e
176+
// flip f :: b -> a -> c -> d -> e

Diff for: ‎library/core/src/monad/map.fe

Whitespace-only changes.

Diff for: ‎library/core/src/monad/option.fe

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
enum Option<Inner> {
1+
pub enum Option<Inner> {
22
Some(Inner),
33
None
44
}

Diff for: ‎library/core/src/num.fe

+15-13
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,21 @@
1-
// use ingot::num::arith::{Add, Sub, Mul, Div, Neg, Mod, Exp}
1+
use ingot::num::arith::{Add, Sub, Mul, Div, Neg, Mod, Pow}
22

3-
// pub trait Num: Add + Sub + Mul + Div + Exp { }
3+
pub trait Num: Add + Sub + Mul + Div + Pow { }
44

5-
// pub trait Complex<N>: Num + Neg {
6-
// fn re() -> N
7-
// fn im() -> N
8-
// }
5+
pub trait Complex<N>: Num + Neg {
6+
fn re() -> N
7+
fn im() -> N
8+
}
99

10-
// pub trait Real: Num + Neg { }
10+
pub trait Real: Num + Neg { }
1111

12-
// pub trait Frac<N>: Num + Neg {
13-
// fn nu() -> N
14-
// fn de() -> N
15-
// }
12+
pub trait Frac<N>: Num + Neg {
13+
fn nu() -> N
14+
fn de() -> N
15+
}
1616

17-
// pub trait Int: Num + Mod + Neg { }
17+
pub trait Int: Num + Mod + Neg { }
1818

19-
// pub trait Nat: Num + Mod { }
19+
pub trait Nat: Num + Mod { }
20+
21+
impl Num for u8 { }

0 commit comments

Comments
 (0)