diff --git a/Useful.cabal b/Useful.cabal
--- a/Useful.cabal
+++ b/Useful.cabal
@@ -1,5 +1,5 @@
 Name:		Useful
-Version:	0.0.3
+Version:	0.0.5
 Cabal-Version:  >= 1.2
 License:	BSD3
 Author:		Daniel Holden
diff --git a/Useful.hs b/Useful.hs
--- a/Useful.hs
+++ b/Useful.hs
@@ -1,18 +1,21 @@
 {- |
 		   
-These are a selection of useful haskell functions which I've written.
+These are a selection of useful haskell functions which I've written to speed general programming.
 
+Several people suggested I re-name this module \"Useless\" and I can see where they are coming from. Don't expect any of this code to save the world. Lots of it is largely redundant (alises, small functions) and based on personal preference, but don't tell me there is never a time you've written "!=" by mistake instead of "/=", or thought things would be easier if you could set up a quick dictionary, or anything else like this.
 It is split into 5 sections so as to allow you to import just one if you think the whole lot will clutter up the namepsace.
 
 	* "Useful.General" 		- General shorthands and the most commonly used.
 	
 	* "Useful.Dictionary"	- A lightweight dictionary implementation using Data.Map
 	
-	* "Useful.List"			- Some general purpose list functions which are missing from Data.List as well as some other shorthands/aliases
-	
-	* "Useful.String"		- A few string only functions which don't make sense over just lists
+	* "Useful.List"			- Some general purpose list functions
 	
+	* "Useful.String"		- A few string functions which don't make sense over all lists
+
 	* "Useful.IO"			- Some shorthand and general purpose IO functions
+
+For any issues or queries with the code you can contact me at contact@theorangeduck.com
 	
 -}
 module Useful(module Useful.General, module Useful.Dictionary, module Useful.List, module Useful.String, module Useful.IO) where
diff --git a/Useful/Dictionary.hs b/Useful/Dictionary.hs
--- a/Useful/Dictionary.hs
+++ b/Useful/Dictionary.hs
@@ -1,8 +1,9 @@
 -- | A lightweight Dictionary implementation based on Data.Map, part of the "Useful" module.
 --
--- So I kinda like dictionaries, but the functions and syntax by default are hardly as elegant as something like python.
--- This isn't a complete solution and nor is it optimal but it's pretty lightweight and pretty and stuff. You get it.
--- It's based off Data.Map so uses a binary tree and therefore the keys have to have some ordering defined over them.
+-- I like dictionaries, and use them often for small things when I'm coding, but the functions and syntax by default are hardly as elegant as something like python. This is one thing I feel is missing in the default implementation of data types. Also, the clashing namespace when importing Data.Map makes code often hard to read and long. Completely inconvenient for small, simple tasks.
+-- This isn't a complete solution and nor is it optimal but it's lightweight and pretty.
+-- Keys must have some ordering defined over them.
+-- In the function descriptions, listed in square brackets are the Data.Map functions used - this does not mean it is an exact alias though, it make just use it.
 module Useful.Dictionary where
 
 import qualified Data.Map
@@ -23,46 +24,49 @@
 dictToList :: Data.Map.Map k a -> [(k, a)]
 dictToList d = Data.Map.toList d
 
+-- | Returns the size of a dictionary [Data.Map.size]
+dictSize :: Data.Map.Map k a -> Int
+dictSize d = Data.Map.size d
 
 -- * Dictionary operations
 
