diff --git a/air.cabal b/air.cabal
--- a/air.cabal
+++ b/air.cabal
@@ -1,5 +1,5 @@
 Name:                 air
-Version:              2012.5.15
+Version:              2013.6.22
 Build-type:           Simple
 Synopsis:             air
 Description:          An alternative Haskell Prelude library.
diff --git a/src/Air/Light.hs b/src/Air/Light.hs
--- a/src/Air/Light.hs
+++ b/src/Air/Light.hs
@@ -21,8 +21,11 @@
 import Control.Concurrent
 import System.Exit ( exitWith, ExitCode(ExitSuccess) )
 
+import Control.Applicative ((<$>), (<*>))
+
 import qualified Data.ByteString.Lazy.Char8 as LazyByteString
 import qualified Data.ByteString.Char8 as StrictByteString
+import Data.Maybe (listToMaybe)
 
 
 -- base DSL
@@ -61,12 +64,12 @@
 join :: [a] -> [[a]] -> [a]
 join = L.intercalate
 
-join' :: [[a]] -> [a]
-join' = concat
+at :: (Integral i) => i -> [a] -> Maybe a
+at i xs = xs.drop i.first
 
-first, second, third, forth, fifth :: (Show a) => [a] -> a
-sixth, seventh, eighth, ninth, tenth :: (Show a) => [a] -> a
-first   = head
+first, second, third, forth, fifth :: [a] -> Maybe a
+sixth, seventh, eighth, ninth, tenth :: [a] -> Maybe a
+first   = listToMaybe
 second  = at 1
 third   = at 2
 forth   = at 3
@@ -108,8 +111,8 @@
 slice :: (Integral i) => i -> i -> [a] -> [a]
 slice l r = take r > drop l
 
-cherry_pick :: (Integral i) => [i] -> [a] -> [a]
-cherry_pick ids xs  = ids.map(xs !!)
+cherry_pick :: (Integral i) => [i] -> [a] -> [Maybe a]
+cherry_pick ids xs  = ids.map(\i -> xs.at i)
 
 reduce, reduce' :: (a -> a -> a) -> [a] -> a
 reduce = L.foldl1
@@ -119,22 +122,10 @@
 inject  = flip foldl
 inject' = flip foldl'
 
-none_of :: (a -> Bool) -> [a] -> Bool
-none_of f = any f > not
-
 select, reject :: (a -> Bool) -> [a] -> [a]
 select   = filter
 reject f = filter (f > not)
 
-inner_map :: (a -> b) -> [[a]] -> [[b]]
-inner_map f = map (map f)
-
-inner_reduce :: (a -> a -> a) -> [[a]] -> [a]
-inner_reduce f = map (reduce f)
-
-inner_inject :: (Foldable t) => a -> (a -> b -> a) -> [t b] -> [a]
-inner_inject x f = map (inject x f)
-
 label_by :: (a -> c) -> [a] -> [(c, a)]
 label_by f = map (f &&& id)
 
@@ -150,11 +141,6 @@
   l = xs.length
   size = if l P.< n then 1 else l `div` n
 
-apply, send_to :: a -> (a -> b) -> b
-apply x f = f x
-send_to   = apply
-
-
 belongs_to :: (Foldable t, Eq a) => t a -> a -> Bool
 belongs_to = flip elem
 
@@ -162,7 +148,7 @@
 has = flip belongs_to
 
 indexed :: (Num t, Enum t) => [b] -> [(t, b)]
-indexed = zip([0..])
+indexed = zip [0..]
 
 ljust, rjust :: (Integral i) => i -> a -> [a] -> [a]
 rjust n x xs 
@@ -218,12 +204,20 @@
 swap :: (a, b) -> (b, a)
 swap (x,y) = (y,x)
 
-tuple2 :: (Show a) => [a] -> (a, a)
-tuple2 = first &&& last
+tuple2 :: [a] -> Maybe (a, a)
+tuple2 xs = do
+  x <- xs.first
+  y <- xs.second
+  return (x,y)
 
-tuple3 :: (Show a) => [a] -> (a, a, a)
-tuple3 xs = (xs.first, xs.second, xs.third)
+tuple3 :: (Show a) => [a] -> Maybe (a, a, a)
+tuple3 xs = do
+  x <- xs.first
+  y <- xs.second
+  z <- xs.third
+  return (x,y,z)
 
