cookbook 2.1.2.1 → 2.2.0.0

raw patch · 18 files changed

+158/−61 lines, 18 files

Files

• Cookbook/Essential/Common.hs +5/−0
• Cookbook/Essential/Continuous.hs +7/−6
• Cookbook/Essential/IO.hs +6/−6
• Cookbook/Ingredients/Functional/Break.hs +2/−2
• Cookbook/Ingredients/Lists/Access.hs +3/−3
• Cookbook/Ingredients/Lists/Encompass.hs +46/−0
• Cookbook/Ingredients/Lists/Modify.hs +9/−6
• Cookbook/Ingredients/Lists/Stats.hs +5/−5
• Cookbook/Ingredients/Tupples/Assemble.hs +1/−1
• Cookbook/Ingredients/Tupples/Look.hs +1/−1
• Cookbook/Project/Configuration/Configuration.hs +1/−1
• Cookbook/Project/Preprocess/Preprocess.hs +2/−2
• Cookbook/Project/Quill/Quill.hs +6/−6
• Cookbook/Recipes/Algorithm.hs +11/−10
• Cookbook/Recipes/Cline.hs +41/−0
• Cookbook/Recipes/Math.hs +4/−4
• Cookbook/Recipes/Sanitize.hs +6/−6
• cookbook.cabal +2/−2

@@ -42,3 +42,8 @@ fromLast f c = rev $ f $ rev c   where rev [] = []         rev (x:xs) = rev xs ++ [x]++afterX :: (Eq a) => [a] -> a -> Int -> [a]+afterX (x:xs) c t+  | t == 0 = x:xs+  | otherwise = if x == c then afterX xs c (pred t) else afterX xs c t

@@ -24,7 +24,7 @@      -- | Returns all elements after part.   after :: list -> part -> list-  +   -- | Returns all elements after part.   before :: list -> part -> list   @@ -41,10 +41,10 @@   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  -- | Classifies information which can be split by a tupple. class Splicable a b where@@ -53,7 +53,7 @@   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+  splice ls (a,b) = before ls a ++ Cm.fromLast (`before` b) ls  instance (Eq a) => Splicable [a] ([a],[a]) where   splice ls (a,b)  = before ls a ++ after (after ls a) b@@ -73,8 +73,8 @@ 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)+    | 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@@ -91,3 +91,4 @@   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)+

@@ -21,24 +21,24 @@ import System.Directory  -- | Return the lines of a file as a list of Strings.-filelines :: String -> IO ([String])+filelines :: String -> IO [String] filelines x = fmap lines $ LIO.openFile x LIO.ReadMode >>= SIO.hGetContents  -- | Prompts the user for keyboard input-prompt :: String -> IO (String)+prompt :: String -> IO String prompt x = do     putStr x     LIO.hFlush LIO.stdout     getLine  -- | Returns the path of a file in the user's home directory. -inhome :: String -> LIO.IOMode -> IO (LIO.Handle)-inhome x c = fmap ((++x).(++"/")) getHomeDirectory >>= (flip LIO.openFile) c+inhome :: String -> LIO.IOMode -> IO LIO.Handle+inhome x c = fmap ((++x).(++"/")) getHomeDirectory >>= flip LIO.openFile c  -- | Pure. Returns the file name with the directory truncated. filename :: String -> String-filename = Cm.fromLast ((flip Ct.before) '/')+filename = Cm.fromLast (`Ct.before` '/')  -- | Pure. Returns the module name. That is, path to the file with the file cut off. modulename :: String -> String-modulename = Cm.fromLast ((flip Ct.after) '/')+modulename = Cm.fromLast (`Ct.after` '/')

@@ -14,7 +14,7 @@ -- | Drop a list until a predicate yields false, returning the false item and 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+removeBreak f (c:cs) = if not $ f c then c:cs else removeBreak f cs  -- | Collect a list until a predicate yields false for a value. filterBreak :: (a -> Bool) -> [a] -> [a]@@ -23,7 +23,7 @@  -- | Returns true if any element in the list yields true for a predicate. imbreak :: (a -> Bool) -> [a] -> Bool-imbreak f = or . map f+imbreak = any  -- | Conditionally transform a list. If a predicate returns true, use lval. Otherwise, use rval. btr :: (a -> Bool) -> (b,b) -> [a] -> [b]

@@ -20,7 +20,7 @@ -- | Checks to see if a list is a sub-list of the list. contains :: (Eq a) => [a] -> [a] -> Bool contains [] _ = False-contains x c = if part x == c then True else contains (tail x) c+contains x c = (part x == c) || contains (tail x) c   where part = take (length c)  -- | QuickSort implementation. Sorts a list of data quickly?@@ -33,11 +33,11 @@ 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)+pull (x:xs) c = if c == 0 then Just x else pull xs $ c - 1  -- | Referrential positioning. Find the position of an element in the first list, and return the element from the second list of the same position. In the event that the second list is shorter than the position where the element is found in the first list, it returns the parameter.  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+refpos (a,b) c = let d = pull b $ Cm.pos a c in case d of (Just x) -> x;(Nothing) -> c  -- | Test to make sure that all elements in a list are equal to a value. areAll :: (Eq a) => [a] -> a -> Bool

@@ -0,0 +1,46 @@+module Cookbook.Ingredients.Lists.Encompass where+{- |+   Module      :   Cookbook.Ingredients.Lists.Encompass+   Copyright   :   (c) 2014 by Nate Pisarski+   License     :   BSD3+   Maintainer  :   nathanpisarski@gmail.com+   Stability   :   Stable+   Portability :   Portable (Cookbook)+Encompass is a library for parsing that is stringent on scope. It supports scope monitoring on single sets of single elements in a list, but it does not need to be a string. +-}+import qualified Cookbook.Essential.Continuous as Ct++-- | 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+  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+      where+        condInp = ([y | e > 0] ++)++-- | Partial implementation of after, but working with scopes. Dangerous implementation, use with caution.+afterEncompassing :: (Eq a) => [a] -> (a,a) -> [a]+afterEncompassing a (b,c) = tail $ Ct.after a $ encompassing a (b,c)++-- | Partial implementation of before, but working with scopes. Less dangerous implementation than afterEncompassing, but still dangerous.+beforeEncompassing :: (Eq a) => [a] -> (a,a) -> [a]+beforeEncompassing a (b,c) = let temp = Ct.before a $ encompassing a (b,c) in take (length temp - 1) temp++-- | Gets all of the elements outside a given scope.+splitEncompassing :: (Eq a) => [a] -> (a,a) -> [[a]]+splitEncompassing a (b,c) = filter (\x -> x /= []) (helper a (b,c)) +  where+    helper e (f,g)+      | not $  f `elem` e && g `elem` e = [e]+      | otherwise = beforeEncompassing e (f,g) : splitEncompassing (afterEncompassing e (f,g)) (f,g)++-- | Returns all of the elements inside of a scope.+gatherEncompassing :: (Eq a) => [a] -> (a,a) -> [[a]]+gatherEncompassing a (b,c)+  | not $ b `elem` a && c `elem` a = []+  | otherwise = encompassing a (b,c) : gatherEncompassing (afterEncompassing a (b,c)) (b,c)

@@ -10,7 +10,7 @@ module Cookbook.Ingredients.Lists.Modify where  import qualified Cookbook.Essential.Common             as Cm-import qualified Cookbook.Essential.Continuous         as Cnt+import qualified Cookbook.Essential.Continuous         as Ct import qualified Cookbook.Ingredients.Functional.Break as Br import qualified Cookbook.Ingredients.Lists.Access     as Ac @@ -26,11 +26,11 @@ -- | Splits a list on an element, making a list of lists based on the element as a seperator. 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+splitOn x c = if c `notElem` x then [x] else Ct.before x c : splitOn (Ct.after x c) c  -- | Returns the data between two items. between :: (Eq a) => [a] -> (a,a) -> [a]-between a (c,d) = Cnt.after (take (last $ Cm.positions a d) a) c+between a (c,d) = Ct.after (take (last $ Cm.positions a d) a) c  -- | Implementation of between that works on a list of lists, and using Contains rather than elem. linesBetween :: (Eq a) => [[a]] -> ([a],[a]) -> [[a]]@@ -47,9 +47,12 @@  -- | Returns a list of all elements surrounded by elements. Basically a between which works more than once. 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)-+surroundedBy x (a,b) = if any (not . flip elem x) [a, b] then [] else recurse+  where recurse = Ct.before (Ct.after x a) b : surroundedBy (Ct.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.++-- [MDN2]+-- encompassingScope has been renamed to "encompassing" and moved to its own module with similar functions, Cookbook.Ingredients.Lists.Encompass

@@ -27,11 +27,11 @@ -- | Provides a mathematical score out of 1 based on the similarities between the two words. This is freqScore, but it takes into account length. wordscore :: (Eq a) => [a] -> [a] -> Double wordscore a b = (freqScore a b - 0.1) + (0.1 / realToFrac (if diffLen == 0 then 1 else diffLen))-  where diffLen = (abs $(length a) - (length b))+  where diffLen = abs $ length a - length b  -- | Provides a frequency score between two lists. freqScore :: (Eq a) => [a] -> [a] -> Double-freqScore a b =  (rawFreq / (fromIntegral diffLen))-  where diffLen = fromIntegral  $ length (if (length (frequency a)) < (length (frequency b)) then (frequency a) else (frequency b))-        rawFreq = fromIntegral ((sum $ (map (\e -> if e `elem` d then 1 else 0) c)))-        (c:d:_) = map ((flip mostFrequent) diffLen) [a,b]+freqScore a b =  rawFreq / fromIntegral diffLen+  where diffLen = fromIntegral  $ length (frequency (if length (frequency a) < length (frequency b) then a else b))+        rawFreq = fromIntegral (sum $ map (\e -> if e `elem` d then 1 else 0) c)+        (c:d:_) = map (`mostFrequent` diffLen) [a,b]

@@ -20,7 +20,7 @@  -- | Order a list of tupples by their rval, and collect the lvals as a list. assemble :: (Ord b) => [(a,b)] -> [a]-assemble = (map fst) . tupsort+assemble = map fst . tupsort  -- | Removes all double-entries from a list of tupples, contingent on just lval. rmDb :: (Eq a) =>[(a,b)] -> [(a,b)]

@@ -12,7 +12,7 @@ module Cookbook.Ingredients.Tupples.Look(look,lookList,swp,rmLook,group) where  -- | Look up an lval in a list of tupples.-look :: (Eq a) => [(a,b)] -> a -> (Maybe b)+look :: (Eq a) => [(a,b)] -> a -> Maybe b look [] _ = Nothing look (a:b) c = if fst a == c then Just (snd a) else look b c 

@@ -14,4 +14,4 @@  -- | Read the lines of a configuration file, query it, and return an answer to the query. 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) -> []+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) -> []

