diff --git a/Cookbook/Ingredients/Lists/Encompass.hs b/Cookbook/Ingredients/Lists/Encompass.hs
--- a/Cookbook/Ingredients/Lists/Encompass.hs
+++ b/Cookbook/Ingredients/Lists/Encompass.hs
@@ -16,14 +16,15 @@
 
 -- | Get the entire section of a list contained within the scope delimited by the parameters, even sub-scopes.
 encompassing :: (Eq a) => [a] -> (a,a) -> [a]
-encompassing (x:xs) (a,b) = helper (x:xs) (a,b) 0
+encompassing (x:xs) (a,b) = helper (x:xs) 0
   where
-    helper [] _ _ = []
-    helper (y:ys) (c,d) e
-      | y == d && e <= 1 = []
-      | y == c = condInp    $ helper ys (c,d) (e + 1)
-      | y == d = y : helper ys (c,d) (e - 1)
-      | otherwise = condInp $ helper ys (c,d) e
+    helper [] _  = []
+    helper (y:ys) e
+      | y == b && e <= 1 = []
+      | y == a && a == b = if e == 0 then [] else condInp $ helper ys (e + 1)
+      | y == a = condInp $ helper ys (e + 1)
+      | y == b = y : helper ys (e - 1)
+      | otherwise = condInp $ helper ys e
       where
         condInp = ([y | e > 0] ++)
 
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
@@ -7,8 +7,7 @@
    Portability :   Portable (Cookbook
 A library for reading simple databases. As what was originally a quirk of the library, database tables can be split up and still parsed as if they were a unit, giving it the ability to read the same table from multiple files in parallel. Quill supports a comment syntax, whitespace-insignificant parsing, and a full CRUD API. Quill will EVENTUALLY be replaced by Scribe2, but the planning for Scribe2 has not yet begun.
 -}
