discro 0.35.0

DISCRete Observables for asynchronous Functional Reactive Programming (FRP).
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

// SPDX-FileCopyrightText: The discro authors
// SPDX-License-Identifier: MPL-2.0

//! Generic traits for verifying that implementations are compliant.

#![expect(dead_code)]

use std::ops::Deref;

use crate::{ModifiedStatus, OrphanedSubscriberError};

pub(crate) trait Ref<T>: Deref<Target = T> {}

pub(crate) trait Readable<'r, T, R>
where
    R: Ref<T> + 'r,
{
    #[must_use]
    fn read(&'r self) -> R;
}

pub(crate) trait Subscribable<'r, T, R, S>
where
    R: Ref<T> + 'r,
    S: Subscriber<'r, T, R>,
{
    #[must_use]
    fn subscribe(&self) -> S;

    #[must_use]
    fn subscribe_changed(&self) -> S;
}

pub(crate) trait Publisher<'r, T, R, O, S>:
    Readable<'r, T, R> + Subscribable<'r, T, R, S> + Clone
where
    R: Ref<T> + 'r,
    O: Observer<'r, T, R, S>,
    S: Subscriber<'r, T, R>,
{
    #[must_use]
    fn observe(&self) -> O;

    #[must_use]
    fn has_subscribers(&self) -> bool;

    fn write(&self, new_value: T);

    #[must_use]
    fn replace(&self, new_value: T) -> T;

    fn modify<M, N>(&self, modify: M) -> N
    where
        M: FnOnce(&mut T) -> N,
        N: ModifiedStatus;

    fn set_modified(&self);
}

pub(crate) trait Observer<'r, T, R, S>:
    Readable<'r, T, R> + Subscribable<'r, T, R, S> + Clone
where
    R: Ref<T> + 'r,
    S: Subscriber<'r, T, R>,
{
}

pub(crate) trait Subscriber<'r, T, R>: Readable<'r, T, R> + Clone
where
    R: Ref<T> + 'r,
{
    #[must_use]
    fn read_ack(&'r mut self) -> R;

    // TODO: How to implement this async fn properly?
    // async fn read_changed(&'r mut self) -> Result<R, OrphanedSubscriberError>;

    // TODO: How to define and implement this async fn properly?
    // async fn map_changed<U>(
    //     &'r mut self,
    //     mut map_fn: impl FnMut(&T) -> U,
    // ) -> Result<U, OrphanedSubscriberError>;

    // TODO: How to define and implement this async fn properly?
    // async fn map_changed<U>(
    //     &'r mut self,
    //     mut map_fn: impl FnMut(&T) -> U,
    // ) -> Result<U, OrphanedSubscriberError>;

    // TODO: How to define and implement this async fn properly?
    // async fn filter_map_changed<U>(
    //     &mut self,
    //     mut filter_map_fn: impl FnMut(&T) -> Option<U>,
    // ) -> Result<U, OrphanedSubscriberError>
}

pub(crate) trait ChangeListener {
    fn mark_changed(&mut self);
    async fn changed(&mut self) -> Result<(), OrphanedSubscriberError>;
}