diff --git a/Cookbook/Common.hs b/Cookbook/Common.hs
deleted file mode 100644
--- a/Cookbook/Common.hs
+++ /dev/null
@@ -1,38 +0,0 @@
-module Cookbook.Common(sub,positions,pos,apply,flt) where
-
---Cut a list off at a certain point
---sub [1,2,3] 1 -> [2 3]
--- | Returns a new list starting at a position. List positions start at 0.
-sub :: (Eq a) => [a] -> Int -> [a]
-sub [] _ = []
-sub x 0 = x
-sub (x:xs) c = sub xs (c - 1)
-
---Find all positions of an element in a list
---positions [1,2,1,2,1,2] 1 -> [ 0 2 4 ]
---Edge cases: [] on notElem
--- | Finds every occurence of an element within a list, starting at position 0.
-positions :: (Eq a) => [a] -> a -> [Int]
-positions x c = let y = zip x [0..(length x)] in find y
-  where find y = [e | (d,e) <- y, d == c]
-
---Interface to positions to find the first matching element.
---pos [1,2,3] 2 -> 1
---Edge Cases: -1 on notElem (Maybe unused because this is a helper function)
--- | Interface to position for finding the position of the first occurence in a list.
-pos :: (Eq a) => [a] -> a -> Int
-pos x c | c `notElem` x = -1
-pos x c = let ans = positions x c in ((if (length ans) > 1 then (head . tail) else head) ans)
-
---Apply a list of functions to one value.
--- | Apply a list of functiosn to one value, using the result from the function beforehand.
-apply :: [(a -> a)] -> a -> a
-apply [] c = c
-apply (f:fs) c = apply fs (f c)
-
--- | Flatten a list one level.
-flt :: [[a]] -> [a]
-flt [] = []
-flt (x:xs) = x ++ flt xs
-
-
diff --git a/Cookbook/Continuous.hs b/Cookbook/Continuous.hs
deleted file mode 100644
--- a/Cookbook/Continuous.hs
+++ /dev/null
@@ -1,41 +0,0 @@
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-
-module Cookbook.Continuous(Continuous(..)) where
-
-import Cookbook.Common
-import Cookbook.Ingredients.Functional.Break
-import Cookbook.Ingredients.Lists.Access
-
--- | 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 $ removeBreak (/=c) x
-  before x c  = filterBreak (/=c) x
-  delete x c  = filter (/= c) x
-  
-instance (Eq a) => Continuous [a] [a] where
-  after [] _ = []
-  after x c
-    | take (length c) x == c = sub x ((length c))
-    | otherwise = after (tail x) c
-
-  before [] _ = []
-  before x c
-    | take (length c) x == c = []
-    | otherwise = (head x) : before (tail x) c
-
-  delete [] _ = []
-  delete x c
-    | not (x `contains` c) = x
-    | otherwise = (before x c) ++ delete (after x c) c
diff --git a/Cookbook/Essential/Common.hs b/Cookbook/Essential/Common.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Essential/Common.hs
@@ -0,0 +1,36 @@
+--Cookbook.Essential.Common
+--Common is the root of the Cookbook library. It provides the abstracts commonly used to build
+--robust applications and sub-libraries within Cookbook. In any Cookbook implementation, Common
+--varies based on the language features the language presents. In Haskell, Common merely provides
+--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) where
+
+-- | Returns a new list starting at a position. List positions start at 0.
+sub :: (Eq a) => [a] -> Int -> [a]
+sub [] _ = []
+sub x 0 = x
+sub (x:xs) c = sub xs (c - 1)
+
+-- | Finds every occurence of an element within a list, starting at position 0.
+positions :: (Eq a) => [a] -> a -> [Int]
+positions x c = let y = zip x [0..(length x)] in find y
+  where find y = [e | (d,e) <- y, d == c]
+
+-- | Interface to position for finding the position of the first occurence in a list.
+pos :: (Eq a) => [a] -> a -> Int
+pos x c | c `notElem` x = -1
+pos x c = let ans = positions x c in ((if (length ans) > 1 then (head . tail) else head) ans)
+
+-- | Apply a list of functiosn to one value, using the result from the function beforehand.
+apply :: [(a -> a)] -> a -> a
+apply [] c = c
+apply (f:fs) c = apply fs (f c)
+
+-- | Flatten a list one level.
+flt :: [[a]] -> [a]
+flt [] = []
+flt (x:xs) = x ++ flt xs
+
+
diff --git a/Cookbook/Essential/Continuous.hs b/Cookbook/Essential/Continuous.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Essential/Continuous.hs
@@ -0,0 +1,39 @@
+{-# LANGUAGE FlexibleInstances     #-}
+{-# 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
+
+import qualified Cookbook.Essential.Common as Cm
+import qualified Cookbook.Ingredients.Functional.Break as Br
+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
+  
+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
+
+  before [] _ = []
+  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
diff --git a/Cookbook/Essential/IO.hs b/Cookbook/Essential/IO.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Essential/IO.hs
@@ -0,0 +1,21 @@
+--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) where
+
+import  System.IO
+import System.Environment
+
+-- | Returns the lines of a file, wrapped in an IO.
+filelines :: String -> IO ([String])
+filelines x = do
+  y <- openFile x ReadMode
+  yc <- hGetContents y
+  return (lines yc)
+
+-- | Prompts the user for a string
+prompt :: String -> IO (String)
+prompt x = do
+    putStr x
+    hFlush stdout
+    getLine
diff --git a/Cookbook/IO.hs b/Cookbook/IO.hs
deleted file mode 100644
--- a/Cookbook/IO.hs
+++ /dev/null
@@ -1,17 +0,0 @@
-module Cookbook.IO(filelines,prompt) where
-import System.IO
-import System.Environment
-
--- | Returns the lines of a file, wrapped in an IO.
-filelines :: String -> IO ([String])
-filelines x = do
-  y <- openFile x ReadMode
-  yc <- hGetContents y
-  return (lines yc)
-
--- | Prompts the user for a string
-prompt :: String -> IO (String)
-prompt x = do
-    putStr x
-    hFlush stdout
-    getLine
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
@@ -1,39 +1,25 @@
-module Cookbook.Ingredients.Functional.Break(
-removeBreak, filterBreak,btr,imbreak) where
+--Cookbook.Ingredients.Functional.Break
+--Break contains utilities for collectings lists conditionally. Unlike filter 
+--from prelude, breaks will stop collecting elements of the list at the first
+--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.
 
---Return the list at the first untrue return from predicate f.
---removeBreak (==1) [1,1,2,3] -> [2,3]
+module Cookbook.Ingredients.Functional.Break(removeBreak, filterBreak,btr,imbreak) where
+
 -- | When the predicate returns false, removeBreak returns the rest of the list.
 removeBreak :: (a -> Bool) -> [a] -> [a]
 removeBreak _ [] = []
-removeBreak f (c:cs)
-  | not $ f c = (c:cs)
-  | otherwise = removeBreak f cs
+removeBreak f (c:cs) = if not $ f c then (c:cs) else removeBreak f cs
 
---Stop consing a list at first untrue return from predicate f.
---filterBreak (==1) [1,1,2,3] -> [1,1]
 -- | When the predicate returns false, filterBreak will stop collecting the list.
 filterBreak :: (a -> Bool) -> [a] -> [a]
 filterBreak _ [] = []
-filterBreak f (c:cs)
-  | not $ f c = []
-  | otherwise = c : filterBreak f cs
+filterBreak f (c:cs) = if not $ f c then [] else c : filterBreak f cs
 
--- Immediately break out of execution on a true.
--- Will return false at the end of execution
 -- | imbreak will return true if any of the members of the list satisfy the predicate.
 imbreak :: (a -> Bool) -> [a] -> Bool
-imbreak _ [] = False
-imbreak f x
-  | f (head x) = True
-  | otherwise = imbreak f (tail x)
+imbreak f = or . map f
 
---Boolean TRansform: (a,b) a if true, b if not, return the list.
---btr (==1) [1,2,3] ('a','b') -> "abb"
 -- | Conditionally transform input based on the predicate. When it is true, fst of the tupple is used, snd otherwise.
-btr :: (a -> Bool) -> [a] -> (b,b) -> [b]
-btr _ [] _ = []
-btr f (c:cs) (a,b)
-  | f c = a : rest
-  | otherwise = b : rest
-  where rest = btr f cs (a,b)
+btr :: (a -> Bool) -> (b,b) -> [a] -> [b]
+btr f (a,b) = map (\c -> if f c then a else b)
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,33 +1,31 @@
-module Cookbook.Ingredients.Lists.Access(
-count,contains,qsort,pull,refpos,areAll) where
+--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) where
 
 import qualified Cookbook.Ingredients.Functional.Break as Br
 