-
-module Cookbook.Project.Quill.Quill where 
+module Cookbook.Project.Quill.Quill {-# DEPRECATED "Quill2 Deprecates this. Scheduled for removal on June 1st, 2014." #-} where 
 
 import qualified Cookbook.Essential.Common         as Cm
 import qualified Cookbook.Essential.Continuous     as Ct
diff --git a/Cookbook/Project/Quill/Quill2.hs b/Cookbook/Project/Quill/Quill2.hs
deleted file mode 100644
--- a/Cookbook/Project/Quill/Quill2.hs
+++ /dev/null
@@ -1,128 +0,0 @@
-{- |
-   Module      :   Cookbook.Project.Quill.Quill2
-   Copyright   :   (c) 2014 by Nate Pisarski
-   License     :   BSD3
-   Maintainer  :   nathanpisarski@gmail.com
-   Stability   :   Stable
-   Portability :   Portable (Cookbook
-Another library for managing databases. It GREATLY breaks compatibility with Quill, and it will eventually deprecate Quill. It's a whitespace-independant string-based flat file language for database information. Some advantages that Quill2 has over Quill include: Record database entries, list support, better commenting support, more complete API, and greater error handling / safety.
--}
-
-module Cookbook.Project.Quill.Quill2 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.Lists.Encompass as En
-import qualified Cookbook.Ingredients.Tupples.Look    as Lk
-
--- Data types and Instances
--- | The body of a table or list.
-data Element a = List [a] | Table [(a,a)] deriving (Eq, Show)
-
--- | Helper type. Binds a name to a body.
-type Quill = (String,Element String)
-  
--- Preprocessing functions - Turning raw text into a more easily workable format.
-
--- | Strip comments from a sanitized string. Comments start with /* and end with */.
-decomment :: String -> String
-decomment = (`Ct.splice` ("/*", "*/"))
-
--- | Prepare the lines of a file for processing.
-prepare :: [String] -> String
-prepare = decomment . (`Ct.remove` '\n') . unlines
-
--- Text processing - Turning the preprocessed text into data.
-
--- | Process a single entry in the database into a Table.
-pTable :: String -> Quill
-pTable x = typ
-  where
-    name = Md.between (Ct.before x '{') ('(',')') --table(name) or list(name)
-    typ  = (name,if (Ct.before x '{') `Ac.contains` "table" then Table (parseTables body) else List body)
-    body = Md.splitOn (En.encompassing x ('{','}')) ';'
-    quoted y = if ('`','\'') `Ac.surrounds` y then En.encompassing x ('`','\'') else Ct.remove y ' '
-    parseTables [] = []
-    parseTables (x:xs) =(quoted $ Ct.before x ':', Ct.after x ':') : parseTables xs
-
--- | Turn the lines of a file into a list of tables, AKA a Database.
-pFile :: [String] -> [Quill]
-pFile x = case allTables of
-  [] -> []
-  (y:ys) -> pTable y : pFile ys
-  where
-    prepared  = prepare x
-    allTables = Md.splitOn prepared '}'
-
--- API functions for creating and reading tables.
-
-data QuillStatus = QuillSuccess Quill | QuillMissing | QuillMultiple deriving (Eq,Show)
-
-getQuillName :: Quill -> String
-getQuillName = fst
-
-getQuill :: [Quill] -> String -> QuillStatus
-getQuill [] _ = QuillMissing
-getQuill (x:xs) c
-  | Ac.count (map getQuillName (x:xs)) c > 1 = QuillMultiple
-  | getQuillName x  == c = QuillSuccess x
-  | otherwise = getQuill xs c
-
-lookUp :: [Quill] -> (String, String) -> String
-lookUp x (a,b) = case (getQuill x a) of
-  QuillMissing  -> error $ "Table not found."
-  QuillMultiple -> error $ "Multiple values of " ++ a ++ " detected. Database eror, fix manually."
-  (QuillSuccess (c,d)) -> case d of
-    (List f) -> error "Cannot look up the value of a list."
-    (Table f) -> let c = Lk.lookList f b in if (c == []) then (error $ "Item " ++ b ++ " not found in table " ++ a) else (if (length c > 1) then multipleInnerError else (head c))
-    where multipleInnerError = error $ "Multiple values of " ++ b ++ " found in table " ++ a ++ ". Database corrupted, change manually."
-
-removeQuill :: [Quill] -> String -> [Quill]
-removeQuill [] _ = []
-removeQuill ((x,y):xs) c
-  | x == c = removeQuill xs c -- See [Q2N1]
-  | otherwise = (x,y) : removeQuill xs c
-
-removeItem :: [Quill] -> (String, String) -> [Quill]
-removeItem x (a,b) = case (getQuill x a) of
-  QuillSuccess (c,j) -> case j of
-    (Table d) -> (c,(Table [(y,t) | (y,t) <- d, y /= b])) : (removeQuill x a)
-    (List d) -> (c,List $ Ct.remove d c) : removeQuill x a
-  _ -> (let l = lookUp x (a,b) in x) -- This goes against everything that haskell means.
-
-addQuill :: [Quill] -> Quill -> [Quill]
-addQuill x c = c : x
-
-addToQuill :: Quill -> (String, String) -> Quill
-addToQuill (x,b) c = case b of
-  (Table z) -> (x, Table (c:z))
-  (List z) ->  (x, List (z))
-
-addItem :: [Quill] -> (String, String, String) -> [Quill]
-addItem x (a, b, c)= case getQuill x a of
-  QuillSuccess (y, ys) -> case ys of
-    (Table d) -> (y,Table $ (b,c) : d) : removeQuill x a
-    (List d)  -> (y,List  $ (c:d)) : removeQuill x a
-  QuillMultiple -> error "Multiple found"
-  QuillMissing -> error "Not found quill!"
-
-changeItem :: [Quill] -> (String, String, String) -> [Quill]
-changeItem x (a,b,c) = addItem (removeItem x (a,b)) (a,b,c)
-
--- Helping functions for writing / reading to files.
--- | Turn a Quill table into a string.
-toString :: Quill -> String
-toString (nm,typ) = case typ of
-  (List a)  -> ("list(" ++ nm ++ "){" ++ (Cm.flt (map (\c -> (c ++ ";")) a))) ++ "}"
-  (Table a) -> ("table(" ++ nm ++ "){" ++ (Cm.flt $ stringify a)) ++ "}"
-  where
-    stringify [] = []
-    stringify ((a,b):xs) = (a ++ ":" ++ b ++ ";") : stringify xs
-
--- [Q2N1]
--- I had a long debate about this function. What it does is removes tables, but it will remove ALL tables. Since
--- Quill2 treats multiple tables of the same name as an error, I'm choosing to make it a sanitization function as
--- well. Database clients beware.
diff --git a/Cookbook/Project/Quill/Quill2/Q2Api.hs b/Cookbook/Project/Quill/Quill2/Q2Api.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Project/Quill/Quill2/Q2Api.hs
@@ -0,0 +1,96 @@
+{- |
+   Module      :   Cookbook.Project.Quill.Quill2.Q2Api
+   Copyright   :   (c) 2014 by Nate Pisarski
+   License     :   BSD3
+   Maintainer  :   nathanpisarski@gmail.com
+   Stability   :   Stable
+   Portability :   Portable (Cookbook)
+Q2Api is the user-facing part of Quill. It has all the functions necessar to Create, Read, Update, and Delete information from the database, and turn a database back into a Quill-readable string.
+-}
+
+module Cookbook.Project.Quill.Quill2.Q2Api where
+
+import qualified Cookbook.Ingredients.Tupples.Look as Lk
+import qualified Cookbook.Essential.Common         as Cm
+import qualified Cookbook.Essential.Continuous     as Ct
+import qualified Cookbook.Ingredients.Lists.Access as Ac
+
+import Cookbook.Project.Quill.Quill2.Q2Prelude
+
+-- | Get the name of a Quill.
+getQuillName :: Quill -> String
+getQuillName = fst
+
+-- | Return the element of the Quill, specifically useful for lists.
+getQuillBody :: Quill -> Element String
+getQuillBody = snd
+
+-- | Find a quill in the database by name, returning it or a possible error type.
+getQuill :: [Quill] -> String -> QuillStatus
+getQuill [] _ = QuillMissing
+getQuill (x:xs) c
+  | Ac.count (map getQuillName (x:xs)) c > 1 = QuillMultiple
+  | getQuillName x  == c = QuillSuccess x
+  | otherwise = getQuill xs c
+
+-- | Look up the value of a Quill TABLE. Will produce an error on a list.
+lookUp :: [Quill] -> (String, String) -> String
+lookUp x (a,b) = case (getQuill x a) of
+  QuillMissing  -> error $ "Table not found."
+  QuillMultiple -> error $ "Multiple values of " ++ a ++ " detected. Database eror, fix manually."
+  (QuillSuccess (c,d)) -> case d of
+    (List f) -> error "Cannot look up the value of a list."
+    (Table f) -> let c = Lk.lookList f b in if (c == []) then (error $ "Item " ++ b ++ " not found in table " ++ a) else (if (length c > 1) then multipleInnerError else (head c))
+    where multipleInnerError = error $ "Multiple values of " ++ b ++ " found in table " ++ a ++ ". Database corrupted, change manually."
+
+-- | Remove a quill from the database by name.
+removeQuill :: [Quill] -> String -> [Quill]
+removeQuill [] _ = []
+removeQuill ((x,y):xs) c
+  | x == c = removeQuill xs c -- See [Q2N1]
+  | otherwise = (x,y) : removeQuill xs c
+
+-- | Remove an item from a Quill within a database. Works aggressively, meaning it removes all copies to help sanitize QuillMultiples out.
+removeItem :: [Quill] -> (String, String) -> [Quill]
+removeItem x (a,b) = case (getQuill x a) of
+  QuillSuccess (c,j) -> case j of
+    (Table d) -> (c,(Table [(y,t) | (y,t) <- d, y /= b])) : (removeQuill x a)
+    (List d) -> (c,List $ Ct.remove d c) : removeQuill x a
+  _ -> (let l = lookUp x (a,b) in x) -- This goes against everything that haskell means.
+
+-- | Adds a Quill databse to the file.
+addQuill :: [Quill] -> Quill -> [Quill]
+addQuill x c = c : x
+
+-- | Add a QuillAddition to the databse. QuillAddition is a safe encapsulation of list and table values.
+addItem :: [Quill] -> QuillAddition -> [Quill]
+addItem x qa= case getQuill x a of
+  QuillSuccess (y, ys) -> case ys of
+    (Table d) -> case qa of
+      (ATable (_,b,c)) -> (y,Table $ (b,c) : d) : removeQuill x a
+      (AList _ ) -> error $ "$ Type Mismatch! Attempted to add a List type to Table in table " ++ (show qa)
+    (List d)  -> case qa of
+      (AList (_,b)) -> (y, List $ (b:d)) : removeQuill x a
+      (ATable _) -> error $ "Type MisMatch! Attempted to add Table type to List in table " ++ (show qa)
+  QuillMultiple -> error "Multiple found"
+  QuillMissing -> error "Not found quill!"
+  where
+    a = case qa of
+      (ATable (g,b,c)) -> g
+      (AList  (g,b))   -> g
+
+-- | Change an item within the database using a Quill addition. Wrapper of addItem and removeItem.
+changeItem :: [Quill] -> QuillAddition -> [Quill]
+changeItem x y = case y of
+                      (ATable (a,b,c)) -> addItem (removeItem x (a,b)) y
+                      (AList  (a,b)) -> addItem (removeItem x (a,b)) y
+
+
+-- | Turn a Quill table into a string.
+toString :: Quill -> String
+toString (nm,typ) = case typ of
+  (List a)  -> ("list(" ++ nm ++ "){" ++ (Cm.flt (map (\c -> (c ++ ";")) a))) ++ "}"
+  (Table a) -> ("table(" ++ nm ++ "){" ++ (Cm.flt $ stringify a)) ++ "}"
+  where
+    stringify [] = []
+    stringify ((a,b):xs) = (a ++ ":" ++ b ++ ";") : stringify xs
diff --git a/Cookbook/Project/Quill/Quill2/Q2Io.hs b/Cookbook/Project/Quill/Quill2/Q2Io.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Project/Quill/Quill2/Q2Io.hs
@@ -0,0 +1,28 @@
+{- |
+   Module      :   Cookbook.Project.Quill.Quill2.Q2Io
+   Copyright   :   (c) 2014 by Nate Pisarski
+   License     :   BSD3
+   Maintainer  :   nathanpisarski@gmail.com
+   Stability   :   Stable
+   Portability :   Portable (Cookbook)
+Q2Io is a helper library for interacting with Quill files. It aids in the reading of and writing to files on the user's system.
+-}
+
+module Cookbook.Project.Quill.Quill2.Q2Io where
+
+import qualified Cookbook.Project.Quill.Quill2.Q2Api as Q2Api
+
+import qualified Cookbook.Essential.IO as Io
+
+import Cookbook.Project.Quill.Quill2.Q2Prelude
+import Cookbook.Project.Quill.Quill2.Q2Parse
+
+import System.IO
+
+-- | Read a Quill database from a file.
+fromFile :: FilePath ->  IO ([Quill])
+fromFile x = fmap pFile $ Io.filelines x
+
+-- | Send a Quill database into a parsable format in a file.
+toFile :: FilePath -> [Quill] -> IO ()
+toFile x c = writeFile x $ unlines $ map Q2Api.toString c
diff --git a/Cookbook/Project/Quill/Quill2/Q2Parse.hs b/Cookbook/Project/Quill/Quill2/Q2Parse.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Project/Quill/Quill2/Q2Parse.hs
@@ -0,0 +1,48 @@
+{- |
+   Module      :   Cookbook.Project.Quill.Quill2.Q2Parse
+   Copyright   :   (c) 2014 by Nate Pisarski
+   License     :   BSD3
+   Maintainer  :   nathanpisarski@gmail.com
+   Stability   :   Stable
+   Portability :   Portable (Cookbook)
+Q2Parse is the "engine" of Quill2. It is able to turn a string (or a list of them) into a Quill database. The syntax of Quill currently supports Whitespace-inclusive strings, comments, and whitespace-independence.
+-}
+
+module Cookbook.Project.Quill.Quill2.Q2Parse 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.Lists.Encompass as En
+
+import Cookbook.Project.Quill.Quill2.Q2Prelude
+
+-- | Remove all C-style comments frm the code. Does not support single-line comments, because Quill2 is fully whitespace independant.
+decomment :: String -> String
+decomment = (`Ct.splice` ("/*", "*/"))
+
+-- | Prepare the lines of a file for processing.
+prepare :: [String] -> String
+prepare = decomment . (`Ct.remove` '\n') . unlines
+
+-- | Process a single entry in the database into a Table.
+pTable :: String -> Quill
+pTable x = typ
+  where
+    name = Md.between (Ct.before x '{') ('(',')') --table(name) or list(name)
+    typ  = (name,if (Ct.before x '{') `Ac.contains` "table" then Table (parseTables body) else List body)
+    body = Md.splitOn (En.encompassing x ('{','}')) ';'
+    quoted y = if ('`','\'') `Ac.surrounds` y then En.encompassing x ('`','\'') else Ct.remove y ' '
+    parseTables [] = []
+    parseTables (x:xs) =(quoted $ Ct.before x ':', Ct.after x ':') : parseTables xs
+
+-- | Turn the lines of a file into a list of tables, AKA a Database.
+pFile :: [String] -> [Quill]
+pFile x = case allTables of
+  [] -> []
+  (y:ys) -> pTable y : pFile ys
+  where
+    prepared  = prepare x
+    allTables = Md.splitOn prepared '}'
diff --git a/Cookbook/Project/Quill/Quill2/Q2Prelude.hs b/Cookbook/Project/Quill/Quill2/Q2Prelude.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Project/Quill/Quill2/Q2Prelude.hs
@@ -0,0 +1,24 @@
+{- |
+   Module      :   Cookbook.Project.Quill.Quill2.Q2Prelude
+   Copyright   :   (c) 2014 by Nate Pisarski
+   License     :   BSD3
+   Maintainer  :   nathanpisarski@gmail.com
+   Stability   :   Stable
+   Portability :   Portable (Cookbook)
+Q2Prelude is the entry-level module for Quill2. It defines the data types that define data, databases, and errors throughout the rest of Quill2.
+-}
+
+module Cookbook.Project.Quill.Quill2.Q2Prelude where
+       
+-- | The body of a table or list.
+data Element a = List [a] | Table [(a,a)] deriving (Eq, Show)
+
+-- | Helper type. Binds a name to a body.
+type Quill = (String,Element String)
+
+-- | Encapsulates errors in the quill database. Currently supports Missing elements and Multiple Instances.
+data QuillStatus = QuillSuccess Quill | QuillMissing | QuillMultiple deriving (Eq, Show)
+
+-- | Safe way of adding items to a Quill database. Allows type-checking on Lists and Tables when manipulating Elements.
+data QuillAddition = AList (String, String) | ATable (String, String, String) deriving (Eq, Show)
+
diff --git a/cookbook.cabal b/cookbook.cabal
--- a/cookbook.cabal
+++ b/cookbook.cabal
@@ -3,7 +3,7 @@
 -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:             2.3.1.0
+version:             2.3.2.0
 synopsis:	Tiered general-purpose libraries with domain-specific applications.
 description:		Cookbook is a line of libraries covering a wide variety of Haskell applications. Every application that I make, I add its functions to Cookbook, turning Cookbook into an all-encompassing general-purpose library over time. The claim-to-fame for the library is its use of overloaded typeclasses, called "Continuities". 
 license:             BSD3
@@ -16,7 +16,7 @@
 build-type:          Simple
 cabal-version:       >=1.8
 library 
-  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, Cookbook.Recipes.Cline, Cookbook.Ingredients.Lists.Encompass, Cookbook.Project.Quill.Quill2
+  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, Cookbook.Recipes.Cline, Cookbook.Ingredients.Lists.Encompass, Cookbook.Project.Quill.Quill2.Q2Parse, Cookbook.Project.Quill.Quill2.Q2Prelude, Cookbook.Project.Quill.Quill2.Q2Api, Cookbook.Project.Quill.Quill2.Q2Io
   build-depends:       base ==4.6.*, directory, strict
 source-repository head
   type: git