diff --git a/Control/CP/FD/Interface.hs b/Control/CP/FD/Interface.hs
--- a/Control/CP/FD/Interface.hs
+++ b/Control/CP/FD/Interface.hs
@@ -42,7 +42,7 @@
 --  Modelable,
 ) where
 
-import Control.CP.FD.FD hiding (allDiff)
+import Control.CP.FD.FD (FDSolver, FDInstance, FDIntTerm, getColItems)
 import qualified Control.CP.FD.Model as Model
 import Control.CP.FD.Model (Model, ModelBool, ModelCol, ModelInt, ToModelBool, asBool, asExpr, asCol, cte, newModelTerm, ModelIntArg, ModelBoolArg, ModelColArg)
 import qualified Data.Expr.Sugar as Sugar
@@ -144,7 +144,7 @@
 (@<=) a b = addM $ (Sugar.@<=) a b
 
 val :: Tree DummySolver () -> ModelInt
-val = toExpr . treeToModel
+val = Sugar.toExpr . treeToModel
 
 {- newBool :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s) => (ModelBool -> Tree DummySolver a) -> m a
 newBool = exists
@@ -207,7 +207,7 @@
 
 infix 5 @:
 
-(@:) :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s, ExprRange ModelIntArg ModelColArg ModelBoolArg r, Term s ModelInt, Term s ModelBool, Term s ModelCol) => ModelInt -> r -> m ()
+(@:) :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s, Sugar.ExprRange ModelIntArg ModelColArg ModelBoolArg r, Term s ModelInt, Term s ModelBool, Term s ModelCol) => ModelInt -> r -> m ()
 a @: b = addM $ (Sugar.@:) a b
 
 infix 4 @?
@@ -216,5 +216,5 @@
 a @? (t,f) = (Sugar.@?) (treeToModel a) (t,f)
 a @?? (t,f) = addM $ (Sugar.@??) (treeToModel a) (treeToModel t, treeToModel f)
 
-allin :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s, ExprRange ModelIntArg ModelColArg ModelBoolArg r, Term s ModelInt, Term s ModelBool, Term s ModelCol) => ModelCol -> r -> m ()
+allin :: (Constraint s ~ Either Model q, MonadTree m, TreeSolver m ~ s, Sugar.ExprRange ModelIntArg ModelColArg ModelBoolArg r, Term s ModelInt, Term s ModelBool, Term s ModelCol) => ModelCol -> r -> m ()
 allin c b = Control.CP.FD.Interface.forall c $ \x -> addM $ (Sugar.@:) x b