@@ -16,7 +16,7 @@  -- | Binds possibly multiple inputs on one line to one input. General syntax is: inp1|inp2_out makeParams :: String -> [(String,String)]-makeParams x = (flip zip) (repeat lastPart) $ Md.splitOn firstPart '|'+makeParams x = flip zip (repeat lastPart) $ Md.splitOn firstPart '|'   where (firstPart:lastPart:[]) = Md.splitOn x '_'  -- | Sanitizes the strings before parsing.@@ -26,4 +26,4 @@ -- | Generate Program Language. Generates a list of input-output pairs to be replaced. gPL :: [String] -> [(String,String)] gPL x = Cm.flt $ map makeParams sanitized-  where sanitized = Ct.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) ""

@@ -22,7 +22,7 @@  -- | Sanitizes strings for Quill processing. Removes comments, newlines, and flattens it into a string. prepare :: [String] -> String-prepare = ((flip Ct.splice) ("(*","*)")) . ((flip Sn.blacklist) ['\n']) . Cm.flt+prepare = (`Ct.splice` ("(*","*)")) . (`Sn.blacklist` "\n") . Cm.flt  -- | Splits a list into tupples. tokenize :: [a] -> [(a,a)]@@ -32,15 +32,15 @@  -- | Returns the names of all tables in the file. tblNames :: String -> [String]-tblNames x = (Ct.before x '{') : (tail $ Md.surroundedBy (Sn.blacklist x [' '])  ('}','{'))+tblNames x = Ct.before x '{' : tail (Md.surroundedBy (Sn.blacklist x " ")  ('}','{'))  -- | *Should not be used raw except for API programming. Really shouldn't be included, but too lazy to enumerate top-level declarations for selective export* Returns all entry lines from within tables in database. headlessData :: String -> [[String]]-headlessData x = map ((flip Md.splitOn) ';') $  (Md.surroundedBy x ('{','}'))+headlessData x = map (`Md.splitOn` ';') $ Md.surroundedBy x ('{','}')  -- | Returns all of the tokens from headlessData. tokenLists :: [[String]] -> [[(String,String)]]-tokenLists x =  ( map (map (\c -> (Ct.before c ':',Ct.after c ':'))) x)+tokenLists =  map (map (\c -> (Ct.before c ':',Ct.after c ':')))  -- API functions -- | Creates a listing of all tables in the file.@@ -54,7 +54,7 @@  -- | Gets the particular item within a table from a database. lookUp :: [(String,[(String,String)])] -> (String,String) -> [String]-lookUp x (c,d) = ((flip Lk.lookList) d) $ getTable x c+lookUp x (c,d) = (`Lk.lookList` d) $ getTable x c  -- | Creates a new table within the database. createTable :: [(String,[(String,String)])] -> String -> [(String,[(String,String)])]@@ -82,5 +82,5 @@  -- | Basically a toString function for Quill tables. It turns data into a String format which can be parsed by the Quill parsing stack. tableToString :: (String,[(String,String)]) -> String-tableToString (x,b) = x ++ "{" ++ (Cm.flt (map detokenize b)) ++ "}"+tableToString (x,b) = x ++ "{" ++ Cm.flt (map detokenize b) ++ "}"   where detokenize (a,b) = a ++ ":" ++ b ++ ";"