-import qualified Cookbook.Common as Cm
+import qualified Cookbook.Essential.Common as Cm
 
---Count the number of occurances in a list.
--- | Counts the number of occurences within a list.
+-- | Counts the number of occurrences within a list.
 count :: (Eq a) => [a] -> a -> Int
-count x c = sum $ Br.btr (==c) x (1,0)
+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
-  | (take (length c) x) == c = True
-  | otherwise = contains (tail x) c 
+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  = qsort [y | y <- xs, y <= x]
-    greatT = qsort [y | y <- xs, y > x]
+  where  (lessT,greatT)  = (qsort $ filter (<=x) xs,qsort $filter (>x) xs)
 
--- | Safe !!
+-- | Safer way than (!! (Prelude)) to get items out of a list. Returns nothing on failure.
 pull :: [a] -> Int -> Maybe a
-pull _ (-1) = Nothing
+pull _ c | c < 0 = Nothing
 pull [] _  = Nothing
 pull (x:xs) c = if c == 0 then (Just x) else pull xs (c - 1)
 
@@ -38,3 +36,7 @@
 -- | 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,10 +1,11 @@
-module Cookbook.Ingredients.Lists.Modify(
-rev,rm,splitOn,snipe,insert) where
+--Cookbook.Ingredients.Lists.Modify
+--Library for altering the contents of a list.
 
