├── .gitignore
├── Cargo.lock
├── Cargo.toml
└── src
    ├── cons.rs
    ├── env.rs
    ├── eval.rs
    ├── expr.rs
    ├── fun.rs
    ├── lib.rs
    ├── main.rs
    ├── num.rs
    ├── symbol.rs
    └── user.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | target
2 | 


--------------------------------------------------------------------------------
/Cargo.lock:
--------------------------------------------------------------------------------
1 | [root]
2 | name = "rustlisp"
3 | version = "0.1.0"
4 | 
5 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "rustlisp"
3 | version = "0.1.0"
4 | authors = ["Sunrin SHIMURA (keen) <3han5chou7@gmail.com>"]
5 | 
6 | [dependencies]
7 | 


--------------------------------------------------------------------------------
/src/cons.rs:
--------------------------------------------------------------------------------
 1 | #![allow(dead_code)]
 2 | use std::marker::PhantomData;
 3 | use expr::*;
 4 | use fun::*;
 5 | use symbol::*;
 6 | 
 7 | pub struct Nil{}
 8 | impl Expr for Nil {
 9 |     fn to_string() -> String {
10 |         "nil".to_string()
11 |     }
12 | }
13 | pub struct ConsCell<T1: Expr, T2: Expr> {
14 |     p1: PhantomData<T1>,
15 |     p2: PhantomData<T2>,
16 | }
17 | 
18 | impl <T1: Expr, T2: Expr> Expr for ConsCell<T1, T2>{
19 |     fn to_string() -> String {
20 |         format!("({} . {})", T1::to_string(), T2::to_string())
21 |     }
22 | }
23 | 
24 | #[macro_export]
25 | macro_rules! list {
26 |     () => {
27 |         $crate::cons::Nil
28 |     };
29 |     (,) => {
30 |         $crate::cons::Nil
31 |     };
32 |     (, $t: ty $(, $tys: ty)*) => {
33 |         $crate::cons::ConsCell<$t , list!($(, $tys)*)>
34 |     };
35 |     ($t: ty $(, $tys: ty)*) => {
36 |         $crate::cons::ConsCell<$t , list!($(, $tys)*)>
37 |     };
38 | }
39 | 
40 | pub type Cons = symbol!(C O N S);
41 | pub type Car = symbol!(C A R);
42 | pub type Cdr = symbol!(C D R);
43 | 
44 | 
45 | impl <T1: Expr, T2: Expr> Fun2<T1, T2> for Cons {
46 |     type Out = ConsCell<T1, T2>;
47 | }
48 | 
49 | impl <T1: Expr, T2: Expr> Fun1<ConsCell<T1, T2>> for Car {
50 |     type Out = T1;
51 | }
52 | 
53 | impl <T1: Expr, T2: Expr> Fun1<ConsCell<T1, T2>> for Cdr {
54 |     type Out = T2;
55 | }
56 | 


--------------------------------------------------------------------------------
/src/env.rs:
--------------------------------------------------------------------------------
 1 | #![allow(dead_code)]
 2 | use std::marker::PhantomData;
 3 | use expr::*;
 4 | 
 5 | pub trait Env{ }
 6 | pub struct Bottom;
 7 | pub struct Stack<Elm: Expr, T: Env> {pelm: PhantomData<Elm>, pt: PhantomData<T>}
 8 | impl Env for Bottom {}
 9 | impl <Elm: Expr, T: Env>Env for Stack<Elm, T> {}
10 | 
11 | pub type Stack1<T1: Expr> = Stack<T1, Bottom>;
12 | pub type Stack2<T1: Expr, T2: Expr> = Stack<T1, Stack1<T2>>;
13 | pub type Stack3<T1: Expr, T2: Expr, T3: Expr> = Stack<T1, Stack2<T2, T3>>;
14 | pub type Stack4<T1: Expr, T2: Expr, T3: Expr, T4: Expr> = Stack<T1, Stack3<T2, T3, T4>>;
15 | 


--------------------------------------------------------------------------------
/src/eval.rs:
--------------------------------------------------------------------------------
 1 | #![allow(dead_code)]
 2 | use std::marker::PhantomData;
 3 | use expr::*;
 4 | use env::*;
 5 | use fun::*;
 6 | use num::*;
 7 | use symbol::*;
 8 | use cons::*;
 9 | 