+
 list2 :: (a, a) -> [a]
 list2 (x,y) = [x,y]
 
@@ -236,12 +230,6 @@
 filter_snd :: (b -> Bool) -> [(a, b)] -> [(a, b)]
 filter_snd f = filter(snd > f)
 
-only_fst :: [(a, b)] -> [a]
-only_fst = map fst
-
-only_snd :: [(a, b)] -> [b]
-only_snd = map snd
-
 map_fst :: (a -> b) -> [(a, c)] -> [(b, c)]
 map_fst f = map(\(a,b) -> (f a, b))
 
@@ -254,8 +242,8 @@
 splat3 :: (a -> b -> c -> d) -> (a, b, c) -> d
 splat3 f (a,b,c) = f a b c
 
-twin :: a -> (a, a)
-twin x = (x,x)
+clone :: a -> (a, a)
+clone x = (x,x)
 
 -- Integer
 from_i :: (Integral a, Num b) => a -> b
@@ -283,14 +271,7 @@
 trace' :: (Show a) => a -> a
 trace' x = trace (x.show) x
 
-
-
 -- New from Lab
-at :: (Show a, Integral i, Show i) => i -> [a] -> a
-at i xs = if i P.< xs.length
-  then xs !! i
-  else error - show xs ++ " at " ++ show i ++ " failed"
-
 void :: (Monad m) => m a -> m ()
 void x = x >>= const () > return
 
@@ -315,8 +296,8 @@
 replicate :: Integral i => i -> a -> [a]
 replicate = L.genericReplicate
 
-(!!) :: Integral a => [b] -> a -> b
-(!!) = index
+(!!) :: Integral a => [b] -> a -> Maybe b
+(!!) = flip at
 
 to_f :: (Real a, Fractional b) => a -> b
 to_f = realToFrac 
@@ -324,15 +305,9 @@
 sleep :: (RealFrac a) => a -> IO ()
 sleep x = threadDelay - round - (x * 1000000)
 
-first_or :: a -> [a] -> a
-first_or x xs = case xs of
-  [] -> x
-  (y:_) -> y
-
 puts :: String -> IO ()
 puts = putStrLn
 
-
 exit_success :: IO ()
 exit_success = exitWith ExitSuccess
 
@@ -342,9 +317,6 @@
 insert_unique :: (Eq a) => a -> [a] -> [a]
 insert_unique x xs = x : xs.reject (is x)
 
-squeeze :: (Monad m) => m (m a) -> m a
-squeeze = Monad.join
-
 end :: (Monad m) => m ()
 end = return ()
 
@@ -356,3 +328,12 @@
 
 s2l :: StrictByteString.ByteString -> LazyByteString.ByteString
 s2l x = LazyByteString.fromChunks [x]
+
+ap2 f x1 z                      = f <$> x1 <*> z 
+ap3 f x1 x2 z                   = ap2 f x1 x2 <*> z
+ap4 f x1 x2 x3 z                = ap3 f x1 x2 x3 <*> z
+ap5 f x1 x2 x3 x4 z             = ap4 f x1 x2 x3 x4 <*> z
+ap6 f x1 x2 x3 x4 x5 z          = ap5 f x1 x2 x3 x4 x5 <*> z
+ap7 f x1 x2 x3 x4 x5 x6 z       = ap6 f x1 x2 x3 x4 x5 x6 <*> z
+ap8 f x1 x2 x3 x4 x5 x6 x7 z    = ap7 f x1 x2 x3 x4 x5 x6 x7 <*> z
+ap9 f x1 x2 x3 x4 x5 x6 x7 x8 z = ap8 f x1 x2 x3 x4 x5 x6 x7 x8 <*> z
diff --git a/src/Air/SimpleMath.hs b/src/Air/SimpleMath.hs
--- a/src/Air/SimpleMath.hs
+++ b/src/Air/SimpleMath.hs
@@ -15,13 +15,6 @@
   ]
   where l = xs.length
 
-
-encode :: (Eq a) => [a] -> [(Int, a)]
-encode xs = xs.L.group.map (length &&& head)
-
-decode :: [(Int, a)] -> [a]
-decode xs = xs.map(\(l,x) -> l.times x).join'
-
 hist :: (Num e, A.Ix i) =>  (i, i) -> [i] -> A.Array i e
 hist bnds ns = A.accumArray (+) 0 bnds [(n, 1) | n <- ns, A.inRange bnds n]