--- | Returns Maybe v from key k
+-- | Returns Maybe v from key k [Data.Map.lookup]
 (#!) :: (Ord k) => k -> Data.Map.Map k a -> Maybe a
 (#!) d k = Data.Map.lookup d k
 
--- | Returns v from key k or error.
+-- | Returns v from key k or error [Data.Map.!]
 (#!!) :: (Ord k) => Data.Map.Map k a -> k -> a
 (#!!) d k = (Data.Map.!) d k
 
--- | adds key-value pair to a dictionary. If key is already in dict will update value.
+-- | Adds key-value pair to a dictionary. If key is already in dict will update value. [Data.Map.insert]
 (#+) :: (Ord k) => Data.Map.Map k a -> (k,a) -> Data.Map.Map k a
 (#+) d (k,v) = Data.Map.insert k v d
 
--- | checks for a key in a dictionary.
+-- | Checks for a key in a dictionary. [Data.Map.member]
 (#?) :: (Ord k) => Data.Map.Map k a -> k -> Bool
 (#?) d k = Data.Map.member k d
 
--- | checks if a value is in a dictionary
+-- | Checks if a value is in a dictionary
 (#*?) :: (Eq a, Ord k) => Data.Map.Map k a -> a -> Bool
 (#*?) d v = (Data.Map.keys (Data.Map.filter (==v) d)) /= []
 
--- | Deletes a key-pair from a dictionary given a key
+-- | Deletes a key-pair from a dictionary given a key [Data.Map.delete]
 (#-) :: (Ord k) => Data.Map.Map k a -> k -> Data.Map.Map k a
 (#-) d k = Data.Map.delete k d
 
--- | Deletes ALL key-pairs from a dictionary given they match a value
+-- | Deletes ALL key-pairs from a dictionary given they match a value [Data.Map.filter]
 (#*-) :: (Eq a, Ord k) => Data.Map.Map k a -> a -> Data.Map.Map k a
 (#*-) d v = Data.Map.filter (/=v) d
 
--- | Intersects two dictionaries
+-- | Intersects two dictionaries [Data.Map.\\]
 (#\\) :: (Ord k) => Data.Map.Map k a -> Data.Map.Map k b -> Data.Map.Map k a
 (#\\) d1 d2 = (Data.Map.\\) d1 d2
 
--- | Unions two dictionaries
+-- | Unions two dictionaries [Data.Map.union]
 (#++) :: (Ord k) => Data.Map.Map k a -> Data.Map.Map k a -> Data.Map.Map k a
 (#++) d1 d2 = Data.Map.union d1 d2
 
--- | Tests if d1 is a sub-dictionary of d2
+-- | Tests if d1 is a sub-dictionary of d2 [Data.Map.isSubmapOf]
 (#??) :: (Ord k, Eq a) => Data.Map.Map k a -> Data.Map.Map k a -> Bool
 (#??) d1 d2 = Data.Map.isSubmapOf d1 d2
 
@@ -72,22 +76,20 @@
 	|(Data.Map.filter (==v) d) == Data.Map.empty = error "value is not in dictionary"
 	|otherwise = head (Data.Map.keys (Data.Map.filter (==v) d))
 
--- | Returns the size of a dictionary
-dictSize :: Data.Map.Map k a -> Int
-dictSize d = Data.Map.size d
+-- * Dictionary mapping and filtering
 
--- | Data.Maps a function to all values in a dictionary
+-- | Maps a function to all values in a dictionary [Data.Map.map]
 mapD :: (a -> b) -> Data.Map.Map k a -> Data.Map.Map k b
 mapD func d = Data.Map.map func d
 
--- | Data.Maps a function to all keys in a dictionary
+-- | Maps a function to all keys in a dictionary [Data.Map.mapKeys]
 mapDkeys :: (Ord k2) => (k1 -> k2) -> Data.Map.Map k1 a -> Data.Map.Map k2 a
 mapDkeys func d = Data.Map.mapKeys func d
 
--- | filter on a dincationy, you get the idea
+-- | Filter over dictionary values [Data.Map.filter]
 filterD :: (Ord k) => (a -> Bool) -> Data.Map.Map k a -> Data.Map.Map k a
 filterD func d = Data.Map.filter func d
 
--- | filter for keys
+-- | Filter over keys in a dictionary [Data.Map.filterWithKey]
 filterDkeys :: (Ord k) => (k -> a -> Bool) -> Data.Map.Map k a -> Data.Map.Map k a
 filterDkeys func d = Data.Map.filterWithKey func d
diff --git a/Useful/General.hs b/Useful/General.hs
--- a/Useful/General.hs
+++ b/Useful/General.hs
@@ -9,6 +9,7 @@
 
 
 -- | Alias of mod
+(%) :: (Integral a) => a -> a -> a
 (%) = mod
 
 
@@ -34,9 +35,9 @@
 (??) = isInfixOf
 
 
--- | Returns the index of the first occurance of an item if it is in a list. Otherwise gives an error. Also remember, starts counting from 0!
+-- | Returns the index of the first occurance of an item if it is in a list. Otherwise gives an error. Starts counting from 0!
 --
--- NOTE: This is not like elemIndex! It does not return a Maybe Int it returns an error if the item is not in a list. Either use elemIndex or test using ? first. THIS FUNCTION IS NOT COMPLETE.
+-- NOTE: This is not like elemIndex! It does not return a Maybe Int it returns an error if the item is not in a list. Either use elemIndex or test using ? first.
 -- 
 -- > $ 'n' ?! "banana"
 -- > 2
@@ -79,12 +80,13 @@
 -- | alias of length
 len :: [a] -> Int
 len = length
+
 -- | alias of length
 count :: [a] -> Int
 count = length
 
 
--- | Simple function that takes the unit list and returns the unit
+-- | Takes the unit list and returns the unit
 --
 -- NOTE: Will return an error if not supplied with the unit list
 -- 
diff --git a/Useful/IO.hs b/Useful/IO.hs
--- a/Useful/IO.hs
+++ b/Useful/IO.hs
@@ -56,7 +56,7 @@
 putln :: (Show a) => a -> IO ()
 putln = print
 
--- maps an IO function in depth N to the given list. Also versions without _ for storing of the returns.
+-- | maps an IO function in depth N to the given list. Also versions without _ for storing of the returns.
 --
 -- Again there are also mapM_3, mapM_4 and mapM_5 defined (as well as versions without underscores)
 -- 
diff --git a/Useful/List.hs b/Useful/List.hs
--- a/Useful/List.hs
+++ b/Useful/List.hs
@@ -1,4 +1,4 @@
--- | Useful List operations, part of the "Useful" module.
+-- | List operations, part of the "Useful" module.
 module Useful.List where
 
 import Useful.General
@@ -9,7 +9,7 @@
 -- > $ explodeI "Hello there people" ' '
 -- > ["Hello","there","people"]
 explodeI :: Eq a => [a] -> a -> [[a]]
-explodeI xs m = rmEmptyList (explode' xs m)
+explodeI xs m = rmEmpty (explode' xs m)
 
 -- explode' :: Eq a => [a] -> a -> [[a]]
 explode' [] m = []
@@ -39,7 +39,10 @@
 
 -- | Takes a two lists and explodes the first into a new list, around the second. Removing the second list where it occurs.
 --
--- THIS NEEDS FIXING
+-- > $explode "hello there people" "ll"
+-- > ["he","o there people"]
+-- > $explode "hello there people" " "
+-- > ["hello","there","people"]
 explode :: Eq a => [a] -> [a] -> [[a]]
 explode x y = explode'' x y 0 0
 
@@ -48,10 +51,11 @@
 	|x == y  = []
 	|x == [] = []
 	|y == [] = [x]
-	|buff == len y = (takeBefore buff (fst splut)) : ( explode'' (snd splut) y 0 0) -- If the buffer is full (match found). Then split and remove match from fst, cons onto the explode'' of the second part.
-	|((x !! count) ? y) = explode'' x y (((x !! count) ?! y )+1) (count+1) -- is x !! count in y? If so then find at which position and explode'' with that +1 as the new buffer.
-	|otherwise = explode'' x y 0 (count+1) -- otherwise increment the counter.
-		where splut = (splitAt count x)
+	|count+buff == len x = [x]
+	|(len y) == buff = (fst splut) : (explode'' (drop buff (snd splut)) y 0 0) -- If the buffer is full (there is a full match) then split the string and explode the rest.
+	|(x !! (count+buff)) == (y !! buff) = explode'' x y (buff+1) count -- If the character matches increase the buffer
+	|otherwise = explode'' x y 0 (count+1) -- otherwise just increment the counter.
+		where splut = (splitAt (count) x)
 
 -- | alias of explode
 split :: Eq a => [a] -> [a] -> [[a]]
@@ -72,56 +76,32 @@
 join :: Eq a => [[a]] -> [a] -> [a]
 join = implode
 
-
--- | takes n number of items from the front of a list, alias of take
---
--- > $ takeFor 5 "Hello there people"
--- > "Hello"
-takeFor :: Eq a => Int -> [a] -> [a]
-takeFor n x = takeFor' n x 0
-
-takeFor' n (x:xs) c
-	|xs == [] = x: []
-	|c == n = []
-	|otherwise = x : takeFor' n xs (c+1)
-
 	
--- | drops n number of items from the front of a list, alias of drop
---
--- > $ dropFor 5 "Hello there people"
--- > " there people"
-dropFor :: Eq a => Int -> [a] -> [a]
-dropFor n x = dropFor' n x 0
-
-dropFor' n (x:xs) c
-	|(xs == []) && (c <= n) = []
-	|(xs == []) && (c > n) = (x:xs)
-	|c < n = [] ++ dropFor' n xs (c+1)
-	|otherwise = x : dropFor' n xs (c+1)
-
-	
 -- | takes a number of items from a list before it reaches the index n
 -- 
 -- > $ takeBefore 5 "Hello there people"
 -- > "Hello there p"
-takeBefore :: Eq a => Int -> [a] -> [a]
-takeBefore n x = takeFor' (len x - n) x 0
+-- takeBefore :: Eq a => Int -> [a] -> [a]
+-- takeBefore n x = take (len x - n) x 0
 
 
 -- | drops a number of items from a list before it reaches the index n
 --
 -- > $ dropBefore 5 "Hello there people"
 -- > "eople"
-dropBefore :: Eq a => Int -> [a] -> [a]
-dropBefore n x = dropFor' (len x - n) x 0
+-- dropBefore :: Eq a => Int -> [a] -> [a]
+-- dropBefore n x = drop (len x - n) x 0
 
 
 -- | In a list of lists this removes any occurances of the empty list. Can also be used to remove occurances of the empty string.
-rmEmptyList :: Eq a =>  [[a]] -> [[a]]
-rmEmptyList [] = []
-rmEmptyList (x:xs)
-	|x == [] = rmEmptyList xs
-	|otherwise = x:(rmEmptyList xs)
+--
+-- > $rmEmpty ["hello","","there","","people",""]
+-- > ["hello","there","people"]
+rmEmpty :: Eq a =>  [[a]] -> [[a]]
+rmEmpty [] = []
+rmEmpty (x:xs)
+	|x == [] = rmEmpty xs
+	|otherwise = x:(rmEmpty xs)
 
 
 -- | maps a function in depth N to the given list. map3, map4, map5 are also defined.
@@ -130,11 +110,17 @@
 -- > [[2,4,6,8],[2,2,2,4]]
 map2 :: (a -> b) -> [[a]] -> [[b]]
 map2 f x = map (map f) x
+
+map3 :: (a -> b) -> [[[a]]] -> [[[b]]]
 map3 f x = map (map (map f)) x
+
+map4 :: (a -> b) -> [[[[a]]]] -> [[[[b]]]]
 map4 f x = map (map (map (map f))) x
+
+map5 :: (a -> b) -> [[[[[a]]]]] -> [[[[[b]]]]]
 map5 f x = map (map (map (map (map f)))) x
 
--- | Replaces any occuranses of the second list, with the third list, in the first list.
+-- | Replaces any occurrences of the second list, with the third list, in the first list.
 --
 -- > $ replace "why hello hello there" "hello" "bonjour"
 -- > "why bonjour bonjour there"
diff --git a/Useful/String.hs b/Useful/String.hs
--- a/Useful/String.hs
+++ b/Useful/String.hs
@@ -5,19 +5,19 @@
 
 -- | Strips whitespace from either side of a string.
 --
--- > $ strip "   asdsadasds   \r\n" \n
+-- > $ strip " \v\r  asdsadasds   \r\n"
 -- > "asdsadasds"	
 strip :: String -> String
 strip = stripr . stripl
 
 -- | Strips whitespace from the right of a string
 --
--- > $ stripr "  asdioamlksd   \n\n" \n
+-- > $ stripr "  asdioamlksd   \n\n"
 -- > "  asdioamlksd"
 stripr :: String -> String
 stripr [] = []
 stripr x
-	|(last x) ? stripset = stripr (init x)
+	|(last x) ? whiteSpaceChars = stripr (init x)
 	|otherwise = x
 
 -- | Strips whitespace from the left of a string
@@ -27,7 +27,7 @@
 stripl :: String -> String
 stripl [] = []
 stripl (x:xs)
-	|x ? stripset = stripl xs
+	|x ? whiteSpaceChars = stripl xs
 	|otherwise = (x:xs)
 
 -- | Alias of 'strip'
@@ -36,7 +36,7 @@
 
 -- | List of whitespace characters: 
 --
--- > [' ','\r','\n','\t']
-stripset :: [Char]
-stripset = [' ','\r','\n','\t']
-	
+-- > $whiteSpaceChars
+-- > [' ','\r','\n','\t','\f','\v']
+whiteSpaceChars :: [Char]
+whiteSpaceChars = [' ','\r','\n','\t','\f','\v']