spacetimedb-sats 2.2.0

Spacetime Algebraic Type Notation
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

use crate::sum_value::SumTag;
use crate::{i256, u256};
use crate::{AlgebraicType, AlgebraicValue, ProductType, ProductValue};
use spacetimedb_primitives::{ArgId, ColId, ConstraintId, IndexId, ScheduleId, SequenceId, TableId, ViewId};

impl crate::Value for AlgebraicValue {
    type Type = AlgebraicType;
}

impl<X: Into<Box<[AlgebraicValue]>>> From<X> for ProductValue {
    fn from(elements: X) -> Self {
        let elements = elements.into();
        ProductValue { elements }
    }
}

impl From<AlgebraicValue> for ProductValue {
    fn from(x: AlgebraicValue) -> Self {
        [x].into()
    }
}

impl From<AlgebraicType> for ProductType {
    fn from(x: AlgebraicType) -> Self {
        Self::new([x.into()].into())
    }
}

impl From<()> for AlgebraicValue {
    fn from((): ()) -> Self {
        AlgebraicValue::unit()
    }
}

macro_rules! built_in_into {
    ($native:ty, $kind:ident) => {
        impl From<$native> for AlgebraicValue {
            fn from(x: $native) -> Self {
                Self::$kind(x.into())
            }
        }
    };
}

built_in_into!(u128, U128);
built_in_into!(i128, I128);
built_in_into!(u256, U256);
built_in_into!(i256, I256);
built_in_into!(f32, F32);
built_in_into!(f64, F64);
built_in_into!(&str, String);
built_in_into!(String, String);
built_in_into!(&[u8], Bytes);
built_in_into!(Box<[u8]>, Bytes);
built_in_into!(SumTag, Sum);

macro_rules! system_id {
    ($name:ident) => {
        impl From<$name> for AlgebraicValue {
            fn from(value: $name) -> Self {
                value.0.into()
            }
        }
    };
}
system_id!(ArgId);
system_id!(TableId);
system_id!(ViewId);
system_id!(ColId);
system_id!(SequenceId);
system_id!(IndexId);
system_id!(ConstraintId);
system_id!(ScheduleId);