diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Infernu
 
-Static type inference for JavaScript.
+Static type inference for JavaScript. (In early development.)
 
 See the [intro blog post](https://noamlewis.wordpress.com/2015/01/20/introducing-sjs-a-type-inferer-and-checker-for-javascript/) for a short discussion comparing infernu to **other type checkers**.
 
diff --git a/infernu.cabal b/infernu.cabal
--- a/infernu.cabal
+++ b/infernu.cabal
@@ -1,5 +1,5 @@
 name:                infernu
-version:             0.0.0.0
+version:             0.0.0.1
 synopsis:            Type inference and checker for JavaScript (experimental)
 description:         This version is highly experimental and may set your computer on fire (also, a lot of JS is not supported yet, so it may not be very useful.)
                      .
@@ -65,12 +65,13 @@
                      , Infernu.Log
                      , Infernu.Options
                      , Infernu.Parse
+                     , Infernu.Prelude
                      , Infernu.Pretty
                      , Infernu.Types
                      , Infernu.Unify
                      , Infernu.Util
   -- TODO: use only mtl (not transformers)
-  build-depends:       base >= 4.8 && < 5, mtl, containers, transformers, either, language-ecmascript, digits, parsec, fgl, optparse-applicative
+  build-depends:       base >= 4.6 && < 5, mtl, containers, transformers, either, language-ecmascript, digits, parsec, fgl, optparse-applicative
   default-language:    Haskell2010
   ghc-options: -Wall -O2 -rtsopts -threaded
   if flag(debug)
diff --git a/src/Infernu/Decycle.hs b/src/Infernu/Decycle.hs
--- a/src/Infernu/Decycle.hs
+++ b/src/Infernu/Decycle.hs
@@ -4,6 +4,7 @@
 
 module Infernu.Decycle(decycleOn, decycle, decycle2, decycle3) where
 
+import Infernu.Prelude
 import qualified Data.Set as Set
 
 -- | A fix for functions that terminates recursive cycles
diff --git a/src/Infernu/Infer.hs b/src/Infernu/Infer.hs
--- a/src/Infernu/Infer.hs
+++ b/src/Infernu/Infer.hs
@@ -15,8 +15,6 @@
 
 
 import           Control.Monad      (foldM, forM)
-import           Data.Foldable      (Foldable (..))
-import           Data.Traversable   (mapM)
 import qualified Data.Graph.Inductive as Graph
 import           Data.Map.Lazy      (Map)
 import qualified Data.Map.Lazy      as Map
@@ -27,6 +25,7 @@
 
 import           Data.List          (intercalate)
 
+import           Infernu.Prelude
 import qualified Infernu.Builtins.Operators   as Operators
 import           Infernu.InferState
 import           Infernu.Lib        (safeLookup)
diff --git a/src/Infernu/InferState.hs b/src/Infernu/InferState.hs
--- a/src/Infernu/InferState.hs
+++ b/src/Infernu/InferState.hs
@@ -5,14 +5,14 @@
 module Infernu.InferState
        where
 
+import           Data.Foldable              (msum)
 import           Control.Monad              (foldM, forM, forM_, liftM2, when)
 import           Control.Monad.Trans        (lift)
 import           Control.Monad.Trans.Either (EitherT (..), left, runEitherT, bimapEitherT)
 import           Control.Monad.Trans.State  (StateT (..), evalStateT, get, put, modify, mapStateT)
-import           Data.Foldable              (Foldable (..), msum)
-import           Data.Traversable              (Traversable (..))
 import qualified Data.Graph.Inductive      as Graph
     
+
 import           Data.Functor.Identity      (Identity (..), runIdentity)
 import qualified Data.Map.Lazy              as Map
 -- import           Data.Map.Lazy              (Map)
@@ -22,7 +22,7 @@
 import           Prelude                    hiding (foldr, sequence, mapM)
 
 
-
+import           Infernu.Prelude
 import           Infernu.Pretty
 import           Infernu.Types
 import           Infernu.Log
diff --git a/src/Infernu/Log.hs b/src/Infernu/Log.hs
--- a/src/Infernu/Log.hs
+++ b/src/Infernu/Log.hs
@@ -6,6 +6,7 @@
        (trace, tracePretty, traceLog, traceLogVal)
        where
 
+import           Infernu.Prelude
 import           Infernu.Pretty
 
 
diff --git a/src/Infernu/Prelude.hs b/src/Infernu/Prelude.hs
new file mode 100644
--- /dev/null
+++ b/src/Infernu/Prelude.hs
@@ -0,0 +1,50 @@
+{-# LANGUAGE CPP #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+-- | The sole purpose of this module is to fix pre/post ghc 7.10 compatibility issues
+module Infernu.Prelude 
+  ( module Prelude
+#if MIN_VERSION_base(4,8,0)
+#else
+  , module Data.Functor
+  , module Data.Foldable
+  , module Data.Monoid
+  , module Control.Applicative
+  , module Data.Traversable
+#endif
+#if MIN_VERSION_base(4,7,0)
+  , module Data.Bool
+#else
+  , bool
+#endif
+  )
+where
+
+ 
+#if MIN_VERSION_base(4,8,0)
+import Prelude
+#else
+import Data.Functor ((<$>))
+import Data.Foldable         (Foldable (..), foldr)
+import Data.Monoid           (Monoid (..))
+import Control.Applicative   (Applicative(..))
+import Data.Traversable      (Traversable (..))
+
+import Prelude hiding (foldl, foldl1, foldr1, foldr, mapM, sequence)
+#endif
+    
+#if MIN_VERSION_base(4,7,0)
+import Data.Bool (bool)
+#else
+
+instance Foldable ((,) a) where
+    foldMap f (_, y) = f y
+
+    foldr f z (_, y) = f y z
+
+bool :: a -> a -> Bool -> a
+bool f _ False = f
+bool _ t True  = t
+
+#endif
+
diff --git a/src/Infernu/Pretty.hs b/src/Infernu/Pretty.hs
--- a/src/Infernu/Pretty.hs
+++ b/src/Infernu/Pretty.hs
@@ -140,7 +140,7 @@
                 [] -> (Nothing, nakedSingleOrTuple nonThisArgs)
                 (this_:_) -> (Just this_, nakedSingleOrTuple nonThisArgs)
         wrapThis Nothing s = s
-        wrapThis (Just (Fix (TBody TUndefined))) s = s
+        wrapThis (Just (Fix (TBody TUndefined))) s = s -- undefined as a function's parameter type (including 'this') is allowed to unify with any input parameter.
         wrapThis (Just t) s = prettyTab n t ++ "." ++ s
 -- prettyTab _ (TCons TFunc ts) = error $ "Malformed TFunc: " ++ intercalate ", " (map pretty ts)
 prettyType n (TCons TArray [t]) = "[" ++ prettyTab n t ++ "]"
diff --git a/src/Infernu/Types.hs b/src/Infernu/Types.hs
--- a/src/Infernu/Types.hs
+++ b/src/Infernu/Types.hs
@@ -59,15 +59,15 @@
 #endif
        ) where
 
-import           Data.Foldable             (Foldable (..), foldr)
 import qualified Data.Map.Lazy             as Map
 import           Data.Maybe                (fromMaybe)
 import qualified Data.Set                  as Set
 import qualified Data.Graph.Inductive      as Graph
-import           Prelude                   hiding (foldr)
 import qualified Text.Parsec.Pos           as Pos
 
 import           Infernu.Fix               (Fix (..), replaceFix)
+import           Infernu.Prelude
+import Prelude ()
 
 #ifdef QUICKCHECK
 import           Data.DeriveTH
diff --git a/src/Infernu/Unify.hs b/src/Infernu/Unify.hs
--- a/src/Infernu/Unify.hs
+++ b/src/Infernu/Unify.hs
@@ -16,7 +16,10 @@
 
 import           Data.Set             (Set)
 import qualified Data.Set             as Set
+import           Prelude              hiding (foldl, foldr, mapM, sequence)
 
+
+import           Infernu.Prelude
 import           Infernu.Builtins.Array (arrayRowType)
 import           Infernu.Builtins.Regex (regexRowType)
 import           Infernu.Builtins.String (stringRowType)
@@ -210,8 +213,8 @@
 unify' _ a (TBody (TVar n)) t = varBind a n (Fix t)
 unify' _ a t (TBody (TVar n)) = varBind a n (Fix t)
 
--- | undefined
-unify' _ _ (TBody TUndefined) _ = return () -- TODO verify this is ok. undefined being treated as "bottom" type here.
+-- -- | undefined
+-- unify' _ _ (TBody TUndefined) _ = return () -- TODO verify this is ok. undefined being treated as "bottom" type here.
 
 -- | Two simple types
 unify' _ a (TBody x) (TBody y) = unlessEq x y $ unificationError a x y
@@ -260,12 +263,22 @@
         Just ts -> unifyl recurse a ts
 
 -- | Two functions
--- TODO: handle func return type (contravariance) by swapping the unify rhs/lhs for the last TCons TFunc targ
 unify' recurse a t1@(TFunc ts1 tres1) t2@(TFunc ts2 tres2) =
     case matchZip ts1 ts2 of
         Nothing -> unificationError a t1 t2
-        Just ts -> do  unifyl recurse a ts
+        Just ts -> do  loop' ts
                        recurse a tres2 tres1
+
+            where loop' [] = return ()
+                  -- This allows passing any value as a function's argument which should have type
+                  -- 'undefined' added to deal with 'this' being inferred to be 'undefined' if a
+                  -- function is ever called without a 'this'.  allows us to call standalone
+                  -- functions even when as a method dispatch (obj.f) that DOES pass a non-undefined
+                  -- 'this'.
+                  loop' ((Fix (TBody TUndefined), _):ts') = loop' ts'
+                  loop' ((x,y):ts') =
+                      do  recurse a x y
+                          loop' ts'
      
 -- | Type constructor vs. row type
 unify' r a (TRow tRowList) t2@(TCons _ _)  = unifyTryMakeRow r a True  tRowList t2
diff --git a/src/Infernu/Util.hs b/src/Infernu/Util.hs
--- a/src/Infernu/Util.hs
+++ b/src/Infernu/Util.hs
@@ -10,6 +10,7 @@
 import qualified Language.ECMAScript3.Syntax as ES3
 import qualified Text.Parsec.Pos             as Pos
 
+import           Infernu.Prelude
 import           Infernu.Options             (Options(..))
 import           Infernu.Parse               (translate)
 -- TODO move pretty stuff to Pretty module
diff --git a/test/Demo.hs b/test/Demo.hs
--- a/test/Demo.hs
+++ b/test/Demo.hs
@@ -1,10 +1,12 @@
 module Demo where
 
-import           Data.Bool          (bool)
 import           Data.List          (intercalate)
+
 import           Infernu.Infer      (pretty)
 import           Infernu.Util       (checkFiles)
 import           Infernu.Options    (defaultOptions)
+import           Infernu.Prelude
+    
 import           System.Environment (getArgs)
 
 isRight :: Either a b -> Bool