-import qualified Cookbook.Continuous as Cnt
-import qualified Cookbook.Common as Com
---Reverse a list
---rev [1,2,3,4] -> [4,3,2,1]
+module Cookbook.Ingredients.Lists.Modify(rev,rm,splitOn,snipe,insert,between) where
+
+import qualified Cookbook.Essential.Continuous as Cnt
+import qualified Cookbook.Essential.Common as Cm
+
 -- | Reverses a list
 rev :: [a] -> [a]
 rev [] = []
@@ -21,8 +22,16 @@
 
 -- | Change a location in a list with an element.
 snipe :: (Eq a) => [a] -> (a,Int) -> [a]
-snipe x (t,c) = (take c x) ++ [t] ++ (Com.sub x (c + 1))
+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 ++ (Com.sub x c)
+insert x (t,c) = (take c x) ++ t ++ (Cm.sub x c)
+
+-- | Find out what is in between two elements of a list
+between a (c,d) = Cnt.after (Cnt.before a d) c
+
+-- | Intersperse elements into a list.
+intersperse :: [a] -> a -> [a]
+intersperse [x] _ = [x]
+intersperse (x:xs) c =  x:c : intersperse xs c
diff --git a/Cookbook/Ingredients/Lists/Replace.hs b/Cookbook/Ingredients/Lists/Replace.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Ingredients/Lists/Replace.hs
@@ -0,0 +1,31 @@
+{-# 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/Stats.hs b/Cookbook/Ingredients/Lists/Stats.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Ingredients/Lists/Stats.hs
@@ -0,0 +1,14 @@
+module Cookbook.Ingredients.Lists.Stats(frequency,mostFrequent) where
+
+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
+
+-- | 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/Ingredients/Tupples/Assemble.hs b/Cookbook/Ingredients/Tupples/Assemble.hs
--- a/Cookbook/Ingredients/Tupples/Assemble.hs
+++ b/Cookbook/Ingredients/Tupples/Assemble.hs
@@ -1,11 +1,15 @@
+--Cookbook.Ingredients.Tupples.Assemble
+--Assemble is a library for sorting and constructing lists from touples with a member of Ord in the second slot.
+--It is used for frequency analyzation, as well as other very particular tasks, but is kept out of Recipes because it is still generic.
 module Cookbook.Ingredients.Tupples.Assemble(tupsort,assemble) where
 
-
+-- | Quicksort a list of tupples, with the (Ord) element being the second one.
 tupsort :: (Ord b) => [(a,b)] -> [(a,b)]
 tupsort [] = []
 tupsort ((a,n):xs) = lesser ++ [(a,n)] ++ greater
   where lesser   = tupsort [(c,d) | (c,d) <- xs, d <= n]
         greater = tupsort [(c,d) | (c,d) <- xs, d > n]
 
+-- | Orders element-Ord tupples and gets all of the first elements.
 assemble :: (Ord b) => [(a,b)] -> [a]
 assemble = (map fst) . tupsort
diff --git a/Cookbook/Ingredients/Tupples/Look.hs b/Cookbook/Ingredients/Tupples/Look.hs
--- a/Cookbook/Ingredients/Tupples/Look.hs
+++ b/Cookbook/Ingredients/Tupples/Look.hs
@@ -1,17 +1,17 @@
+--Cookbook.Ingredients.Tupples.Look
+--This library is for manipulating and searching lists of two-element tupples.
+
 module Cookbook.Ingredients.Tupples.Look(look,lookList,swp) where
 
 -- | Returns the second element of the first tupple where the first element matches input.
 look :: (Eq a) => [(a,b)] -> a -> (Maybe b)
 look [] _ = Nothing
-look ((a,b):bs) c
-  | a == c = (Just b)
-  | otherwise = look bs c
+look (a:b) c = if fst a == c then Just (snd a) else look b c
 
 -- | Returns all second elements where (fst t) matches the input.
-lookList :: (Eq a) => [(a,b)] -> a -> Maybe [b]
-lookList d c = case filt of [] -> Nothing ; _ -> Just filt
-  where filt = [b | (a,b) <- d, a == c]
+lookList :: (Eq a) => [(a,b)] -> a -> [b]
+lookList a b =  [d | (c,d) <- a, c == b]
 
 -- | Swap the order of a second-degree tupple.
 swp :: (a,b) -> (b,a)
-swp (a,b) = (b,a)
+swp    (a,b)  = (b,a)
diff --git a/Cookbook/Project/Configuration/Configuration.hs b/Cookbook/Project/Configuration/Configuration.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Project/Configuration/Configuration.hs
@@ -0,0 +1,6 @@
+module Cookbook.Project.Configuration.Configuration(conf) where
+import qualified Cookbook.Ingredients.Lists.Modify as Md
+import qualified Cookbook.Ingredients.Tupples.Look as Lk
+
+conf :: [String] -> String -> String
+conf x c = let configs = [let (d:f:_) = (Md.splitOn y ':') in (d,f)| y <- x, (length y) > 2, ':' `elem` y] in case (Lk.look configs c) of (Just f) -> f;(Nothing) -> []
diff --git a/Cookbook/Project/Groups/Groups.hs b/Cookbook/Project/Groups/Groups.hs
new file mode 100644
--- /dev/null
+++ b/Cookbook/Project/Groups/Groups.hs
@@ -0,0 +1,21 @@
+--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/Recipes/Configuration.hs b/Cookbook/Recipes/Configuration.hs
deleted file mode 100644
--- a/Cookbook/Recipes/Configuration.hs
+++ /dev/null
@@ -1,8 +0,0 @@
-module Cookbook.Recipes.Configuration(conf) where
-import Cookbook.Ingredients.Lists.Access
-import Cookbook.Ingredients.Lists.Modify
-import Cookbook.Ingredients.Tupples.Look
-
-conf :: [String] -> String -> String
-conf x c = let configs = [let (d:f:_) = (splitOn y ':') in (d,f)| y <- x, (length y) > 2, ':' `elem` y] in case (look configs c) of (Just f) -> f
-                                                                                                                                    (Nothing) -> []
diff --git a/Cookbook/Recipes/Detect.hs b/Cookbook/Recipes/Detect.hs
--- a/Cookbook/Recipes/Detect.hs
+++ b/Cookbook/Recipes/Detect.hs
@@ -1,17 +1,16 @@
+--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 Cookbook.Common
-import Cookbook.Ingredients.Lists.Access
-import Cookbook.Ingredients.Functional.Break
+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
-  | item `elem` a = (Just b)
-  | otherwise = represent c item
+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]
@@ -25,7 +24,7 @@
 
 -- | Does the string contain the standard strpex pattern?
 strmatch :: String -> String -> Bool
