diff --git a/Cookbook/Essential/Common.hs b/Cookbook/Essential/Common.hs
--- a/Cookbook/Essential/Common.hs
+++ b/Cookbook/Essential/Common.hs
@@ -5,7 +5,7 @@
 --informational contexts for modifying/accessing lists. They are placed in this high of a module because
 --of how ubiquitous their use is, even though they fit in with Cookbook.Ingredients.Lists
 
-module Cookbook.Essential.Common(sub,positions,pos,apply,flt,fromLast) where
+module Cookbook.Essential.Common where
 
 -- | Returns a new list starting at a position. List positions start at 0.
 sub :: (Eq a) => [a] -> Int -> [a]
diff --git a/Cookbook/Essential/Continuous.hs b/Cookbook/Essential/Continuous.hs
--- a/Cookbook/Essential/Continuous.hs
+++ b/Cookbook/Essential/Continuous.hs
@@ -2,38 +2,76 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 
 --Cookbook.Essential.Continuous
---Continuous creates a generic overloaded interface to modify lists.
---Making use of generic typeclass constructors, a constraint to the Continuous
---typeclass (and thus, the LANGUAGE Pragmas) is not needed.
-module Cookbook.Essential.Continuous(Continuous(..)) where
+--Continuous is the most important Cookbook library. It defines Overloaded Generic Interfaces
+-- (refered to as OGI's throughout the library) for working on two generic types of data, usually
+--   lists and items.
+module Cookbook.Essential.Continuous where
 
-import qualified Cookbook.Essential.Common as Cm
+import qualified Cookbook.Essential.Common             as Cm
 import qualified Cookbook.Ingredients.Functional.Break as Br
-import qualified Cookbook.Ingredients.Lists.Access as Ac
+import qualified Cookbook.Ingredients.Lists.Access     as Ac
 
--- | Continuous provides an interface for function overloading. Everything automatically qualifies to be a constrained by class continuous, so no anotation is required in any type signatures.
 class Continuous list part where
-  
--- | After returns a sub-list after the first element or first occurence of a larger list.
   after :: list -> part -> list
-  
--- | Before returns a sub-list before either the first occurence of an element or sublist.
   before :: list -> part -> list
-
--- | Remove an item from a list, when used on an element, it works the same as rm.
   delete :: list -> part -> list
 
 instance (Eq a) => Continuous [a] a where
-  after x c     = tail $ Br.removeBreak (/=c) x
-  before x c  = Br.filterBreak (/=c) x
-  delete x c  = filter (/= c) x
+  after x c   = tail $ Br.removeBreak (/=c) x
+  before x c  = Br.filterBreak        (/=c) x
+  delete x c  = filter                (/=c) x
   
 instance (Eq a) => Continuous [a] [a] where
   after [] _ = []
-  after x c = if Ac.isBefore x c then Cm.sub x (length c) else after (tail x) c
+  after x c  = if Ac.isBefore x c then Cm.sub x (length c) else after (tail x) c
 
   before [] _ = []
-  before x c = if Ac.isBefore x c then [] else (head x) : before (tail x) c
+  before x c  = if Ac.isBefore x c then [] else (head x) : before (tail x) c
 
   delete [] _ = []
-  delete x c = if not (x `Ac.contains` c) then x else  (before x c) ++ delete (after x c) c
+  delete x c  = if not (x `Ac.contains` c) then x else  (before x c) ++ delete (after x c) c
+
+-- Spliceable
+class Splicable a b where
+  splice :: a -> b -> a
+
+instance (Eq a) => Splicable [a] (a,a) where
+  splice ls (a,b) = before ls a ++ Cm.fromLast ((flip before) b) ls
+
+instance (Eq a) => Splicable [a] ([a],[a]) where
+  splice ls (a,b)  = before ls a ++ after (after ls a) b
+
+-- Replacable
+class Replacable list repls where
+  replace  :: list -> repls -> list
+  
+instance (Eq a) => Replacable [a] (a,a) where
+  replace lst (on,tw) = map (\c -> if c == on then tw else c) lst
+  
+instance (Eq a) => Replacable [a] [(a,a)] where
+  replace x c = Cm.apply (map (flip replace) c) x
+  
+instance (Eq a) => Replacable [a] ([a],[a]) where
+  replace [] _ = []
+  replace lst (on,tw) 
+    | (take (length on) lst) == on = tw ++ replace (Cm.sub lst (length on)) (on,tw)
+    | otherwise = (head lst) : replace (tail lst) (on,tw)
+
+instance (Eq a) => Replacable [a] [([a],[a])] where
+  replace x c = Cm.apply (map (flip replace) c) x
+
+-- Removable
+class Removable list toRm where
+  remove :: list -> toRm -> list
+
+instance (Eq a) => Removable [a] a where
+  remove x c = [y | y <- x, y /= c]
+
+instance (Eq a) => Removable [a] [a] where
+  remove [] _       = []
+  remove x@(a:b) c  = if take (length c) x == c then remove (restart x) c else a : remove b c
+    where restart d = Cm.sub d (length c)
+
+instance (Eq a) => Removable [a] (a,a) where
+  remove [] _ = []
+  remove (x:xs) (a,b) = if and [x == a, b `elem` xs] then remove (tail (Br.removeBreak (/=b) xs)) (a,b) else x : remove xs (a,b)
diff --git a/Cookbook/Essential/IO.hs b/Cookbook/Essential/IO.hs
--- a/Cookbook/Essential/IO.hs
+++ b/Cookbook/Essential/IO.hs
@@ -1,23 +1,22 @@
 --Cookbook.Essential.IO
 --IO is the only Cookbook library to import System modules. As the name states, Cookbook.IO makes IO
 --easier and less error-prone by wrapping common IO "gotchas" in a function.
-module Cookbook.Essential.IO(filelines,prompt,inhome,getHomePath,filename,modulename) where
+module Cookbook.Essential.IO where
 
-import qualified System.IO as LIO
-import  qualified System.IO.Strict as SIO
-import qualified Cookbook.Essential.Continuous as Ct
+import qualified System.IO                         as LIO
+import qualified System.IO.Strict                  as SIO
+import qualified Cookbook.Essential.Continuous     as Ct
 import qualified Cookbook.Ingredients.Lists.Modify as Md
-import System.Environment
+
+import System.Environment       
 import System.Directory
 
--- | Returns the lines of a file, wrapped in an IO.
 filelines :: String -> IO ([String])
 filelines x = do
   y <- LIO.openFile x LIO.ReadMode
   yc <- SIO.hGetContents y
   return (lines yc)
 
--- | Prompts the user for a string
 prompt :: String -> IO (String)
 prompt x = do
     putStr x
diff --git a/Cookbook/Ingredients/Functional/Break.hs b/Cookbook/Ingredients/Functional/Break.hs
--- a/Cookbook/Ingredients/Functional/Break.hs
+++ b/Cookbook/Ingredients/Functional/Break.hs
@@ -4,26 +4,21 @@
 --untrue value. As an addition to this library are functions relating to
 --mapping predicates over lists to yield either a different result or one solution.
 
-module Cookbook.Ingredients.Functional.Break(removeBreak, filterBreak,btr,imbreak,splitBool) where
+module Cookbook.Ingredients.Functional.Break where
 
--- | When the predicate returns false, removeBreak returns the rest of the list.
 removeBreak :: (a -> Bool) -> [a] -> [a]
 removeBreak _ [] = []
 removeBreak f (c:cs) = if not $ f c then (c:cs) else removeBreak f cs
 
--- | When the predicate returns false, filterBreak will stop collecting the list.
 filterBreak :: (a -> Bool) -> [a] -> [a]
 filterBreak _ [] = []
 filterBreak f (c:cs) = if not $ f c then [] else c : filterBreak f cs
 
--- | imbreak will return true if any of the members of the list satisfy the predicate.
 imbreak :: (a -> Bool) -> [a] -> Bool
 imbreak f = or . map f
 
--- | Conditionally transform input based on the predicate. When it is true, fst of the tupple is used, snd otherwise.
 btr :: (a -> Bool) -> (b,b) -> [a] -> [b]
 btr f (a,b) = map (\c -> if f c then a else b)
-
 
 splitBool :: (Eq a) => (a -> Bool) -> [a] -> [[a]]
 splitBool _ [] = []
diff --git a/Cookbook/Ingredients/Lists/Access.hs b/Cookbook/Ingredients/Lists/Access.hs
--- a/Cookbook/Ingredients/Lists/Access.hs
+++ b/Cookbook/Ingredients/Lists/Access.hs
@@ -1,43 +1,37 @@
 --Cookbook.Ingredients.Lists.Access
 --Access is a library for generating statistics about a list. The lists are not changed as a result
 --of executing any Access function.
-module Cookbook.Ingredients.Lists.Access(count,contains,qsort,pull,refpos,areAll,isBefore,surrounds) where
 
-import qualified Cookbook.Ingredients.Functional.Break as Br
+module Cookbook.Ingredients.Lists.Access where
 
-import qualified Cookbook.Essential.Common as Cm
+import qualified Cookbook.Ingredients.Functional.Break as Br
+import qualified Cookbook.Ingredients.Tupples.Assemble as As
+import qualified Cookbook.Essential.Common             as Cm
 
--- | Counts the number of occurrences within a list.
 count :: (Eq a) => [a] -> a -> Int
 count x c = sum $ Br.btr (==c)  (1,0) x
 
--- | Checks to see if a greater list has a list within it.
 contains :: (Eq a) => [a] -> [a] -> Bool
 contains [] _ = False
 contains x c = if part x == c then True else contains (tail x) c
   where part = take (length c)
 
--- | Sorts a list from least to greatest. Compose with Cookbook.Ingredients.Lists.Modify.rev for greatest-to-least.
 qsort :: (Ord a) => [a] -> [a]
 qsort [] = []
 qsort (x:xs) = lessT ++ [x] ++ greatT
   where  (lessT,greatT)  = (qsort $ filter (<=x) xs,qsort $filter (>x) xs)
 
--- | Safer way than (!! (Prelude)) to get items out of a list. Returns nothing on failure.
 pull :: [a] -> Int -> Maybe a
 pull _ c | c < 0 = Nothing
 pull [] _  = Nothing
 pull (x:xs) c = if c == 0 then (Just x) else pull xs (c - 1)
 
--- | Reference an element from one list to another.
 refpos :: (Eq a) => ([a],[a]) -> a -> a
 refpos (a,b) c = let d = (pull b (Cm.pos a c)) in case d of (Just x) -> x;(Nothing) -> c
 
--- | Are all elements of the list equal?
 areAll :: (Eq a) => [a] -> a -> Bool
 areAll x c = not $ Br.imbreak (/=c) x
 
--- | Is the list a prefix of another?
 isBefore :: (Eq a) => [a] -> [a] -> Bool
 isBefore li tf = take (length tf) li == tf
 
diff --git a/Cookbook/Ingredients/Lists/Modify.hs b/Cookbook/Ingredients/Lists/Modify.hs
--- a/Cookbook/Ingredients/Lists/Modify.hs
+++ b/Cookbook/Ingredients/Lists/Modify.hs
@@ -1,50 +1,40 @@
 --Cookbook.Ingredients.Lists.Modify
 --Library for altering the contents of a list.
 
-module Cookbook.Ingredients.Lists.Modify(rev,rm,splitOn,snipe,insert,between,linesBetween,surroundedBy) where
-
-import qualified Cookbook.Essential.Continuous as Cnt
-import qualified Cookbook.Essential.Common as Cm
+module Cookbook.Ingredients.Lists.Modify where
 
+import qualified Cookbook.Essential.Continuous         as Cnt
+import qualified Cookbook.Essential.Common             as Cm
 import qualified Cookbook.Ingredients.Functional.Break as Br
-import qualified Cookbook.Ingredients.Lists.Access as Ac
+import qualified Cookbook.Ingredients.Lists.Access     as Ac
 
--- | Reverses a list
 rev :: [a] -> [a]
 rev [] = []
 rev (x:xs) = rev xs ++ [x]
 
--- | Removes all occurences from a list.
-rm :: (Eq a) => [a] -> a -> [a]
+rm :: (Eq a) => [a] -> a -> [a] -- See MDN1
 rm x c = filter (/=c) x
 
--- | Create sub-lists based on a delimeter. The string 'joe,joe1,joe2' splitOn ',' would return a list of the three joes.
 splitOn :: (Eq a) => [a] -> a -> [[a]]
 splitOn [] _ = []
 splitOn x c = if (c `notElem` x) then [x] else (Cnt.before x c) : splitOn (Cnt.after x c) c
 
--- | Change a location in a list with an element.
 snipe :: (Eq a) => [a] -> (a,Int) -> [a]
 snipe x (t,c) = (take c x) ++ [t] ++ (Cm.sub x (c + 1))
 
--- | Snipe, workable with lists and does not delete information.
 insert :: (Eq a) => [a] -> ([a],Int) -> [a]
 insert x (t,c) = (take c x) ++ t ++ (Cm.sub x c)
 
--- | Find out what is in between two elements of a list
 between :: (Eq a) => [a] -> (a,a) -> [a]
 between a (c,d) = Cnt.after (take (last $ Cm.positions a d) a) c
 
--- | Selectively parse a list based on the existance of a substring.
 linesBetween :: (Eq a) => [[a]] -> ([a],[a]) -> [[a]]
 linesBetween a (c,d) = tail $ Br.filterBreak (\e -> not $ Ac.contains e d) $ Br.removeBreak (\e -> not $ Ac.contains e c) a
 
--- | Intersperse elements into a list.
 intersperse :: [a] -> a -> [a]
 intersperse [x] _ = [x]
 intersperse (x:xs) c =  x:c : intersperse xs c
 
--- | Perform a function on the last element of a list.
 onLast :: (a -> a) -> [a] -> [a]
 onLast _ []     = []
 onLast f [x]    = f x : []
@@ -57,3 +47,7 @@
 surroundedBy :: (Eq a) => [a] -> (a,a) -> [[a]] -- Map checks if a or b are not elememts.
 surroundedBy x (a,b) = if or (map (not . (flip elem) x) [a,b]) then [] else recurse
   where recurse = Cnt.before (Cnt.after x a) b : surroundedBy (Cnt.after x b) (a,b)
+
+-- [MDN1]
+-- This is implemented in Continuous, but is kept here for historical purposes,
+--    or for when Continuous is too heavy-duty for whatever job you are on.
diff --git a/Cookbook/Ingredients/Lists/Remove.hs b/Cookbook/Ingredients/Lists/Remove.hs
deleted file mode 100644
--- a/Cookbook/Ingredients/Lists/Remove.hs
+++ /dev/null
@@ -1,26 +0,0 @@
---Cookbook.Ingredients.Lists.Remove
---Remove is an OGI for removing parts of lists.
-
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FlexibleInstances #-}
-module Cookbook.Ingredients.Lists.Remove(Removable(..)) where
-
-import Cookbook.Essential.Common             as Cm
-import Cookbook.Ingredients.Functional.Break as Br
-import Cookbook.Ingredients.Lists.Modify     as Md
-
-class Removable list toRm where
-
-  remove :: list -> toRm -> list
-
-instance (Eq a) => Removable [a] a where
-  remove x c = [y | y <- x, y /= c]
-
-instance (Eq a) => Removable [a] [a] where
-  remove [] _ = []
-  remove x@(a:b) c = if take (length c) x == c then remove (restart x) c else a : remove b c
-    where restart d = Cm.sub d (length c)
-
-instance (Eq a) => Removable [a] (a,a) where
-  remove [] _ = []
-  remove (x:xs) (a,b) = if and [x == a, b `elem` xs] then remove (tail (Br.removeBreak (/=b) xs)) (a,b) else x : remove xs (a,b)
diff --git a/Cookbook/Ingredients/Lists/Replace.hs b/Cookbook/Ingredients/Lists/Replace.hs
deleted file mode 100644
--- a/Cookbook/Ingredients/Lists/Replace.hs
+++ /dev/null
@@ -1,31 +0,0 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-
---Cookbook.Ingredients.Lists.Replace
---Replace, much alike Cookbook.Essential.Continuous, is a generic overloaded typeclass for replacing parts of lists.
---It is overloaded to work with a list and elements, a list and a list of elements, and a list and a list of elements which are lists, and a lists of a lists of elements which are lists.
-
-module Cookbook.Ingredients.Lists.Replace(Replacable(..)) where
-import qualified Cookbook.Essential.Common as Cm
-
--- | Provides a generic interface to replacable lists.
-class Replacable list repls where
-
--- | Transforms lists of any type.
-  replace  :: list -> repls -> list
-  
-instance (Eq a) => Replacable [a] (a,a) where
-  replace lst (on,tw) = map (\c -> if c == on then tw else c) lst
-  
-instance (Eq a) => Replacable [a] [(a,a)] where
-  replace x c = Cm.apply (map (flip replace) c) x
-  
-instance (Eq a) => Replacable [a] ([a],[a]) where
-  replace [] _ = []
-  replace lst (on,tw) 
-    | (take (length on) lst) == on = tw ++ replace (Cm.sub lst (length on)) (on,tw)
-    | otherwise = (head lst) : replace (tail lst) (on,tw)
-
-instance (Eq a) => Replacable [a] [([a],[a])] where
-  replace x c = Cm.apply (map (flip replace) c) x
-
diff --git a/Cookbook/Ingredients/Lists/Splice.hs b/Cookbook/Ingredients/Lists/Splice.hs
deleted file mode 100644
--- a/Cookbook/Ingredients/Lists/Splice.hs
+++ /dev/null
@@ -1,14 +0,0 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-module Cookbook.Ingredients.Lists.Splice(Splicable(..)) where
-import qualified Cookbook.Essential.Continuous as Ct
-import qualified Cookbook.Essential.Common     as Cm
-
-class Splicable a b where
-  splice :: a -> b -> a
-
-instance (Eq a) => Splicable [a] (a,a) where
-  splice ls (a,b) = Ct.before ls a ++ Cm.fromLast ((flip Ct.before) b) ls
-
-instance (Eq a) => Splicable [a] ([a],[a]) where
-  splice ls (a,b)  = Ct.before ls a ++ Ct.after (Ct.after ls a) b
diff --git a/Cookbook/Ingredients/Lists/Stats.hs b/Cookbook/Ingredients/Lists/Stats.hs
--- a/Cookbook/Ingredients/Lists/Stats.hs
+++ b/Cookbook/Ingredients/Lists/Stats.hs
@@ -1,15 +1,12 @@
-module Cookbook.Ingredients.Lists.Stats(frequency,mostFrequent) where
+module Cookbook.Ingredients.Lists.Stats where
 
+import qualified Cookbook.Ingredients.Lists.Access     as Ac
+import qualified Cookbook.Ingredients.Lists.Modify     as Md
 import qualified Cookbook.Ingredients.Tupples.Assemble as As
-import qualified Cookbook.Ingredients.Lists.Access as Ac
-import qualified Cookbook.Ingredients.Lists.Modify as Md
-import qualified Cookbook.Recipes.Sanitize as Sn
+import qualified Cookbook.Recipes.Sanitize              as Sn
 
--- | Return a list of all elements of the list with its frequency.
 frequency :: (Eq a) => [a] -> [(a,Int)] 
 frequency x = let y = map (\c -> (c,Ac.count x c)) x in Sn.rmdbAll y
 
--- | Get the x amount of most frequent items in the list.
 mostFrequent :: (Eq a) => [a] -> Int -> [a]
 mostFrequent x c = take c $ Md.rev (As.assemble  $ frequency x)
-
diff --git a/Cookbook/Project/Configuration/Configuration.hs b/Cookbook/Project/Configuration/Configuration.hs
--- a/Cookbook/Project/Configuration/Configuration.hs
+++ b/Cookbook/Project/Configuration/Configuration.hs
@@ -1,6 +1,6 @@
 --Cookbook.Project.Configuration.Configuration (Cf)
 -- Cf is a library for reading very simple configuration files.
-module Cookbook.Project.Configuration.Configuration(conf) where
+module Cookbook.Project.Configuration.Configuration where
 import qualified Cookbook.Ingredients.Lists.Modify as Md
 import qualified Cookbook.Ingredients.Tupples.Look as Lk
 
diff --git a/Cookbook/Project/Context/Context.hs b/Cookbook/Project/Context/Context.hs
deleted file mode 100644
--- a/Cookbook/Project/Context/Context.hs
+++ /dev/null
@@ -1,33 +0,0 @@
-module Cookbook.Project.Context.Context(parseContexts,skim) where
-
-import qualified Cookbook.Ingredients.Lists.Modify     as Md
-import qualified Cookbook.Ingredients.Lists.Access     as Ac
-import qualified Cookbook.Ingredients.Functional.Break as Br
-import qualified Cookbook.Ingredients.Tupples.Look     as Lk
-import qualified Cookbook.Ingredients.Lists.Replace    as Rp
-
-import qualified Cookbook.Essential.IO                 as CIO
-
-import System.Directory
-
--- Binary search capabilities
-skim :: FilePath -> IO [(String,FilePath)]
-skim x =
-  do
-    allFiles <- getDirectoryContents x
-    return $ zip (allFiles) (map ((x++"/")++) allFiles)
-
---Helper functions
-isGlobalCall x = and [x `Ac.contains` "{=",x `Ac.contains` "=}"]
-getGlobalName x = Md.between x ('=','=')
-
--- Parsing
-parseContexts :: [(String,String)] -> [String] -> [String] -- Returns a list of shell commands
-parseContexts _ [] = []
-parseContexts cmdList (line:lines)
-  | isGlobalCall line = parseGlobal cmdList line (Br.filterBreak notEnd lines) : parseContexts cmdList (Br.removeBreak notEnd lines)
-  | otherwise = parseContexts cmdList lines
-  where notEnd = (\c -> not (c `Ac.contains` ("{"++getGlobalName line++"}")))
-
-parseGlobal :: [(String,String)] -> String -> [String] -> String
-parseGlobal cmdList header lines = (head $ Lk.lookList cmdList (getGlobalName header)) ++ " " ++ Rp.replace (unlines lines) ('\n',' ')
diff --git a/Cookbook/Project/Groups/Groups.hs b/Cookbook/Project/Groups/Groups.hs
deleted file mode 100644
--- a/Cookbook/Project/Groups/Groups.hs
+++ /dev/null
@@ -1,21 +0,0 @@
---Groups is a very small markup language with an inflexible syntax.
---Groups have data constructors and implementations.
---An example of a groups file can be found in the Examples directory of this repo
-module Cookbook.Project.Groups.Groups(Constructor,construct,implement) where
-
-import qualified Cookbook.Ingredients.Lists.Modify as Md
-import qualified Cookbook.Ingredients.Tupples.Look as Lk
-import qualified Cookbook.Essential.Continuous     as Ct
-
-type Constructor = (String,[String])
-
---Example: phone:number,name
--- | Construct a data constructor. Delmits using '_'
-construct :: String -> Constructor
-construct x = ((Ct.before x ':'),(Md.splitOn (Ct.after x ':') '_'))
-
---Example: phone:123-456-7899,Joe
--- | Using a list of constructors, implements an instantiation.
-implement :: String -> [Constructor] -> [(String,String)]
-implement x c = zip typ (Md.splitOn (Ct.after x ':') ',')
-  where typ = case Lk.look c (Ct.before x ':') of (Just e) -> e;  _ -> error "Type undefined."
diff --git a/Cookbook/Project/Preprocess/Preprocess.hs b/Cookbook/Project/Preprocess/Preprocess.hs
--- a/Cookbook/Project/Preprocess/Preprocess.hs
+++ b/Cookbook/Project/Preprocess/Preprocess.hs
@@ -1,21 +1,19 @@
 --Cookbook.Project.Preprocess.Preprocess
 --A library for implementing preprocess syntax, as defined in the .std
 
-module Cookbook.Project.Preprocess.Preprocess(makeParams,gPL) where
+module Cookbook.Project.Preprocess.Preprocess where
 
-import qualified Cookbook.Ingredients.Lists.Replace as Rp
 import qualified Cookbook.Ingredients.Lists.Modify  as Md
-import qualified Cookbook.Ingredients.Lists.Remove  as Rm
-
-import qualified Cookbook.Essential.Common as Cm
+import qualified Cookbook.Essential.Common          as Cm
+import qualified Cookbook.Essential.Continuous      as Ct
 
 makeParams :: String -> [(String,String)]
 makeParams x = (flip zip) (repeat lastPart) $ Md.splitOn firstPart '|'
   where (firstPart:lastPart:[]) = Md.splitOn x '_'
 
 sanitize :: String -> String
-sanitize x = Rm.remove x ('$','$')
+sanitize x = Ct.remove x ('$','$')
 
 gPL :: [String] -> [(String,String)]
 gPL x = Cm.flt $ map makeParams sanitized
-  where sanitized = Rm.remove (map (\c -> if (length c) > 3 then (sanitize c) else "") x) ""
+  where sanitized = Ct.remove (map (\c -> if (length c) > 3 then (sanitize c) else "") x) ""
diff --git a/Cookbook/Project/Quill/Quill.hs b/Cookbook/Project/Quill/Quill.hs
--- a/Cookbook/Project/Quill/Quill.hs
+++ b/Cookbook/Project/Quill/Quill.hs
@@ -1,10 +1,9 @@
-module Cookbook.Project.Quill.Quill(tblNames,tables,getTable,lookUp,createTable,removeTable,removeItem,addItem,tableToString,changeItem) where
+module Cookbook.Project.Quill.Quill where 
+
 import qualified Cookbook.Essential.Common         as Cm
 import qualified Cookbook.Essential.Continuous     as Ct
-import qualified Cookbook.Ingredients.Lists.Remove as Rm
 import qualified Cookbook.Ingredients.Lists.Modify as Md
 import qualified Cookbook.Ingredients.Lists.Access as Ac
-import qualified Cookbook.Ingredients.Lists.Splice as Sp
 import qualified Cookbook.Ingredients.Tupples.Look as Lk
 import qualified Cookbook.Recipes.Sanitize         as Sn
 
@@ -13,7 +12,7 @@
 
 -- Parsing
 prepare :: [String] -> String
-prepare = ((flip Sp.splice) ("(*","*)")) . ((flip Sn.blacklist) [' ','\n']) . Cm.flt
+prepare = ((flip Ct.splice) ("(*","*)")) . ((flip Sn.blacklist) ['\n']) . Cm.flt
 
 tokenize :: [a] -> [(a,a)]
 tokenize []  = []
@@ -22,15 +21,13 @@
 
 -- Table access
 tblNames :: String -> [String]
-tblNames x = (Ct.before x '{') : Md.surroundedBy x ('}','{')
-
+tblNames x = (Ct.before x '{') : (tail $ Md.surroundedBy (Sn.blacklist x [' '])  ('}','{'))
 
 headlessData :: String -> [[String]]
 headlessData x = map ((flip Md.splitOn) ';') $  (Md.surroundedBy x ('{','}'))
 
 tokenLists :: [[String]] -> [[(String,String)]]
-tokenLists x =  map tokenize $ map Cm.flt ( map (map ((flip Md.splitOn) ':')) x)
-
+tokenLists x =  ( map (map (\c -> (Ct.before c ':',Ct.after c ':'))) x)
 
 -- API functions
 tables :: [String] -> [(String,[(String,String)])]
@@ -65,5 +62,3 @@
 tableToString :: (String,[(String,String)]) -> String
 tableToString (x,b) = x ++ "{" ++ (Cm.flt (map detokenize b)) ++ "}"
   where detokenize (a,b) = a ++ ":" ++ b ++ ";"
-
-
diff --git a/Cookbook/Project/Scribe/Scribe.hs b/Cookbook/Project/Scribe/Scribe.hs
deleted file mode 100644
--- a/Cookbook/Project/Scribe/Scribe.hs
+++ /dev/null
@@ -1,105 +0,0 @@
---Cookbook.Project.Scribe
---Scribe is a tool for communicating with SCRIBE databases.
-module Cookbook.Project.Scribe.Scribe(
-  Frame(..),Column,Row,Table,Database,
-  isRow,isColumn,isFrame,isTable,
-  makeName,
-  parseFrame,parseColumn,parseRow,parseTable,
-  readColumn,readRow,readTable,readDatabase,
-  getTable,getRow,getColumn,getFrame,
-  qGetRow,qGetColumn,qGetFrame) where
-
-import qualified Cookbook.Essential.Common             as Cm
-import qualified Cookbook.Essential.Continuous         as Ct
-import qualified Cookbook.Ingredients.Lists.Modify     as Md
-import qualified Cookbook.Ingredients.Lists.Access     as Ac
-import qualified Cookbook.Ingredients.Tupples.Look     as Lk
-import qualified Cookbook.Ingredients.Functional.Break as Br
-import qualified Cookbook.Recipes.Sanitize             as St
-
---Data
-data Frame = Frame {keyval :: String, entry :: String} | Promise {keyval :: String, link :: String}  deriving (Eq,Show)
-
---Type synonyms
-type Column = (String,[Frame])
-type Row = (String,[Column])
-type Table = (String,[Row])
-type Database = [Table]
-
---Standard information
-isRow     x = and [x `Ac.contains` "row",    length x > 4]
-isColumn  x = and [x `Ac.contains` "column", length x > 4]
-isFrame   x = and $ map ((flip elem) x) "<>"
-isTable   x = and [x `Ac.contains` "table",length x > 4]
-
-makeName :: String -> String -> String
-makeName a b = St.blacklist (Ct.after a b) "{ "
-
---Parsing
-parseFrame :: String -> Frame
-parseFrame x | not $ isFrame x = error (x ++ " was passed to parseFrame, but does not conform to standard.")
-parseFrame x
-  | ('-','-') `Ac.surrounds` inner = Promise {keyval = Md.between inner ('-','-'), link = Ct.after x '>'}
-  | otherwise = Frame {keyval = inner, entry = Ct.after x '>'} -- Surrounded in <-->? It's a link.
-  where inner = Md.between x ('<','>')
-
-parseColumn :: (String,[String]) -> Column -- Expects the column declaration, and the relevant lines.
-parseColumn (a,b) = (makeName a "column ",map parseFrame b)
-
-parseRow :: (String,[(String,[String])]) -> Row
-parseRow (a,b) = (makeName a "row ",map parseColumn b)
-
-parseTable :: (String,[(String,[(String,[String])])]) -> Table
-parseTable (a,b) = (makeName a "table ",map parseRow b)
-
---Reading
-readColumn :: [String] -> (String,[String])
-readColumn [] = error "Column either does not exist or does not conform to standards."
-readColumn (x:xs) | not  $ isColumn x = readColumn xs
-readColumn (x:xs) = (x,Md.linesBetween (x:xs) ("{","}"))
-
-readRow :: [String] -> (String,[(String,[String])])
-readRow [] = error "Row either does not exist or does not conform to standards."
-readRow (x:xs) | not $ isRow x = readRow xs
-readRow (x:xs) = (x, map readColumn splitup)
-  where splitup = Br.splitBool (\c -> not $ c `Ac.contains` "}") rowScope
-        rowScope = Md.linesBetween (x:xs) ("{","}}")
-
-readTable :: [String] -> (String,[(String,[(String,[String])])])
-readTable [] = error "Table either does not exist or does not conform to standards."
-readTable (x:xs) | not $ isTable x = readTable xs
-readTable (x:xs) = (x,map readRow splitup)
-  where splitup = Br.splitBool (\c -> not $ c `Ac.contains` "}}") tableScope;
-        tableScope = Md.linesBetween (x:xs) ("{","}}}")
-
---Final functions
-readDatabase :: [String] -> Database
-readDatabase (x:xs)
-  | isTable x = parseTable (readTable (x:xs)) : readDatabase (Ct.after xs "}}}")
-  | otherwise = readDatabase xs
-
---Accessors
-getTable :: String -> Database -> Table
-getTable a b = (a,(head $ Lk.lookList b a))
-
-getRow :: (String,String) -> Database -> Row
-getRow (a,b) c = (b,head $ Lk.lookList (snd (getTable a c)) b)
-
-getColumn :: (String,String,String) -> Database -> Column
-getColumn (a,b,c) d = (c,head $ Lk.lookList (snd (getRow (a,b) d)) c)
-
-getFrame :: (String,String,String,String) -> Database -> Frame
-getFrame (a,b,c,d) e = let frames = (snd $ getColumn (a,b,c) e) in head $ Lk.lookList (zip (map keyval frames) frames) d
-
---Shorthand accessors
-qGetRow :: String -> Database -> Row
-qGetRow x z= getRow (a,b) z
-  where (a,b) = let (f:g:[]) = Md.splitOn x '.' in (f,g)
-
-qGetColumn :: String -> Database -> Column
-qGetColumn x z = getColumn (a,b,c) z
-  where (a,b,c) = let (f:g:h:[]) = Md.splitOn x '.' in (f,g,h)
-
-qGetFrame :: String -> Database -> Frame
-qGetFrame x z = getFrame (a,b,c,d) z
-  where (a,b,c,d) = let (f:g:h:j:[]) = Md.splitOn x '.' in (f,g,h,j)
diff --git a/Cookbook/Recipes/Algorithm.hs b/Cookbook/Recipes/Algorithm.hs
--- a/Cookbook/Recipes/Algorithm.hs
+++ b/Cookbook/Recipes/Algorithm.hs
@@ -1,29 +1,25 @@
 --Cookbook.Recipes.Algorithm
 --Used for traversing data structures.
-module Cookbook.Recipes.Algorithm(climb,genMatrix) where
+module Cookbook.Recipes.Algorithm where
 
 import Cookbook.Recipes.DataStructures
 import Cookbook.Ingredients.Lists.Modify
 
--- | Gets all the nodes in a binary tree, putting them in a list.
 climb :: (Tree a) -> [a]
 climb x = case x of (Empty) -> [];(Branch a (Empty) b) -> a : climb b;
                     (Branch a b (Empty)) -> a : climb b;
                     (Branch a b d) -> a : climb b ++ climb d 
 
--- | Provides map-like behavior for binary trees.
 treeMap :: (Tree a) -> (a -> a) -> (Tree a)
 treeMap tr f = case tr of Empty -> Empty;
                           (Branch a (Empty) z@(Branch c _ _)) -> (Branch (f c) (treeMap z f) (Empty));
                           (Branch a z@(Branch b _ _) (Empty)) -> (Branch (f b) (Empty) (treeMap z f))
 
--- | Provides filter-like behavior for binary trees.
 treeFilter :: (Tree a) -> (a -> Bool) -> (Tree a)
 treeFilter Empty f = Empty
 treeFilter (Branch a (Empty) z@(Branch b _ _)) f = if (f a) then (Branch a (Empty) (treeFilter z f)) else Empty
 treeFilter (Branch a z@(Branch b _ _) (Empty)) f = if (f a) then (Branch a (treeFilter z f) (Empty)) else Empty
 
--- | Generates a matrix (coord1,coord2,a) with the specified data to null it out.
 genMatrix :: (Int,Int) -> a -> [((Int,Int),a)]
 genMatrix (a,b) c = helper (0,0)
   where helper (d,e)
diff --git a/Cookbook/Recipes/DataStructures.hs b/Cookbook/Recipes/DataStructures.hs
--- a/Cookbook/Recipes/DataStructures.hs
+++ b/Cookbook/Recipes/DataStructures.hs
@@ -1,8 +1,7 @@
 --Cookbook.Recipes.DataStructures
 --Higher-level data structures for use in the rest of Cookbook.
-module Cookbook.Recipes.DataStructures(Tree(..),) where
+module Cookbook.Recipes.DataStructures where
 
--- | Cookie-cutter implementation of a binary tree.
 data Tree a = Empty | Branch a (Tree a) (Tree a) deriving (Show)--add a "map" and "filter" function for Tree.
 
 
diff --git a/Cookbook/Recipes/Detect.hs b/Cookbook/Recipes/Detect.hs
deleted file mode 100644
--- a/Cookbook/Recipes/Detect.hs
+++ /dev/null
@@ -1,38 +0,0 @@
---Cookbook.Recipes.Detect
---Detect is a regex-like library with a defined standard, but in Recipes because it uses generic functions to implement them.
-
-module Cookbook.Recipes.Detect(represent,toRepex,strpex,strmatch,containingPattern,withPattern) where
-
-import Data.Maybe
-
-import qualified Cookbook.Ingredients.Lists.Access as Ac
-
--- | Represent a list using symbols, and if it's not found, return Nothing.
-represent :: (Eq a) => [([a],b)] -> a -> (Maybe b)
-represent [] _ = Nothing
-represent ((a,b):c) item = if item `elem` a then (Just b) else represent c item
-
--- | Filter maybes out, replacing Nothings with a failsafe "catch-all"
-toRepex :: (Eq a) => [([a],b)] -> [a] -> b-> [b]
-toRepex a b failsafe= map (\c -> case c of (Just x) -> x;_ -> failsafe) (map (represent a) b)
-
---Standardized functions
-
--- | Standard interface to "toRepex" for strings.
-strpex :: String -> String
-strpex x = toRepex [(['a'..'z'],'@'),(['A'..'Z'],'!'),(['0'..'9'],'#'),([':'..'@']++['\\'..'`']++[' '..'/'],'&')] x '_'
-
--- | Does the string contain the standard strpex pattern?
-strmatch :: String -> String -> Bool
-strmatch x c = (strpex x) `Ac.contains` c
-
--- | All lines containing this pattern
-containingPattern :: [String] -> String -> [String]
-containingPattern x c = filter (flip strmatch c) x
-
--- | All patterns matching the pattern
-withPattern :: [String] -> String -> [String]
-withPattern [] _ = []
-withPattern a@(x:xs) c = if  strpex takeX == c then takeX : withPattern xs c else withPattern xs c
-  where takeX = (take (length c) x)
-
diff --git a/Cookbook/Recipes/DiffStat.hs b/Cookbook/Recipes/DiffStat.hs
deleted file mode 100644
--- a/Cookbook/Recipes/DiffStat.hs
+++ /dev/null
@@ -1,16 +0,0 @@
---Cookbook.Recipes.Diffstat
---A library for logging the movements of elements from one equally sized list to another, and patching others.
-module Cookbook.Recipes.DiffStat(diff,patch) where
-
-import qualified Cookbook.Essential.Common as  Cm
-import qualified Cookbook.Ingredients.Tupples.Assemble as As
-
--- | Returns the transpositions each element of a list made.
-diff :: (Eq a) => [a] -> [a] -> [Int]
-diff  a b = map (\(c,d) -> d-c) difflists
-  where difflists = zip [0..(length a)]  (map ( Cm.pos b) a) -- (orignal,new) positions
-
--- | Makes a list out of a difflist
-patch :: (Eq a) => [a] -> [Int] -> [a]
-patch x c = As.assemble $  zip x (map (\(d,e) -> d+e) ( zip c [0..(length x)]))
---Diff returns a relative list. patch has to add the index number of the list to the list to be meaningful in As.assemble
diff --git a/Cookbook/Recipes/Math.hs b/Cookbook/Recipes/Math.hs
--- a/Cookbook/Recipes/Math.hs
+++ b/Cookbook/Recipes/Math.hs
@@ -1,6 +1,6 @@
 --Cookbook.Recipes.Math
 --A library for mathematical formulas, parsing, and conversions.
-module Cookbook.Recipes.Math(inc,dec,sqr,avg,stdev,fact) where
+module Cookbook.Recipes.Math where
 
 --Simple, helper arithmetic functions.
 inc :: (Num a) => a -> a
diff --git a/Cookbook/Recipes/Sanitize.hs b/Cookbook/Recipes/Sanitize.hs
--- a/Cookbook/Recipes/Sanitize.hs
+++ b/Cookbook/Recipes/Sanitize.hs
@@ -1,57 +1,42 @@
-module Cookbook.Recipes.Sanitize(blacklist,rmleading,up,down,rmdb,rmdbAll,tolower,toupper,rmlws,rmsymbols) where
+module Cookbook.Recipes.Sanitize where
 --"Sanization" is quite the overloaded term. The purpose of this sanitzation lib
 --is to be as unobtrusive yet flexible as possible. This will generally work with
 --strings, so some domain-specific solutions for strings are present in this lib
-import qualified Cookbook.Essential.Common as Cm
-import qualified Cookbook.Ingredients.Lists.Modify as Md
-import qualified Cookbook.Ingredients.Lists.Access as Ac
-import qualified Cookbook.Ingredients.Functional.Break as Br
 
---Generic Underpinnings
+import qualified Cookbook.Essential.Common             as Cm
+import qualified Cookbook.Ingredients.Lists.Modify     as Md
+import qualified Cookbook.Ingredients.Lists.Access     as Ac
+import qualified Cookbook.Ingredients.Functional.Break as Br
 
--- | Remove each element of the second list from the first.
 blacklist :: (Eq a) => [a] -> [a] -> [a]
 blacklist x c = Cm.apply (map (flip Md.rm) c) x
 
--- | Remove leading elements from the list. Useful for getting rid of spaces.
 rmleading :: (Eq a) => [a] -> a -> [a]
 rmleading x c = Br.filterBreak (==c) x
 
--- | Move an element in one list to the other, if it is not there already.
 up :: (Eq a) => ([a],[a]) -> [a] -> [a]
 up (a,b) c = map (Ac.refpos (a,b)) c
 
--- | Up, but down. If that helps.
 down :: (Eq a) => ([a],[a]) -> [a] -> [a]
 down (a,b) c = map (Ac.refpos (b,a)) c
 
--- | Remove all adjacent doubles from the list.
 rmdb :: (Eq a) => [a] -> [a]
 rmdb [] = []
 rmdb [x] = [x]
 rmdb (x:y:zs) = if x == y then x: rmdb (Br.removeBreak (== x) (y:zs)) else x : rmdb (y:zs)
 
--- | Removes absolutely all doubles, leaving the first copy.
 rmdbAll :: (Eq a) => [a] -> [a]
 rmdbAll [] = []
 rmdbAll (x:xs) = x : rmdb (Md.rm xs x)
 
---Interface to generic underpinnings
-
--- | Moves a string to lower case.
 tolower :: String -> String
 tolower = down (['a'..'z'],['A'..'Z'])
 
--- | Moves a string to upper case.
 toupper :: String -> String
 toupper = up (['a'..'z'],['A'..'Z'])
 
--- | Removes leading whitespace.
 rmlws :: String -> String
 rmlws = ((flip rmleading) ' ')
 
--- | Removes all symbols, leaving spaces intact.
 rmsymbols :: String -> String
 rmsymbols = ((flip blacklist) (['\\'..'`']))
-
-
diff --git a/cookbook.cabal b/cookbook.cabal
--- a/cookbook.cabal
+++ b/cookbook.cabal
@@ -10,10 +10,10 @@
 -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:             2.0.0.1
+version:             2.1.0.0
 
 -- A short (one-line) description of the package.
-synopsis:            A delicious set of interdependant libraries.
+synopsis:	Tiered general-purpose libraries with domain-specific applications.
 
 -- A longer description of the package.
 -- description:         
@@ -48,7 +48,7 @@
 
 library
   -- Modules exported by the library.
-  exposed-modules:     Cookbook.Project.Context.Context, Cookbook.Essential.Common, Cookbook.Essential.Continuous, Cookbook.Essential.IO, Cookbook.Recipes.DiffStat,  Cookbook.Project.Configuration.Configuration, Cookbook.Project.Scribe.Scribe, Cookbook.Project.Preprocess.Preprocess, Cookbook.Ingredients.Functional.Break, Cookbook.Ingredients.Lists.Access, Cookbook.Ingredients.Lists.Remove, Cookbook.Ingredients.Lists.Modify, Cookbook.Ingredients.Lists.Stats, Cookbook.Ingredients.Tupples.Look, Cookbook.Ingredients.Tupples.Assemble, Cookbook.Recipes.Detect, Cookbook.Project.Groups.Groups, Cookbook.Recipes.Sanitize, Cookbook.Ingredients.Lists.Replace, Cookbook.Recipes.Math,Cookbook.Recipes.DataStructures,Cookbook.Recipes.Algorithm, Cookbook.Project.Quill.Quill, Cookbook.Ingredients.Lists.Splice
+  exposed-modules:      Cookbook.Essential.Common, Cookbook.Essential.Continuous, Cookbook.Essential.IO,   Cookbook.Project.Configuration.Configuration, Cookbook.Project.Preprocess.Preprocess, Cookbook.Ingredients.Functional.Break, Cookbook.Ingredients.Lists.Access, Cookbook.Ingredients.Lists.Modify, Cookbook.Ingredients.Lists.Stats, Cookbook.Ingredients.Tupples.Look, Cookbook.Ingredients.Tupples.Assemble,  Cookbook.Recipes.Sanitize, Cookbook.Recipes.Math,Cookbook.Recipes.DataStructures,Cookbook.Recipes.Algorithm, Cookbook.Project.Quill.Quill
   
   -- Modules included in this library but not exported.
   -- other-modules: