dxpr 0.2.3

Differentiable expression templates in compile-time, dependency-free, no_std Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Traits to provide `.eval()`.
//!
//! Dependencies:
//! ```text
//!        *Eval
//!       /     \
//! eval::Own eval::Ref
//!       \     /
//!     eval::Typed
//!          |
//!        Sized
//! ```

/// Output type.
#[const_trait]
pub trait Typed: Sized {
    /// Output of evaluation (i.e. `eval() -> ???`).
    type Evaluated;
}

/// Implementation taking `self` (moved).
#[const_trait]
pub trait Own: ~const Typed {
    /// Fold an expression into a value.
    fn eval(self) -> Self::Evaluated;
}

/// Implementation taking `&self` (not moved).
#[const_trait]
pub trait Ref: ~const Typed {
    /// Fold an expression into a value without consuming the expression.
    fn eval(&self) -> Self::Evaluated;
}

/// Trait analogous to a function: an output type and a callable, `eval`.
#[const_trait]
pub trait Eval: ~const Own + ~const Ref {}

/// Automagically implement `Eval`.
#[macro_export]
macro_rules! implement_eval {
    ($name:ty >-> $output:ty: |$self:ident| $body:expr) => {
        impl const $crate::eval::Typed for $name {
            type Evaluated = $output;
        }
        impl const $crate::eval::Own for $name {
            #[inline(always)]
            fn eval($self) -> $output {
                $body
            }
        }
        impl const $crate::eval::Ref for $name {
            #[inline(always)]
            fn eval(&$self) -> $output {
                $body
            }
        }
        impl const Eval for $name {}
    };
    ($($t:ident: $const_trait:path),+ => $name:ty >-> $output:ty: |$self:ident| $body:expr) => {
        impl<$($t: ~const $const_trait),+> const $crate::eval::Typed for $name {
            type Evaluated = $output;
        }
        impl<$($t: ~const $const_trait),+> const $crate::eval::Own for $name {
            #[inline(always)]
            fn eval($self) -> $output {
                $body
            }
        }
        impl<$($t: ~const $const_trait),+> const $crate::eval::Ref for $name {
            #[inline(always)]
            fn eval(&$self) -> $output {
                $body
            }
        }
        impl<$($t: ~const $const_trait),+> const $crate::eval::Eval for $name {}
    };
    // It would be so nice to have `where` as a parallel to C++'s `if constexpr`...
    ($($t:ident: $const_trait:path),+ => $name:ty >-> $output:ty: |$self:ident| where own { $own:expr } else { $ref:expr }) => {
        impl<$($t: ~const $const_trait),+> const $crate::eval::Typed for $name {
            type Evaluated = $output;
        }
        impl<$($t: ~const $const_trait),+> const $crate::eval::Own for $name {
            #[inline(always)]
            fn eval($self) -> $output {
                $own
            }
        }
        impl<$($t: ~const $const_trait),+> const $crate::eval::Ref for $name {
            #[inline(always)]
            fn eval(&$self) -> $output {
                $ref
            }
        }
        impl<$($t: ~const $const_trait),+> const $crate::eval::Eval for $name {}
    };
}

/// Take a function and make it lazily evaluable (under the same name, but in mod \[this mod]::dxpr)
#[macro_export]
macro_rules! op_from_fn {
    ($existing_fn:ident($($arg:ident: $t:ty),+) -> $o:ty) => {
        mod dxpr {
            #![allow(non_camel_case_types)]
            mod ops {
                use $crate::eval::Eval;
                pub struct $existing_fn<$($arg: ~const Eval<Evaluated = $t>),+> { $($arg: $crate::expr::Expr<$arg>),+ }
                impl<$($arg: ~const Eval<Evaluated = $t>),+> $existing_fn<$($arg),+> {
                    #[inline(always)]
                    pub const fn new($($arg: $crate::expr::Expr<$arg>),+) -> Self {
                        Self { $($arg),+ }
                    }
                }
                $crate::implement_eval!(
                    $($arg: Eval<Evaluated = $t>),+ =>
                    $existing_fn<$($arg),+> >-> $o:
                    |self| where own {
                        super::super::$existing_fn($(self.$arg.eval()),+)
                    } else {
                        super::super::$existing_fn($((&self.$arg).eval()),+)
                    }
                );
            }
            #[inline(always)]
            pub const fn $existing_fn<$($arg: ~const $crate::eval::Eval<Evaluated = $t>),+>($($arg: $crate::expr::Expr<$arg>),+) -> ops::$existing_fn<$($arg),+> {
                ops::$existing_fn::new($($arg),+)
            }
        }
    };
}

const fn shit(a: i32, b: i32) -> i32 {
    a + b
}

op_from_fn!(shit(a: i32, b: i32) -> i32);

#[allow(unused)]
const fn check() {
    #![allow(clippy::assertions_on_constants)]
    use crate::{expr::Expr, ops::Add, prelude::*};
    const A: Expr<Add<&i32, &i32>> = var(&1) + var(&2); // -> 3
    const B: Expr<Add<&i32, &i32>> = var(&4) + var(&8); // -> 12
    const C: i32 = dxpr::shit(A, B).eval(); // -> 15
    assert!(C == 15);
}
const _: () = check();