-strmatch x c = (strpex x) `contains` c
+strmatch x c = (strpex x) `Ac.contains` c
 
 -- | All lines containing this pattern
 containingPattern :: [String] -> String -> [String]
@@ -34,8 +33,6 @@
 -- | All patterns matching the pattern
 withPattern :: [String] -> String -> [String]
 withPattern [] _ = []
-withPattern a@(x:xs) c
-  | strpex takeX == c = takeX : withPattern xs c
-  | otherwise = withPattern xs c
+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
--- a/Cookbook/Recipes/DiffStat.hs
+++ b/Cookbook/Recipes/DiffStat.hs
@@ -1,46 +1,16 @@
---Library for determining movement of data within a list. 
---data Stat can have one of 3 forms:
---Less a = Back by a
---Even  = Same position
---Great a = Forward by a
-module Cookbook.Recipes.DiffStat(Stat(..),stat,diff,patch) where
-
-import Cookbook.Common
-import Cookbook.Ingredients.Lists.Modify
-import Cookbook.Ingredients.Lists.Access
-import Cookbook.Ingredients.Tupples.Look
-
-import Data.Maybe
-data Stat a = Less a | Even |  Great a deriving (Show)
-
-stat :: (Eq a) => [a] -> [a] -> a -> Stat Int
-stat x c f
-  | f `notElem` x = error "Unique entry found in stat x"
-  | f `notElem` c = error "Unique entry found in stat c"
-stat x c f
-  | diff < 0  = Less diff
-  | diff == 0 = Even
-  | otherwise = Great diff
-  where diff = (pos x f) - (pos c f)
+--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
 
