1 files changed, 37 insertions, 12 deletions

diff --git a/chain/src/lib.rs b/chain/src/lib.rs
index 0ec4d4c..4e21e1d 100644
--- a/chain/src/lib.rs
+++ b/chain/src/lib.rs
@@ -1,3 +1,4 @@
+#![warn(missing_docs)]
 //! This package implements the core algorithm of the entire
 //! workspace: parsing with derivatives by means of chain rule and
 //! regular nulling languages.
@@ -7,19 +8,43 @@
 //! think is the essence of this algorithm, the chain-rule for
 //! derivatives of languages.
 
-pub mod grammar;
+pub mod atom;
 
-pub fn add(left: usize, right: usize) -> usize {
-    left + right
-}
+// TODO: Define errors.
+
+/// The expected behaviours of a language which can take derivatives
+/// by chain rule.
+pub trait Chain: Default {
+    /// The implementations should choose a type to represent errors.
+    type Error: std::error::Error;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+    /// Represents the language that is present after we parse the
+    /// empty string, that is the initial configuration of the
+    /// language.  This may or may not be different from what
+    /// `Default::default` gives.
+    fn unit() -> Self;
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
+    /// Take the derivative by a terminal symbol.
+    ///
+    /// This takes care of the union and the prepending operations.
+    ///
+    /// # A little remark about the design
+    ///
+    /// I have thought to separate different operations (like the
+    /// union, the prepending, and single derivatives) and then define
+    /// a function to put everything together.  But I think that
+    /// design is not convenient to use.  Also, I really do not need
+    /// those operations other than to provide this derivative
+    /// operation, so why define them?  And putting all things
+    /// together may reduce the number of bugs caused by wrong uses of
+    /// those component functions, and can reduce the amount of
+    /// documentation strings a library user needs to read, in order
+    /// to make use of this trait.  So I ended up with this design.
+    fn chain(&mut self, t: usize);
+
+    /// Return true if and only if the language contains the empty
+    /// string.
+    fn epsilon(&self) -> bool;
 }
+
+pub mod default;