alice-math 0.1.0

A topology and algebra library from first principles
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

use alloc::boxed::Box;

pub trait Morphism {
    type Domain: Clone;
    type Codomain: Clone;

    fn apply(&self, x: &Self::Domain) -> Self::Codomain;
}

pub trait Composable<M>: Morphism
where
    M: Morphism<Codomain = Self::Domain>,
{
    type Composed: Morphism<Domain = M::Domain, Codomain = Self::Codomain>;
    fn compose(self, other: M) -> Self::Composed;
}

pub trait Invertible: Morphism {
    type Inverse: Morphism<Domain = Self::Codomain, Codomain = Self::Domain>;
    fn inverse(self) -> Self::Inverse;
}

pub struct MapMorphism<A, B> {
    f: Box<dyn Fn(&A) -> B + Send + Sync>,
}

impl<A: Clone, B: Clone> MapMorphism<A, B> {
    pub fn new<F>(f: F) -> Self
    where
        F: Fn(&A) -> B + Send + Sync + 'static,
    {
        Self { f: Box::new(f) }
    }
}

impl<A: Clone, B: Clone> Morphism for MapMorphism<A, B> {
    type Domain = A;
    type Codomain = B;

    fn apply(&self, x: &A) -> B {
        (self.f)(x)
    }
}

pub struct ComposedMorphism<F, G> {
    outer: F,
    inner: G,
}

impl<F, G> Morphism for ComposedMorphism<F, G>
where
    F: Morphism,
    G: Morphism<Codomain = F::Domain>,
{
    type Domain = G::Domain;
    type Codomain = F::Codomain;

    fn apply(&self, x: &Self::Domain) -> Self::Codomain {
        let intermediate = self.inner.apply(x);
        self.outer.apply(&intermediate)
    }
}

impl<F, G> Composable<G> for F
where
    F: Morphism,
    G: Morphism<Codomain = F::Domain>,
{
    type Composed = ComposedMorphism<F, G>;

    fn compose(self, other: G) -> Self::Composed {
        ComposedMorphism {
            outer: self,
            inner: other,
        }
    }
}

pub struct IdentityMorphism<A> {
    _marker: core::marker::PhantomData<A>,
}

impl<A> IdentityMorphism<A> {
    pub fn new() -> Self {
        Self {
            _marker: core::marker::PhantomData,
        }
    }
}

impl<A> Default for IdentityMorphism<A> {
    fn default() -> Self {
        Self::new()
    }
}

impl<A: Clone> Morphism for IdentityMorphism<A> {
    type Domain = A;
    type Codomain = A;

    fn apply(&self, x: &A) -> A {
        x.clone()
    }
}

impl<A: Clone> Invertible for IdentityMorphism<A> {
    type Inverse = IdentityMorphism<A>;

    fn inverse(self) -> Self::Inverse {
        Self::new()
    }
}