-diff :: (Eq a) => [a] -> [a] -> [Stat Int]
-diff x [] = []
-diff x (c:cs) = stat x (c:cs) c : diff x cs
+import qualified Cookbook.Essential.Common as  Cm
+import qualified Cookbook.Ingredients.Tupples.Assemble as As
 
---The compiler doesn't like this type signature for some reason.
---Here it is anyway, and :t in GHCI can even back it up:
---patch :: (Eq a) => [a] -> [Stat Int] -> [Int] 
-patch x c = assemble $ relatdiff posbind c
-  where posbind = zip x [0..((length x))]
-        
---Get the absolute positions of diff lists.
-relatdiff :: (Eq a) => [(a,Int)] -> [Stat Int] -> [(a,Int)]
-relatdiff [] _ = []
-relatdiff _ [] = []
-relatdiff ((a,b):bs) ((Great x):xs) = (a,(b + x)) : relatdiff bs xs
-relatdiff ((a,b):bs) ((Less x):xs) = (a,(b - x)) : relatdiff bs xs
-relatdiff ((a,b):bs) ((Even):xs) = (a,(b-1)) : relatdiff bs xs
+-- | 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
 
---Assemble a relatdiff list
-assemble :: [(a,Int)] -> [a]
-assemble x = catMaybes $ map (look (map swp x)) $ qsort (map snd x)
+-- | 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/Groups.hs b/Cookbook/Recipes/Groups.hs
deleted file mode 100644
--- a/Cookbook/Recipes/Groups.hs
+++ /dev/null
@@ -1,23 +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.Recipes.Groups(Constructor,construct,implement) where
-
-import Cookbook.Ingredients.Lists.Modify
-import Cookbook.Ingredients.Lists.Access
-import Cookbook.Ingredients.Tupples.Look
-import Cookbook.Recipes.Sanitize
-import Cookbook.Continuous
-
-type Constructor = (String,[String])
-
---Example: phone:number,name
--- | Construct a data constructor. Delmits using '_'
-construct :: String -> Constructor
-construct x = ((before x ':'),(splitOn (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 (splitOn (after x ':') ',')
-  where typ = case look c (before x ':') of (Just e) -> e;  _ -> error "Type undefined."
diff --git a/Cookbook/Recipes/Sanitize.hs b/Cookbook/Recipes/Sanitize.hs
--- a/Cookbook/Recipes/Sanitize.hs
+++ b/Cookbook/Recipes/Sanitize.hs
@@ -2,39 +2,39 @@
 --"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 Cookbook.Common
-import Cookbook.Ingredients.Lists.Modify
-import Cookbook.Ingredients.Lists.Access
-import Cookbook.Ingredients.Functional.Break
+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
 
 -- | Remove each element of the second list from the first.
 blacklist :: (Eq a) => [a] -> [a] -> [a]
-blacklist x c = apply (map (flip rm) c) x
+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 = filterBreak (==c) x
+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 (refpos (a,b)) c
+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 (refpos (b,a)) c
+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 (removeBreak (== x) (y:zs)) else x : rmdb (y:zs)
+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 (rm xs x)
+rmdbAll (x:xs) = x : rmdb (Md.rm xs x)
 
 --Interface to generic underpinnings
 
diff --git a/Cookbook/Recipes/Stats.hs b/Cookbook/Recipes/Stats.hs
deleted file mode 100644
--- a/Cookbook/Recipes/Stats.hs
+++ /dev/null
@@ -1,14 +0,0 @@
-module Cookbook.Recipes.Stats(frequency,mostFrequent) where
-
-import Cookbook.Ingredients.Tupples.Assemble
-import Cookbook.Ingredients.Lists.Access
-import Cookbook.Ingredients.Lists.Modify
-import Cookbook.Recipes.Sanitize
-
--- | 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,count x c)) x in rmdbAll y
-
--- | Get the x amount of most frequent items in the list.
-mostFrequent :: (Eq a) => [a] -> Int -> [a]
-mostFrequent x c = take c $ rev (assemble  $ frequency x)
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:             0.1.5.0
+version:             1.1.0.1
 
 -- A short (one-line) description of the package.
-synopsis:            An independent library of common haskell operations.
+synopsis:            A delicious set of interdependant libraries.
 
 -- A longer description of the package.
 -- description:         
@@ -47,7 +47,7 @@
 
 library
   -- Modules exported by the library.
-  exposed-modules:     Cookbook.Common, Cookbook.Continuous, Cookbook.IO, Cookbook.Recipes.DiffStat, Cookbook.Recipes.Stats, Cookbook.Recipes.Configuration, Cookbook.Ingredients.Functional.Break, Cookbook.Ingredients.Lists.Access, Cookbook.Ingredients.Lists.Modify, Cookbook.Ingredients.Tupples.Look, Cookbook.Ingredients.Tupples.Assemble, Cookbook.Recipes.Detect, Cookbook.Recipes.Groups, Cookbook.Recipes.Sanitize
+  exposed-modules:     Cookbook.Essential.Common, Cookbook.Essential.Continuous, Cookbook.Essential.IO, Cookbook.Recipes.DiffStat, Cookbook.Project.Configuration.Configuration, 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.Detect, Cookbook.Project.Groups.Groups, Cookbook.Recipes.Sanitize, Cookbook.Ingredients.Lists.Replace
   
   -- Modules included in this library but not exported.
   -- other-modules: