Updated everything and moved to hard tab indentation

orchid-api/src/atom.rs

@@ -3,7 +3,9 @@ use std::num::NonZeroU64;
 use orchid_api_derive::{Coding, Hierarchy};
 use orchid_api_traits::Request;
 
-use crate::{ExprTicket, Expression, ExtHostReq, HostExtNotif, HostExtReq, OrcResult, SysId, TStrv};
+use crate::{
+	ExprTicket, Expression, ExtHostReq, HostExtNotif, HostExtReq, OrcResult, SysId, TStrv,
+};
 
 pub type AtomData = Vec<u8>;
 
@@ -15,34 +17,34 @@ pub struct AtomId(pub NonZeroU64);
 /// This has the same semantics as [Atom] except in that the owner is implied.
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Coding)]
 pub struct LocalAtom {
-  pub drop: Option<AtomId>,
-  pub data: AtomData,
+	pub drop: Option<AtomId>,
+	pub data: AtomData,
 }
 impl LocalAtom {
-  pub fn associate(self, owner: SysId) -> Atom { Atom { owner, drop: self.drop, data: self.data } }
+	pub fn associate(self, owner: SysId) -> Atom { Atom { owner, drop: self.drop, data: self.data } }
 }
 
 /// An atom representation that can be serialized and sent around. Atoms
 /// represent the smallest increment of work.
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Coding)]
 pub struct Atom {
-  /// Instance ID of the system that created the atom
-  pub owner: SysId,
-  /// Indicates how the owner should be notified when this atom is dropped.
-  /// Construction is always explicit and atoms are never cloned.
-  ///
-  /// Atoms with `drop == None` are also known as trivial, they can be
-  /// duplicated and stored with no regard to expression lifetimes. NOTICE
-  /// that this only applies to the atom. If it's referenced with an
-  /// [ExprTicket], the ticket itself can still expire.
-  ///
-  /// Notice also that the atoms still expire when the system is dropped, and
-  /// are not portable across instances of the same system, so this doesn't
-  /// imply that the atom is serializable.
-  pub drop: Option<AtomId>,
-  /// Data stored in the atom. This could be a key into a map, or the raw data
-  /// of the atom if it isn't too big.
-  pub data: AtomData,
+	/// Instance ID of the system that created the atom
+	pub owner: SysId,
+	/// Indicates how the owner should be notified when this atom is dropped.
+	/// Construction is always explicit and atoms are never cloned.
+	///
+	/// Atoms with `drop == None` are also known as trivial, they can be
+	/// duplicated and stored with no regard to expression lifetimes. NOTICE
+	/// that this only applies to the atom. If it's referenced with an
+	/// [ExprTicket], the ticket itself can still expire.
+	///
+	/// Notice also that the atoms still expire when the system is dropped, and
+	/// are not portable across instances of the same system, so this doesn't
+	/// imply that the atom is serializable.
+	pub drop: Option<AtomId>,
+	/// Data stored in the atom. This could be a key into a map, or the raw data
+	/// of the atom if it isn't too big.
+	pub data: AtomData,
 }
 
 /// Attempt to apply an atom as a function to an expression
@@ -50,7 +52,7 @@ pub struct Atom {
 #[extends(AtomReq, HostExtReq)]
 pub struct CallRef(pub Atom, pub ExprTicket);
 impl Request for CallRef {
-  type Response = Expression;
+	type Response = Expression;
 }
 
 /// Attempt to apply an atom as a function, consuming the atom and enabling the
@@ -60,21 +62,21 @@ impl Request for CallRef {
 #[extends(AtomReq, HostExtReq)]
 pub struct FinalCall(pub Atom, pub ExprTicket);
 impl Request for FinalCall {
-  type Response = Expression;
+	type Response = Expression;
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Coding, Hierarchy)]
 #[extends(AtomReq, HostExtReq)]
 pub struct SerializeAtom(pub Atom);
 impl Request for SerializeAtom {
-  type Response = Option<(Vec<u8>, Vec<ExprTicket>)>;
+	type Response = Option<(Vec<u8>, Vec<ExprTicket>)>;
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Coding, Hierarchy)]
 #[extends(HostExtReq)]
 pub struct DeserAtom(pub SysId, pub Vec<u8>, pub Vec<ExprTicket>);
 impl Request for DeserAtom {
-  type Response = Atom;
+	type Response = Atom;
 }
 
 /// A request blindly routed to the system that provides an atom.
@@ -82,26 +84,26 @@ impl Request for DeserAtom {
 #[extends(AtomReq, HostExtReq)]
 pub struct Fwded(pub Atom, pub TStrv, pub Vec<u8>);
 impl Request for Fwded {
-  type Response = Option<Vec<u8>>;
+	type Response = Option<Vec<u8>>;
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Coding, Hierarchy)]
 #[extends(ExtHostReq)]
 pub struct Fwd(pub Atom, pub TStrv, pub Vec<u8>);
 impl Request for Fwd {
-  type Response = Option<Vec<u8>>;
+	type Response = Option<Vec<u8>>;
 }
 
 #[derive(Clone, Debug, Coding)]
 pub enum NextStep {
-  Continue(Expression),
-  Halt,
+	Continue(Expression),
+	Halt,
 }
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Coding, Hierarchy)]
 #[extends(AtomReq, HostExtReq)]
 pub struct Command(pub Atom);
 impl Request for Command {
-  type Response = OrcResult<NextStep>;
+	type Response = OrcResult<NextStep>;
 }
 
 /// Notification that an atom is being dropped because its associated expression
@@ -115,7 +117,7 @@ pub struct AtomDrop(pub SysId, pub AtomId);
 #[extends(AtomReq, HostExtReq)]
 pub struct AtomPrint(pub Atom);
 impl Request for AtomPrint {
-  type Response = String;
+	type Response = String;
 }
 
 /// Requests that apply to an existing atom instance
@@ -123,24 +125,24 @@ impl Request for AtomPrint {
 #[extends(HostExtReq)]
 #[extendable]
 pub enum AtomReq {
-  CallRef(CallRef),
-  FinalCall(FinalCall),
-  Fwded(Fwded),
-  Command(Command),
-  AtomPrint(AtomPrint),
-  SerializeAtom(SerializeAtom),
+	CallRef(CallRef),
+	FinalCall(FinalCall),
+	Fwded(Fwded),
+	Command(Command),
+	AtomPrint(AtomPrint),
+	SerializeAtom(SerializeAtom),
 }
 impl AtomReq {
-  /// Obtain the first [Atom] argument of the request. All requests in this
-  /// subclass have at least one atom argument.
-  pub fn get_atom(&self) -> &Atom {
-    match self {
-      Self::CallRef(CallRef(a, ..))
-      | Self::Command(Command(a))
-      | Self::FinalCall(FinalCall(a, ..))
-      | Self::Fwded(Fwded(a, ..))
-      | Self::AtomPrint(AtomPrint(a))
-      | Self::SerializeAtom(SerializeAtom(a)) => a,
-    }
-  }
+	/// Obtain the first [Atom] argument of the request. All requests in this
+	/// subclass have at least one atom argument.
+	pub fn get_atom(&self) -> &Atom {
+		match self {
+			Self::CallRef(CallRef(a, ..))
+			| Self::Command(Command(a))
+			| Self::FinalCall(FinalCall(a, ..))
+			| Self::Fwded(Fwded(a, ..))
+			| Self::AtomPrint(AtomPrint(a))
+			| Self::SerializeAtom(SerializeAtom(a)) => a,
+		}
+	}
 }