Serialize 对许多类型实现了。最值得注意的是，对所有原始类型 T（除了 usize 和 isize）实现了 T: Serialize<T> 和 &T: Serialize<T>。另一个重要的实现是 Serialize<F> for I where I: IntoIterator, I::Item: Serialize<F>，允许直接从迭代器和集合中序列化到切片。使用 Ref<F> 的序列化使用 F 的序列化公式，然后存储相对地址和大小。不需要动态分配。

为类型推导 Serialize 将生成 Serialize 实现，公式在属性 #[alkahest(FormulaRef)] 或 #[alkahest(serialize(FormulaRef))] 中指定。通常 FormulaRef 是一个类型。当使用泛型时，它还包含泛型参数和界限。如果没有指定公式，则假定 Self。还应该为类型推导 Formula。不建议为手动实现 Formula 的公式推导 Serialize，因为 Serialize 推导宏生成的代码使用了由 Formula 推导宏生成的非公共项。因此，两者都应该有手动实现或都进行推导。

对于结构，Serialize 推导宏要求所有字段都存在于 Serialize 和 Formula 结构中，并且顺序相同（如果是同一结构，则非常简单）。

对于枚举，Serialize 推导宏检查对于每个变体，在 Formula 枚举中存在相应的变体。变体内容与结构类似进行比较。序列化会插入变体 ID，并将变体作为结构序列化。变体的尺寸可能不同。如果需要，外值序列化会插入填充。

Serialize 可以用于具有枚举类型 Formula 的结构。在这种情况下，应使用 #[alkahest(@variant_ident)] 或 #[alkahest(serialize(@variant_ident))] 来指定变体。然后，Serialize 派生宏将生成类似于此变体是结构 Formula 的序列化代码，除了变体的 ID 将在字段之前序列化。

Serialize 仅当 Formula 也是枚举时才能用于枚举。可序列化的枚举可以省略 Formula 中的某些（或所有）变体。它不能缺少 Formula 中的变体。每个变体随后遵循结构的规则。

为了方便起见，Infallible 为枚举公式实现了 Serialize。

反序列化

使用 Deserialize<'de, Formula> 特性来根据特定公式实现反序列化。反序列化从字节切片中读取，构建反序列化的值。反序列化 不应 执行动态分配，除非需要构建和初始化反序列化值。例如，如果反序列化出非零数量的 Vec<T>，则允许分配。它 不应 过度分配。

类似于 Serialize，alkahest 提供了一系列现成的 Deserialize 特性实现。可以使用原始公式 T 反序列化 From<T> 类型。

可以使用公式 F 反序列化的值也可以使用 Ref<F> 反序列化，它读取地址和长度，然后使用公式 F 继续操作。

Vec<T> 可以使用切片公式进行反序列化。针对 Deserialize<'de, [F]> 的实现，针对 alkahest::SliceIter<'de, T> 类型，该类型实现了 Iterator 并懒加载地反序列化类型 T: Deserialize<'de, F> 的元素。 SliceIter 可被复制，可以从两端迭代，并且可以在常数时间内跳过元素。为了方便，SliceIter 也使用数组公式进行反序列化。

为一个类型推导 Deserialize 将生成 Deserialize 的实现，公式在属性 #[alkahest(FormulaRef)] 或 #[alkahest(deserialize(FormulaRef))] 中指定。 FormulaRef 通常是一个类型。当使用泛型时，它还包含泛型参数和限制。如果没有指定公式，则假定 Self。还应为该类型推导 Formula。不建议为具有手动 Formula 实现的公式推导 Deserialize，因为 Deserialize 推导宏生成的代码使用了由 Formula 推导宏生成的非公开项。因此，两者都应有手动实现或都进行推导。

与 serde 的互操作性

Alkahest 很酷，但 serde 几乎被普遍使用，而且有很好的理由。在设计 Formula 时，可能希望包括支持序列化的现有类型，尤其是如果它来自另一个包。这个包提供了 Bincode 和 Bincoded<T> 公式来覆盖这一点。任何具有 serde::Serialize 实现的类型都可以使用 Bincode 公式进行序列化，自然地，它将使用 bincode 包进行序列化。 Bincoded<T> 是 Bincode 的一个受限版本，它仅适用于 T。

// This requires two default features - "alloc" and "derive".
#[cfg(all(feature = "derive", feature = "alloc"))]
fn main() {
  use alkahest::{alkahest, serialize_to_vec, deserialize};

  // Define simple formula. Make it self-serializable.
  #[derive(Clone, Debug, PartialEq, Eq)]
  #[alkahest(Formula, SerializeRef, Deserialize)]
  struct MyDataType {
    a: u32,
    b: Vec<u8>,
  }

  // Prepare data to serialize.
  let value = MyDataType {
    a: 1,
    b: vec![2, 3],
  };

  // Use infallible serialization to `Vec`.
  let mut data = Vec::new();

  // Note that this value can be serialized by reference.
  // This is default behavior for `Serialized` derive macro.
  // Some types required ownership transfer for serialization.
  // Notable example is iterators.
  let (size, _) = serialize_to_vec::<MyDataType, _>(&value, &mut data);

  let de = deserialize::<MyDataType, MyDataType>(&data[..size]).unwrap();
  assert_eq!(de, value);
}

#[cfg(not(all(feature = "derive", feature = "alloc")))]
fn main() {}