10 | // trait Eval<E: Expr> {
11 | //     type Out: Env;
12 | // }
13 | 
14 | // impl <Ev: Env, N: Num>Eval<Number<N>> for Ev {
15 | //     type Out = Stack<Number<N>, Ev>;
16 | // }
17 | 
18 | // impl <Ev: Env, S: Sym>Eval<Symbol<S>> for Ev {
19 | //     type Out = Stack<Symbol<S>, Ev>;
20 | // }
21 | 
22 | // trait Call<E: Expr> {
23 | //     type Out: Env;
24 | // }
25 | 
26 | // impl <Ev: Env, S: Sym, T1: Expr, T1O: Expr, FO: Expr>Eval<List2<Symbol<S>, T1>> for Ev
27 | //     where Ev: Eval<T1, Out = Stack<T1O, Ev>>,
28 | //           Symbol<S>: Fun1<T1O, Out = FO>,
29 | // {
30 | //     type Out = Stack<FO, Ev>;
31 | // }
32 | 
33 | pub trait Eval {
34 |     type Out: Expr;
35 | }
36 | 
37 | impl <N: Num>Eval for Number<N> {
38 |     type Out = Number<N>;
39 | }
40 | 
41 | impl <S: Sym>Eval for Symbol<S> {
42 |     type Out = Symbol<S>;
43 | }
44 | 
45 | impl <S: Sym, T1: Expr, T1O: Expr, O: Expr>Eval for list!(Symbol<S>, T1)
46 |     where T1: Eval<Out = T1O>,
47 |           Symbol<S>: Fun1<T1O, Out = O>,
48 | {
49 |     type Out = O;
50 | }
51 | 
52 | impl <S: Sym, T1: Expr, T2: Expr, T1O: Expr, T2O: Expr, O: Expr>Eval for list!(Symbol<S>, T1, T2)
53 |     where T1: Eval<Out = T1O>,
54 |           T2: Eval<Out = T2O>,
55 |           Symbol<S>: Fun2<T1O, T2O, Out = O>,
56 | {
57 |     type Out = O;
58 | }
59 | 
60 | 


