agility 0.1.1

A powerful and elegant reactive programming library for Rust, inspired by category theory
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
148
149
150
151

use crate::signal::Signal;
use crate::signal_sync::SignalSync;

trait Mutable {}

/// Trait for lifting collections of signals into a single signal.
/// For example, lifting (Signal<A>, Signal<B>) into Signal<(A, B)>
pub trait LiftInto<T> {
    /// Lift the collection into a single signal
    ///
    /// # Examples
    /// ```rust
    /// let a = Signal::new(1);
    /// let b = Signal::new(2);
    /// let lifted = [a, b].lift();
    /// lifted.with(|[x, y]| println!("Lifted: {}, {}", x, y));
    /// a.send(10); // prints "Lifted: 10, 2"
    /// b.send(20); // prints "Lifted: 10, 20"
    /// ```
    fn lift(self) -> T;
}

/// Trait for lifting collections of thread-safe signals into a single thread-safe signal.
/// For example, lifting (SignalSync<A>, SignalSync<B>) into SignalSync<(A, B)>
pub trait LiftIntoSync<T> {
    /// Lift the collection into a single thread-safe signal
    fn lift(self) -> T;
}

/// Trait for signal-like types that can be lifted
pub trait Liftable<'a> {
    type Inner;
    /// Get a reference to the underlying signal
    fn as_ref(&self) -> &Signal<'a, Self::Inner>;
}

/// Trait for thread-safe signal-like types that can be lifted
pub trait LiftableSync<'a> {
    type Inner;
    /// Get a reference to the underlying thread-safe signal
    fn as_ref(&self) -> &SignalSync<'a, Self::Inner>;
}

impl<T> Mutable for Vec<T> {}

impl<'a, T> Liftable<'a> for Signal<'a, T> {
    type Inner = T;
    fn as_ref(&self) -> &Signal<'a, Self::Inner> {
        &self
    }
}

impl<'a, T> Liftable<'a> for &Signal<'a, T> {
    type Inner = T;
    fn as_ref(&self) -> &Signal<'a, Self::Inner> {
        self
    }
}

impl<'a, T: Send + Sync + 'a> LiftableSync<'a> for SignalSync<'a, T> {
    type Inner = T;
    fn as_ref(&self) -> &SignalSync<'a, Self::Inner> {
        &self
    }
}

impl<'a, T: Send + Sync + 'a> LiftableSync<'a> for &SignalSync<'a, T> {
    type Inner = T;
    fn as_ref(&self) -> &SignalSync<'a, Self::Inner> {
        self
    }
}

impl<'a, S1, S2> LiftInto<Signal<'a, (S1::Inner, S2::Inner)>> for (S1, S2)
where
    S1: Liftable<'a>,
    S2: Liftable<'a>,
    S1::Inner: 'a,
    S2::Inner: 'a,
{
    fn lift(self) -> Signal<'a, (S1::Inner, S2::Inner)> {
        self.0.as_ref().combine(self.1.as_ref())
    }
}

impl<'a, S, I> LiftInto<Signal<'a, Vec<S::Inner>>> for I
where
    S: Liftable<'a>,
    I: IntoIterator<Item = S> + Mutable,
    S::Inner: 'a,
{
    fn lift(self) -> Signal<'a, Vec<S::Inner>> {
        let mut items: Vec<S> = self.into_iter().collect();
        if items.is_empty() {
            Signal::new(Vec::new())
        } else {
            let first = items.remove(0);
            first.as_ref().extend(items.into_iter())
        }
    }
}

impl<'a, const N: usize, S> LiftInto<Signal<'a, [S::Inner; N]>> for [S; N]
where
    S: Liftable<'a>,
    S::Inner: 'a,
{
    fn lift(self) -> Signal<'a, [S::Inner; N]> {
        Signal::<S::Inner>::lift_from_array::<S, N>(self)
    }
}

// LiftIntoSync implementations for thread-safe variant
impl<'a, S1, S2> LiftIntoSync<SignalSync<'a, (S1::Inner, S2::Inner)>> for (S1, S2)
where
    S1: LiftableSync<'a>,
    S2: LiftableSync<'a>,
    S1::Inner: Send + Sync + 'a,
    S2::Inner: Send + Sync + 'a,
{
    fn lift(self) -> SignalSync<'a, (S1::Inner, S2::Inner)> {
        self.0.as_ref().combine(self.1.as_ref())
    }
}

impl<'a, S, I> LiftIntoSync<SignalSync<'a, Vec<S::Inner>>> for I
where
    S: LiftableSync<'a>,
    I: IntoIterator<Item = S> + Mutable,
    S::Inner: Send + Sync + 'a,
{
    fn lift(self) -> SignalSync<'a, Vec<S::Inner>> {
        let mut items: Vec<S> = self.into_iter().collect();
        if items.is_empty() {
            SignalSync::new(Vec::new())
        } else {
            let first = items.remove(0);
            first.as_ref().extend(items.into_iter())
        }
    }
}

impl<'a, const N: usize, S> LiftIntoSync<SignalSync<'a, [S::Inner; N]>> for [S; N]
where
    S: LiftableSync<'a>,
    S::Inner: Send + Sync + 'a,
{
    fn lift(self) -> SignalSync<'a, [S::Inner; N]> {
        SignalSync::<S::Inner>::lift_from_array::<S, N>(self)
    }
}