actuate 0.21.0

A reactive user-interface framework
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

use crate::{compose::Compose, Data, Scope, ScopeState};
use core::marker::PhantomData;

/// Create a composable from a function.
///
/// This will create a composable from a function that takes a [`ScopeState`] and returns some composable content.
///
/// # Examples
///
/// ```
/// use actuate::prelude::*;
///
/// #[derive(Data)]
/// struct User {
///     id: i32,
/// }
///
/// impl Compose for User {
///     fn compose(cx: Scope<Self>) -> impl Compose {}
/// }
///
/// #[derive(Data)]
/// struct App;
///
/// impl Compose for App {
///     fn compose(cx: Scope<Self>) -> impl Compose {
///         compose::from_fn(|_cx| {
///             User { id: 0 }
///         })
///     }
/// }
/// ```
pub fn from_fn<F, C>(f: F) -> FromFn<F, C>
where
    F: Fn(ScopeState) -> C,
    C: Compose,
{
    FromFn {
        f,
        _marker: PhantomData,
    }
}

/// Function composable.
///
/// For more see [`from_fn`].
pub struct FromFn<F, C> {
    f: F,
    _marker: PhantomData<C>,
}

impl<F: Clone, C> Clone for FromFn<F, C> {
    fn clone(&self) -> Self {
        Self {
            f: self.f.clone(),
            _marker: PhantomData,
        }
    }
}

unsafe impl<F, C> Data for FromFn<F, C>
where
    F: Fn(ScopeState) -> C,
    C: Compose,
{
}

impl<F, C> Compose for FromFn<F, C>
where
    F: Fn(ScopeState) -> C,
    C: Compose,
{
    fn compose(cx: Scope<Self>) -> impl Compose {
        (cx.me().f)(&cx)
    }
}