diff --git a/Control/Monatron/Open.hs b/Control/Monatron/Open.hs
--- a/Control/Monatron/Open.hs
+++ b/Control/Monatron/Open.hs
@@ -1,4 +1,10 @@
-{-# OPTIONS -fglasgow-exts -XNoMonomorphismRestriction -XOverlappingInstances #-}
+-- {-# OPTIONS -fglasgow-exts -XNoMonomorphismRestriction -XOverlappingInstances #-}
+
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE OverlappingInstances #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 module Control.Monatron.Open where
 
diff --git a/Control/Monatron/Transformer.hs b/Control/Monatron/Transformer.hs
--- a/Control/Monatron/Transformer.hs
+++ b/Control/Monatron/Transformer.hs
@@ -17,7 +17,7 @@
 import Control.Monad.Fix
 import Control.Monatron.MonadT
 -- for Writer
-import Data.Monoid
+import Data.Monoid hiding ((<>))
 -- for Error (and Reader?)
 --import Monatron.Codensity
 import Control.Monatron.AutoInstances()
diff --git a/Control/Monatron/Zipper.hs b/Control/Monatron/Zipper.hs
--- a/Control/Monatron/Zipper.hs
+++ b/Control/Monatron/Zipper.hs
@@ -1,4 +1,9 @@
-{-# OPTIONS -fglasgow-exts -XNoMonomorphismRestriction #-}
+-- {-# OPTIONS -fglasgow-exts -XNoMonomorphismRestriction #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE OverlappingInstances #-}
diff --git a/Control/Search/Language.hs b/Control/Search/Language.hs
--- a/Control/Search/Language.hs
+++ b/Control/Search/Language.hs
@@ -3,7 +3,7 @@
 module Control.Search.Language  where 
 
 import Text.PrettyPrint
-import Data.Monoid
+import Data.Monoid hiding ((<>))
 import Data.Int
 import qualified Data.Map as Map
 import Data.Map (Map)
diff --git a/Control/Search/SStateT.hs b/Control/Search/SStateT.hs
--- a/Control/Search/SStateT.hs
+++ b/Control/Search/SStateT.hs
@@ -1,4 +1,7 @@
-{-# OPTIONS -fglasgow-exts #-}
+-- {-# OPTIONS -fglasgow-exts #-}
+
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
 
 module Control.Search.SStateT (
   SStateT, sstateT, runSStateT,
diff --git a/Data/Expr/Sugar.hs b/Data/Expr/Sugar.hs
--- a/Data/Expr/Sugar.hs
+++ b/Data/Expr/Sugar.hs
@@ -14,7 +14,6 @@
   (@||), (@&&), inv,
   (@/=), (@>), (@<), (@>=), (@<=), (@=), 
   loopall, loopany, forall, forany,
-  ExprClass,
   Expr(), ColExpr(), BoolExpr(),
   ToExpr(..), ToColExpr(..), ToBoolExpr(..),
   sorted, sSorted, allDiff, allDiffD,
diff --git a/Data/Linear.hs b/Data/Linear.hs
--- a/Data/Linear.hs
+++ b/Data/Linear.hs
@@ -23,9 +23,9 @@
 
 data (Ord t, Num v) => Linear t v = Linear v (Map t v)
 
-deriving instance (Num v, Ord t, Eq t) => Eq (Linear t v)
+deriving instance (Num v, Eq v, Ord t, Eq t) => Eq (Linear t v)
 deriving instance (Num v, Ord v, Ord t, Eq t) => Ord (Linear t v)
-deriving instance (Num v, Ord t, Show t) => Show (Linear t v)
+deriving instance (Num v, Show v, Ord t, Show t) => Show (Linear t v)
 
 termToLinear :: (Num v, Ord t) => t -> Linear t v
 termToLinear x = Linear 0 $ Map.singleton x 1
@@ -52,10 +52,10 @@
 getCoef Nothing (Linear c _) = c
 getCoef (Just t) (Linear _ m) = Map.findWithDefault 0 t m
 
-linearMult :: (Num v, Ord t) => v -> Linear t v -> Linear t v
+linearMult :: (Num v, Eq v, Ord t) => v -> Linear t v -> Linear t v
 linearMult m (Linear ac am) = Linear (m*ac) $ if (m==0) then Map.empty else Map.filter (/=0) $ Map.map (m*) am
 
-linearMultiply :: (Num v, Ord t) => Linear t v -> Linear t v -> Maybe (Linear t v)
+linearMultiply :: (Num v, Eq v, Ord t) => Linear t v -> Linear t v -> Maybe (Linear t v)
 linearMultiply (Linear ac am) bl | (Map.null am) = Just $ linearMult ac bl
 linearMultiply bl (Linear ac am) | (Map.null am) = Just $ linearMult ac bl
 linearMultiply _ _ = Nothing
@@ -64,13 +64,13 @@
 linearToConst (Linear c m) | Map.null m = Just c
 linearToConst _ = Nothing
 
-linearToTerm :: (Num v, Ord t) => Linear t v -> Maybe t
+linearToTerm :: (Num v, Eq v, Ord t) => Linear t v -> Maybe t
 linearToTerm (Linear c m) | (c==0 && (Map.size m)==1) = 
   let (t,v) = Map.findMin m
       in if (v==1) then Just t else Nothing
 linearToTerm _ = Nothing
 
-instance (Num v, Ord t, Eq t, Show t) => Num (Linear t v) where
+instance (Num v, Eq v, Ord t, Eq t, Show t) => Num (Linear t v) where
   (Linear ac am) + (Linear bc bm) = Linear (ac+bc) $ Map.filter (/=0) $ Map.unionWith (+) am bm
   (Linear ac am) - (Linear bc bm) = Linear (ac-bc) $ Map.filter (/=0) $ Map.unionWith (+) am $ Map.map negate bm
   a * b = case linearMultiply a b of Just x -> x; Nothing -> error "Cannot multiply generic linear expressions"
diff --git a/README.txt b/README.txt
--- a/README.txt
+++ b/README.txt
@@ -1,5 +1,7 @@
 ACKNOWLEDGMENTS
 ================
 
+- Thanks to Chris Mears for a patch to get
+  the package to compile against GHC 7.4.1.
 - Thanks to Nicholas Tung for a patch to get
   the package to compile against GHC 7.2.2.
diff --git a/monadiccp.cabal b/monadiccp.cabal
--- a/monadiccp.cabal
+++ b/monadiccp.cabal
@@ -1,5 +1,5 @@
 Name:			monadiccp
-Version:		0.7.3
+Version:		0.7.4
 Description:		Monadic Constraint Programming framework
 License:		BSD3
 License-file:		LICENSE