--------------------------------------------------------------------------------
/src/expr.rs:
--------------------------------------------------------------------------------
 1 | #![allow(dead_code)]
 2 | use std::marker::PhantomData;
 3 | 
 4 | pub struct Stuck;
 5 | pub struct Nothing;
 6 | pub trait Expr {
 7 |         fn to_string() -> String;
 8 | }
 9 | impl Expr for Stuck {
10 |     fn to_string() -> String {
11 |         "stuck".to_string()
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/fun.rs:
--------------------------------------------------------------------------------
 1 | #![allow(dead_code)]
 2 | use expr::*;
 3 | 
 4 | pub trait Fun1<T: Expr> {
 5 |     type Out: Expr;
 6 | }
 7 | 
 8 | impl <T: Expr>Fun1<T>  for Stuck {
 9 |     type Out = Stuck;
10 | }
11 | 
12 | pub trait Fun2<T1: Expr, T2: Expr> {
13 |     type Out: Expr;
14 | }
15 | 
16 | impl <T1: Expr, T2: Expr>Fun2<T1, T2>  for Stuck {
17 |     type Out = Stuck;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | use std::marker::PhantomData;
 2 | 
 3 | pub mod expr;
 4 | #[macro_use]
 5 | pub mod symbol;
 6 | pub mod fun;
 7 | pub mod num;
 8 | #[macro_use]
 9 | pub mod cons;
10 | pub mod env;
11 | pub mod eval;
12 | pub mod user;
13 | 
14 | 
15 | #[macro_export]
16 | macro_rules! eval {
17 |     ($t: ty) => {
18 |         <<$t as $crate::eval::Eval>::Out as $crate::expr::Expr>::to_string()
19 |     };
20 | }
21 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
 1 | #[macro_use]
 2 | extern crate rustlisp;
 3 | use rustlisp::expr::*;
 4 | use rustlisp::fun::*;
 5 | use rustlisp::num::*;
 6 | use rustlisp::symbol::*;
 7 | use rustlisp::cons::*;
 8 | use rustlisp::eval::*;
 9 | use rustlisp::user::*;
10 | 
11 | fn main() {
12 |     println!("{}", Car::to_string());
13 |     println!("{}", _3::to_string());
14 |     println!("{}", <<Add as Fun2<_1, _3>>::Out as Expr>::to_string());
15 |     println!("{}", eval!(list!(Fib, _3)));
16 | }
17 | 


--------------------------------------------------------------------------------
/src/num.rs:
--------------------------------------------------------------------------------
 1 | #![allow(dead_code)]
 2 | use std::marker::PhantomData;
 3 | use expr::*;
 4 | use fun::*;
 5 | use symbol::*;
 6 | 
 7 | pub struct Number<N: Num> {
 8 |     number: PhantomData<N>,
 9 | }
10 | 
11 | impl <N: Num>Expr for Number<N> {
12 |     fn to_string() -> String {
13 |         N::to_string()
14 |     }
15 | }
16 | 
17 | pub trait Num {
18 |     fn to_string() -> String {
19 |         Self::to_int().to_string()
20 |     }
21 |     fn to_int() -> isize;
22 | }
23 | pub struct Zero;
24 | pub struct Succ<T: Num> {t: PhantomData<T>}
25 | impl Num for Zero {
26 |     fn to_int() -> isize {
27 |         0
28 |     }
29 | }
30 | impl <T: Num>Num for Succ<T> {
31 |     fn to_int() -> isize {
32 |         1 + T::to_int()
33 |     }
34 | }
35 | 
36 | macro_rules! numty {
37 |     ($num: ident, $n: ident, $p: ty) => {
38 |         pub type $n= Succ<$p>;
39 |         pub type $num = Number<$n>;
40 |     }
41 | }
42 | 
43 | pub type __0 = Zero;
44 | pub type _0 = Number<__0>;
45 | numty!(_1, __1, __0);
46 | numty!(_2, __2, __1);
47 | numty!(_3, __3, __2);
48 | numty!(_4, __4, __3);
49 | numty!(_5, __5, __4);
50 | numty!(_6, __6, __5);
51 | numty!(_7, __7, __6);
52 | numty!(_8, __8, __7);
53 | numty!(_9, __9, __8);
54 | numty!(_10, __10, __9);
55 | 
56 | 
57 | pub type Add = symbol!(A D D);
58 | pub type Mul = symbol!(M U L);
59 | 
60 | impl <T1: Num> Fun2<Number<T1>, _0> for Add {
61 |     type Out = Number<T1>;
62 | }
63 | 
64 | impl <T1: Num, T2: Num, ON: Num> Fun2<Number<T1>, Number<Succ<T2>>> for Add
65 |     where Add: Fun2<Number<Succ<T1>>, Number<T2>, Out = Number<ON>> {
66 |     type Out = Number<ON>;
67 | }
68 | 
69 | 
70 | 


--------------------------------------------------------------------------------
/src/symbol.rs:
--------------------------------------------------------------------------------
 1 | #![allow(dead_code)]
 2 | use std::marker::PhantomData;
 3 | use expr::*;
 4 | 
 5 | pub struct Symbol<S: Sym>{
 6 |     s: PhantomData<S>
 7 | }
 8 | 
 9 | impl <S: Sym>Expr for Symbol<S> {
10 |     fn to_string() -> String {
11 |         S::to_string()
12 |     }
13 | }
14 | 
15 | pub trait Sym {
16 |     fn to_string() -> String;
17 | }
18 | pub trait SymChar{
19 |     fn to_string() -> String;
20 | }
21 | pub struct Eos;
22 | pub struct SymCons<C: SymChar, S: Sym> {
23 |     cp: PhantomData<C>,
24 |     sp: PhantomData<S>,
25 | }
26 | impl Sym for Eos{
27 |     fn to_string() -> String {
28 |         "".to_string()
29 |     }
30 | }
31 | impl <C: SymChar, S: Sym>Sym for SymCons<C, S>{
32 |     fn to_string() -> String {
33 |         C::to_string() + &S::to_string()
34 |     }
35 | 
36 | }
37 | 
38 | macro_rules! symchar {
39 |     ($c: ident) => {
40 |         pub struct $c;
41 |         impl SymChar for $c {
42 |             fn to_string() -> String {
43 |                 stringify!($c).to_string()
44 |             }
45 |         }
46 |     }
47 | }
48 | macro_rules! symchars {
49 |     ($c1: ident) => {
50 |         symchar!($c1);
51 |     };
52 |     ($c1: ident,) => {
53 |         symchar!($c1);
54 |     };
55 |     ($c1: ident $(, $c: ident)*) => {
56 |         symchar!($c1);
57 |         symchars!($($c,)*);
58 |     };
59 |     ($c1: ident $(, $c: ident)*,) => {
60 |         symchar!($c1);
61 |         symchars!($($c,)*);
62 |     };
63 | }
64 | symchars!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z);
65 | 
66 | #[macro_export]
67 | macro_rules! sym {
68 |     () => {
69 |         $crate::symbol::Eos
70 |     };
71 |     (,) => {
72 |         $crate::symbol::Eos
73 |     };
74 |     (, $t: ty $(, $tys: ty)*) => {
75 |         $crate::symbol::SymCons<$t , sym!($(, $tys)*)>
76 |     };
77 |     ($t: ty $(, $tys: ty)*) => {
78 |         $crate::symbol::SymCons<$t , sym!($(, $tys)*)>
79 |     };
80 | }
81 | 
82 | #[macro_export]
83 | macro_rules! symbol {
84 |     ($($sym:ty)*) => {
85 |         Symbol<sym!($(, $sym)*)>
86 |     };
87 | }
88 | 


--------------------------------------------------------------------------------
/src/user.rs:
--------------------------------------------------------------------------------
 1 | use expr::*;
 2 | use symbol::*;
 3 | use fun::*;
 4 | use num::*;
 5 | use eval::*;
 6 | 
 7 | pub type Fib = symbol!(F I B);
 8 | 
 9 | impl Fun1<_0> for Fib {
10 |     type Out = _1;
11 | }
12 | 
13 | impl Fun1<_1> for Fib {
14 |     type Out = _1;
15 | }
16 | 
17 | impl <T1N: Num, N1_O: Num, N2_O: Num, NO: Num>Fun1<Number<Succ<Succ<T1N>>>> for Fib
18 |     where Fib: Fun1<Number<Succ<T1N>>, Out = Number<N1_O>>,
19 |           Fib: Fun1<Number<     T1N >, Out = Number<N2_O>>,
20 |           Add: Fun2<Number<N1_O>, Number<N2_O>, Out = Number<NO>>
21 | {
22 |     type Out = Number<NO>;
23 | }
24 | 


--------------------------------------------------------------------------------