Merge pull request #6 from FL03/v0.1.2

V0.1.2

Author: FL03

contained/Cargo.toml

@@ -27,6 +27,7 @@ scsys = { features = ["derive"], version = "0.1.41" }
 # Standard dependencies
 anyhow = "1"
 clap = { features = ["cargo", "derive", "env"], version = "4" }
+futures = "0.3"
 serde = { features = ["derive"], version = "1" }
 serde_json = "1"
 smart-default = "0.6"

contained/examples/basic.rs

@@ -5,4 +5,38 @@
 */
 extern crate contained;
 
-fn main() {}
+use contained::turing::{
+    Configurable, Configuration, Machine, Move, Program, Programatic, Tape, Turing,
+};
+use contained::{Resultant, State, States};
+
+fn main() -> Resultant {
+    let alphabet = vec!["a", "b", "c"];
+
+    let tape = Tape::new(alphabet.clone());
+    let mut cnf = Configuration::norm(tape)?;
+
+    // Setup the program
+    let final_state = State::from(&States::invalid());
+    let mut program = Program::new(alphabet, final_state);
+    // Instruction set; turn ["a", "b", "c"] into ["c", "a", "a"]
+    program.insert((State::default(), "a", State::default(), "c", Move::Right).into())?;
+    program.insert((State::default(), "b", State::default(), "a", Move::Right).into())?;
+    program.insert(
+        (
+            State::default(),
+            "c",
+            State::from(&States::invalid()),
+            "a",
+            Move::Left,
+        )
+            .into(),
+    )?;
+
+    let a = Machine::new("a", program.clone())?;
+    let res = a.execute(&mut cnf)?;
+    assert_eq!(res.tape().tape().clone(), vec!["c", "a", "a"]);
+    println!("{:?}", res);
+
+    Ok(())
+}

contained/examples/neo.rs

@@ -0,0 +1,57 @@
+/*
+    Appellation: basic <example>
+    Contrib: FL03 <jo3mccain@icloud.com>
+    Description: ... summary ...
+*/
+extern crate contained;
+
+use contained::neo::{Triad, Triadic, Triads};
+use contained::turing::{Configuration, Program, Programatic, Turing};
+use contained::{cmp::Note, Resultant, State, States};
+
+fn main() -> Resultant {
+    let triad = Triad::new(0.into(), Triads::Diminshed);
+
+    let alphabet: Vec<Note> = triad.clone().into_iter().collect();
+    let mut cnf: Configuration<Note> = triad.config();
+
+    // Setup the program
+    let final_state = State::from(&States::invalid());
+    let mut program = Program::new(alphabet, final_state);
+    // Instruction set; turn ["C", "D#", "F#"] into ["F#", "D#", "D#"]
+    program.insert(
+        (
+            State::default(),
+            0.into(),
+            State::default(),
+            6.into(),
+            1.into(),
+        )
+            .into(),
+    )?;
+    program.insert(
+        (
+            State::default(),
+            3.into(),
+            State::default(),
+            3.into(),
+            1.into(),
+        )
+            .into(),
+    )?;
+    program.insert(
+        (
+            State::default(),
+            6.into(),
+            State::from(&States::invalid()),
+            3.into(),
+            2.into(),
+        )
+            .into(),
+    )?;
+
+    let res = triad.machine(program)?.execute(&mut cnf)?;
+    println!("{:?}", res);
+
+    Ok(())
+}

contained/src/cmp/chord.rs

@@ -0,0 +1,103 @@
+/*
+    Appellation: chord <module>
+    Contrib: FL03 <jo3mccain@icloud.com>
+    Description: A chord is any set of notes played simultaneously; for our considerations, allow a chord to represent the alphabet of a Turing machine or automata.
+
+*/
+use crate::cmp::Note;
+use crate::ArrayLike;
+use serde::{Deserialize, Serialize};
+use smart_default::SmartDefault;
+use strum::{Display, EnumString, EnumVariantNames};
+
+/// [Chord] is a wrapper for a [Vec] of [Note]
+#[derive(Clone, Debug, Default, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
+pub struct Chord(Vec<Note>);
+
+impl Chord {
+    pub fn new(chord: impl IntoIterator<Item = Note>) -> Self {
+        Self(Vec::from_iter(chord))
+    }
+    pub fn chord(&self) -> &Self {
+        self
+    }
+}
+
+impl ArrayLike for Chord {
+    type Data = Note;
+
+    fn content(&self) -> &Vec<Self::Data> {
+        &self.0
+    }
+
+    fn mut_content(&mut self) -> &mut Vec<Self::Data> {
+        &mut self.0
+    }
+}
+
+impl IntoIterator for Chord {
+    type Item = Note;
+
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+pub trait ChordFactor {
+    fn factor(&self) -> &ChordFactors
+    where
+        Self: Sized;
+    fn note(&self) -> &Note
+    where
+        Self: Sized;
+}
+
+#[derive(
+    Clone,
+    Debug,
+    Deserialize,
+    Display,
+    EnumString,
+    EnumVariantNames,
+    Eq,
+    Hash,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    Serialize,
+    SmartDefault,
+)]
+#[repr(i64)]
+#[strum(serialize_all = "snake_case")]
+pub enum ChordFactors {
+    #[default]
+    Root(Note) = 0,
+    Third(Note) = 1,
+    Fifth(Note) = 2,
+}
+
+pub type Root = Note;
+pub type Third = Note;
+pub type Fifth = Note;
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_chords() {
+        let a = vec![0.into(), 3.into(), 8.into()];
+        let mut b = Chord::default();
+        assert!(b.is_empty());
+        b.append(&mut a.clone());
+        assert_eq!(b.len(), 3);
+    }
+
+    #[test]
+    fn test_chord_factors() {
+        let a = ChordFactors::default();
+        assert_eq!(a, ChordFactors::Root(Default::default()))
+    }
+}

contained/src/cmp/clef.rs

@@ -0,0 +1,48 @@
+/*
+    Appellation: clef <module>
+    Contrib: FL03 <jo3mccain@icloud.com>
+    Description:
+        A clef, placed on the far left-hand side of the staff or stave, signals which notes are represented by the respective staff.
+*/
+use serde::{Deserialize, Serialize};
+use strum::{Display, EnumString, EnumVariantNames};
+
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    Deserialize,
+    Display,
+    EnumString,
+    EnumVariantNames,
+    Eq,
+    Hash,
+    PartialEq,
+    PartialOrd,
+    Serialize,
+)]
+#[repr(i64)]
+#[strum(serialize_all = "snake_case")]
+pub enum Clef {
+    Alto = 0,
+    Bass = 1,
+    #[default]
+    Treble = 2,
+}
+
+impl From<Clef> for i64 {
+    fn from(data: Clef) -> i64 {
+        data as i64
+    }
+}
+
+impl From<i64> for Clef {
+    fn from(data: i64) -> Clef {
+        match data {
+            0 => Clef::Alto,
+            1 => Clef::Bass,
+            _ => Clef::Treble,
+        }
+    }
+}

contained/src/cmp/epoch.rs

@@ -0,0 +1,25 @@
+/*
+    Appellation: epoch <module>
+    Contrib: FL03 <jo3mccain@icloud.com>
+    Description: ... Summary ...
+*/
+use scsys::prelude::{SerdeDisplay, Timestamp};
+use serde::{Deserialize, Serialize};
+
+/// An [Epoch] consists of a start time and optionally, a duration (seconds). If None, the system assumes an infinite duration
+#[derive(
+    Clone, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, SerdeDisplay, Serialize,
+)]
+pub struct Epoch(i64, Option<i64>);
+
+impl Epoch {
+    pub fn new(ts: i64, duration: Option<i64>) -> Self {
+        Self(ts, duration)
+    }
+}
+
+impl Default for Epoch {
+    fn default() -> Self {
+        Self::new(Timestamp::default().into(), Some(1000))
+    }
+}