diff --git a/semiring-num.cabal b/semiring-num.cabal
--- a/semiring-num.cabal
+++ b/semiring-num.cabal
@@ -1,5 +1,5 @@
 name:                semiring-num
-version:             1.0.0.1
+version:             1.1.0.0
 synopsis:            Basic semiring class and instances
 description:         Adds a basic semiring class
 homepage:            https://github.com/oisdk/semiring-num
@@ -21,7 +21,6 @@
                      , Test.Semiring
   other-modules:       Data.Semiring.TH
   build-depends:       base >= 4.9 && < 5
-                     , containers >= 0.5
                      , template-haskell >= 2.11
   default-language:    Haskell2010
   ghc-options:         -Wall
diff --git a/src/Data/Semiring/Free.hs b/src/Data/Semiring/Free.hs
--- a/src/Data/Semiring/Free.hs
+++ b/src/Data/Semiring/Free.hs
@@ -1,5 +1,4 @@
 {-# LANGUAGE DeriveFoldable             #-}
-{-# LANGUAGE BangPatterns               #-}
 {-# LANGUAGE DeriveFunctor              #-}
 {-# LANGUAGE DeriveTraversable          #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
@@ -12,24 +11,14 @@
   ) where
 
 import           Control.Applicative (liftA2)
-
 import           Data.Coerce
-
-import           Data.Function (on)
-import           Data.List (sort)
-
 import           Data.Semiring
-import           Data.Ord (comparing)
 
-import qualified Data.Map.Strict as Map
-import           Data.Map.Strict (Map)
-
 -- | The free semiring. Adapted from PureScript's version, available
 -- <https://pursuit.purescript.org/packages/purescript-semirings/3.0.0/docs/Data.Semiring.Free here>.
 -- Only a valid semiring if treated as a multiset, as in:
 --
--- >>> Free [[1],[0]] == Free [[0],[1]]
--- True
+-- > Free [[1],[0]] = Free [[0],[1]]
 newtype Free a = Free
   { getFree :: [[a]]
   } deriving (Show, Read, Functor, Foldable, Traversable, Monoid)
@@ -52,24 +41,7 @@
 unFree :: Semiring s => Free s -> s
 unFree = getAdd .# foldMap (Add .# getMul .# foldMap Mul) . getFree
 
--- | Extremely slow. For testing purposes.
-instance Ord a => Eq (Free a) where
-  (==) = isAnagram `on` getFree
-
-instance Ord a => Ord (Free a) where
-  compare = comparing (sort . getFree)
-
 infixr 9 .#
 (.#) :: Coercible b c => (b -> c) -> (a -> b) -> a -> c
 (.#) _ = coerce
 
-isAnagram :: Ord a => [a] -> [a] -> Bool
-isAnagram = go (Map.empty :: Map a Int) where
-  go !m (x:xs) (y:ys) =
-    go ( Map.alter (remZero . maybe (-1) pred) x
-       $ Map.alter (remZero . maybe 1    succ) y
-    m) xs ys
-  go !m [] [] = Map.null m
-  go _ _ _ = False
-  remZero 0 = Nothing
-  remZero n = Just n
diff --git a/test/Spec.hs b/test/Spec.hs
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE BangPatterns               #-}
 {-# LANGUAGE DataKinds                  #-}
 {-# LANGUAGE FlexibleInstances          #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
@@ -9,30 +10,40 @@
 module Main (main) where
 
 import           Control.Applicative
+
 import           Control.Arrow            (first)
 import           Data.Bool
-import           Data.Foldable
 import           Data.Function
+
+import           Data.Foldable
+import           Data.Monoid
+
 import           Data.IntMap.Strict       (IntMap)
 import qualified Data.IntMap.Strict       as IntMap
+
+import           Data.Map.Strict          (Map)
 import qualified Data.Map.Strict          as Map
-import           Data.Monoid
+
+
 import           Data.Semiring
 import           Data.Semiring.Free
 import           Data.Semiring.Infinite
 import           Data.Semiring.Numeric
+
 import           GHC.TypeLits
+import           Numeric.Natural
 import           Numeric.Sized.WordOfSize
+
 import           Test.DocTest
 import           Test.QuickCheck          hiding (Positive (..), generate,
                                            (.&.))
-import           Test.Semiring
 import           Test.SmallCheck          hiding (Testable, (==>))
 import           Test.SmallCheck.Series   hiding (Positive)
 import qualified Test.SmallCheck.Series   as SC
 
-import           Numeric.Natural
+import           Test.Semiring
 
+
 ------------------------------------------------------------------------
 
 main :: IO ()
@@ -290,6 +301,21 @@
 
 ternLawsOn :: (Eq b, Semiring b, Show b) => (a -> b) -> TernaryLaws a
 ternLawsOn = ternOn ternaryLaws
+
+
+isAnagram :: Ord a => [a] -> [a] -> Bool
+isAnagram = go (Map.empty :: Map a Int) where
+  go !m (x:xs) (y:ys) =
+    go ( Map.alter (remZero . maybe (-1) pred) x
+       $ Map.alter (remZero . maybe 1    succ) y
+    m) xs ys
+  go !m [] [] = Map.null m
+  go _ _ _ = False
+  remZero 0 = Nothing
+  remZero n = Just n
+
+instance Ord a => Eq (Free a) where
+  (==) = isAnagram `on` getFree
 
 ------------------------------------------------------------------------
 -- Serial wrappers