Extract ArrayValue, ArrayType, MapValue, MapType to own files (…

…#387)

* move ArrayType to own file

* move MapType to own file

* move ArrayValue to own file

* move MapValue to own file

crates/sats/src/algebraic_value.rs

@@ -3,10 +3,15 @@ pub mod ser;
 use std::collections::BTreeMap;
 use std::ops::{Bound, RangeBounds};
 
-use crate::builtin_value::{F32, F64};
 use crate::{AlgebraicType, ArrayValue, BuiltinType, BuiltinValue, ProductValue, SumValue};
 use enum_as_inner::EnumAsInner;
 
+/// Totally ordered [`f32`] allowing all IEEE-754 floating point values.
+pub type F32 = decorum::Total<f32>;
+
+/// Totally ordered [`f64`] allowing all IEEE-754 floating point values.
+pub type F64 = decorum::Total<f64>;
+
 /// A value in SATS typed at some [`AlgebraicType`].
 ///
 /// Values are type erased, so they do not store their type.

crates/sats/src/algebraic_value/de.rs

@@ -1,4 +1,4 @@
-use crate::builtin_value::{ArrayValueIntoIter, ArrayValueIterCloned};
+use crate::array_value::{ArrayValueIntoIter, ArrayValueIterCloned};
 use crate::{de, AlgebraicValue, SumValue};
 
 use derive_more::From;

crates/sats/src/array_type.rs

@@ -0,0 +1,24 @@
+use crate::algebraic_type::AlgebraicType;
+use crate::de::Deserialize;
+use crate::meta_type::MetaType;
+use crate::{impl_deserialize, impl_serialize};
+
+/// An array type is a homegeneous product type of dynamic length.
+///
+/// That is, it is a product type
+/// where every element / factor / field is of the same type
+/// and where the length is statically unknown.
+#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct ArrayType {
+    /// The base type every element of the array has.
+    pub elem_ty: Box<AlgebraicType>,
+}
+
+impl_serialize!([] ArrayType, (self, ser) => self.elem_ty.serialize(ser));
+impl_deserialize!([] ArrayType, de => Deserialize::deserialize(de).map(|elem_ty| Self { elem_ty }));
+
+impl MetaType for ArrayType {
+    fn meta_type() -> AlgebraicType {
+        AlgebraicType::ZERO_REF
+    }
+}