@@ -14,22 +14,23 @@ import Cookbook.Ingredients.Lists.Modify  -- | Get every node of a tree, put it into 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;+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   -- | Apply a function to every node in a tree.-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))+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  -- | Collectively nullify nodes on a tree.-treeFilter :: (Tree a) -> (a -> Bool) -> (Tree a)+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+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 list of points, with the specified null data in the snd of the tupples. genMatrix :: (Int,Int) -> a -> [((Int,Int),a)]

@@ -0,0 +1,41 @@+module Cookbook.Recipes.Cline(parse,Cline(..),clineExtract) where++import qualified  Cookbook.Essential.Continuous     as Ct+import qualified  Cookbook.Essential.Common         as Cm+import qualified  Cookbook.Ingredients.Lists.Modify as Md+import qualified  Cookbook.Ingredients.Lists.Access as Ac++{- |+   Module      :   Cookbook.Recipes.Cline+   Copyright   :   (c) 2014 by Nate Pisarski+   License     :   BSD3+   Maintainer  :   nathanpisarski@gmail.com+   Stability   :   Stable+   Portability :   Portable (Cookbook)+Cline is a library for managing strings meant to represent command-line arguments. Flags can toggle functionality in programs. Command-line arguments and their short names take an argument.+-}++-- | Represents command-line options. Works on either arguments or flags.+data Cline = Flag Char | Argument String String deriving (Show,Eq)++-- | Parses a flag argument.+singleParse y = Flag (last y)+-- | Parses an argument Cline.+doubleParse (a,b) = Argument (Ct.after a "--") b++-- | Extract arguments from a list of word-separated strings.+clineExtract :: [String] -> [Cline]+clineExtract x = case x of+  (a:b:[]) -> if Ac.count a '-' == 2 then [doubleParse (a,b)] else [singleParse a,singleParse b]+  (a:[]) -> [singleParse a]+  _ -> helper x+  +helper x+  | Ac.count w1 '-' == 1 = singleParse w1 : clineExtract (w2:r)+  | Ac.count w1 '-' == 2 = doubleParse (w1,w2) : clineExtract r+  | otherwise = clineExtract (w2:r)+  where (w1:w2:r) = x++-- | Parse a flat string into a list of Clines.+parse :: String -> [Cline]+parse =  clineExtract . (`Md.splitOn` ' ')

@@ -20,16 +20,16 @@  -- | Multiply a number by itself. sqr :: (Num a) => a -> a-sqr x = (x*x)+sqr x = x*x  -- | Find the average of a group of Fractionals.-avg :: (Fractional a) => [a] -> a-avg x = sum x / (realToFrac $ length x)+avg :: Fractional a => [a] -> a+avg x = sum x / realToFrac (length x)  -- | Find the standard deviation of a list of data. stdev :: (Fractional a, Floating a) => [a] -> a stdev x = sqrt $ diffs / realToFrac (length x)-  where diffs = sum $ [sqr $ a - avg x| a <- x]+  where diffs = sum [sqr $ a - avg x| a <- x]  -- | Factorial, from 1 to point. fact :: (Num a, Enum a) => a -> a

@@ -25,17 +25,17 @@  -- | Refpos wrapper for two lists, last to first. up :: (Eq a) => ([a],[a]) -> [a] -> [a]-up (a,b) c = map (Ac.refpos (a,b)) c+up (a,b) = map (Ac.refpos (a,b))   -- | Refpos wrapper for two lists, first to last. down :: (Eq a) => ([a],[a]) -> [a] -> [a]-down (a,b) c = map (Ac.refpos (b,a)) c+down (a,b)  = map (Ac.refpos (b,a))   -- | Removes all doubles in the list, turning them into just one occurrence. 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)+rmdb (x:y:zs) = x: rmdb (if x == y then Br.removeBreak (== x) (y:zs) else y:zs)  -- | Wholly removes doubles from a list. rmdbAll :: (Eq a) => [a] -> [a]@@ -52,8 +52,8 @@  -- | Removes all of the leading whitespace from a string. rmlws :: String -> String-rmlws = ((flip rmleading) ' ')+rmlws = (`rmleading` ' ') --- | Removes all "symbols" from a string.+-- | Removes all "symbols" from a string rmsymbols :: String -> String-rmsymbols = ((flip blacklist) (['\\'..'`']))+rmsymbols = (`blacklist` ['\\'..'`'])

@@ -3,7 +3,7 @@ -- PVP summary:      +-+------- breaking API changes --                   | | +----- non-breaking API additions --                   | | | +--- code changes with no API change-version:             2.1.2.1+version:             2.2.0.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+  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   build-depends:       base ==4.6.*, directory, strict source-repository head   type: git