diff --git a/src/Base/CompileError.hs b/src/Base/CompileError.hs
--- a/src/Base/CompileError.hs
+++ b/src/Base/CompileError.hs
@@ -27,6 +27,7 @@
 
 import Control.Monad (Monad(..))
 import Data.Foldable
+import Data.Functor
 
 #if MIN_VERSION_base(4,9,0)
 import Control.Monad.Fail
@@ -41,9 +42,9 @@
 
 -- For some GHC versions, pattern-matching failures require MonadFail.
 #if MIN_VERSION_base(4,9,0)
-class (Monad m, MonadFail m) => CompileErrorM m where
+class (Functor m, Monad m, MonadFail m) => CompileErrorM m where
 #else
-class Monad m => CompileErrorM m where
+class (Functor m, Monad m) => CompileErrorM m where
 #endif
   compileErrorM :: String -> m a
   isCompileErrorM :: m a -> Bool
diff --git a/src/Base/Mergeable.hs b/src/Base/Mergeable.hs
--- a/src/Base/Mergeable.hs
+++ b/src/Base/Mergeable.hs
@@ -27,6 +27,7 @@
 
 import Control.Monad (Monad(..))
 import Data.Foldable
+import Data.Functor
 
 
 class Mergeable a where
@@ -37,7 +38,7 @@
   mergeDefault :: a
   mergeDefault = mergeAll Nothing
 
-class Monad m => MergeableM m where
+class (Functor m, Monad m) => MergeableM m where
   mergeAnyM :: (Mergeable a, Foldable f) => f (m a) -> m a
   mergeAllM :: (Mergeable a, Foldable f) => f (m a) -> m a
   mergeNestedM :: Mergeable a => m a -> m a -> m a
diff --git a/src/Compilation/CompilerState.hs b/src/Compilation/CompilerState.hs
--- a/src/Compilation/CompilerState.hs
+++ b/src/Compilation/CompilerState.hs
@@ -63,6 +63,7 @@
 
 import Control.Monad.Trans (lift)
 import Control.Monad.Trans.State (StateT(..),execStateT,get,mapStateT,put)
+import Data.Functor
 import Data.Monoid
 import qualified Data.Set as Set
 
@@ -78,7 +79,7 @@
 
 type CompilerState a m = StateT a m
 
-class Monad m => CompilerContext c m s a | a -> c s where
+class (Functor m, Monad m) => CompilerContext c m s a | a -> c s where
   ccCurrentScope :: a -> m SymbolScope
   ccResolver :: a -> m AnyTypeResolver
   ccSameType :: a -> TypeInstance -> m Bool
diff --git a/src/Parser/Common.hs b/src/Parser/Common.hs
--- a/src/Parser/Common.hs
+++ b/src/Parser/Common.hs
@@ -100,6 +100,7 @@
 
 import Data.Char
 import Data.Foldable
+import Data.Functor
 import Data.Monoid
 import Prelude hiding (foldl,foldr)
 import Text.Parsec
@@ -328,23 +329,23 @@
          _ -> return ['\\',v]
   notEscaped = fmap (:[]) $ noneOf "\""
 
-put12 :: Monad m => m a -> m ([a],[b])
+put12 :: (Functor m, Monad m) => m a -> m ([a],[b])
 put12 = fmap put where put x = ([x],[])
 
-put22 :: Monad m => m b -> m ([a],[b])
+put22 :: (Functor m, Monad m) => m b -> m ([a],[b])
 put22 = fmap put where put x = ([],[x])
 
 merge2 :: (Foldable f, Monoid a, Monoid b) => f (a,b) -> (a,b)
 merge2 = foldr merge (mempty,mempty) where
   merge (xs1,ys1) (xs2,ys2) = (xs1<>xs2,ys1<>ys2)
 
-put13 :: Monad m => m a -> m ([a],[b],[c])
+put13 :: (Functor m, Monad m) => m a -> m ([a],[b],[c])
 put13 = fmap put where put x = ([x],[],[])
 
-put23 :: Monad m => m b -> m ([a],[b],[c])
+put23 :: (Functor m, Monad m) => m b -> m ([a],[b],[c])
 put23 = fmap put where put x = ([],[x],[])
 
-put33 :: Monad m => m c -> m ([a],[b],[c])
+put33 :: (Functor m, Monad m) => m c -> m ([a],[b],[c])
 put33 = fmap put where put x = ([],[],[x])
 
 merge3 :: (Foldable f, Monoid a, Monoid b, Monoid c) => f (a,b,c) -> (a,b,c)
diff --git a/src/Types/Positional.hs b/src/Types/Positional.hs
--- a/src/Types/Positional.hs
+++ b/src/Types/Positional.hs
@@ -25,6 +25,7 @@
 
 import Control.Monad (Monad(..))
 import Control.Monad.Trans (MonadTrans(..))
+import Data.Functor
 
 import Base.CompileError
 
diff --git a/zeolite-lang.cabal b/zeolite-lang.cabal
--- a/zeolite-lang.cabal
+++ b/zeolite-lang.cabal
@@ -1,5 +1,5 @@
 name:                zeolite-lang
-version:             0.1.2.5
+version:             0.1.2.6
 synopsis:            Zeolite is a statically-typed, general-purpose programming language.
 
 description: