Fix up tests

semantic-diff.cabal

@@ -91,6 +91,8 @@ test-suite semantic-diff-test
                      , quickcheck-text
                      , semantic-diff
                      , text >= 1.2.1.3
+                     , free
+                     , recursion-schemes >= 4.1
   if os(darwin)
     ghc-options:       -threaded -rtsopts -with-rtsopts=-N -j
   else

src/Term.hs

@@ -17,6 +17,7 @@ type Term a annotation = Cofree (Syntax a) annotation
 
 type instance Base (Cofree f a) = CofreeF f a
 instance Functor f => Foldable.Foldable (Cofree f a) where project = runCofree
+instance Functor f => Foldable.Unfoldable (Cofree f a) where embed = cofree
 
 -- | Zip two terms by combining their annotations into a pair of annotations.
 -- | If the structure of the two terms don't match, then Nothing will be returned.

test/AlignmentSpec.hs

@@ -8,8 +8,8 @@ import Data.Text.Arbitrary ()
 import Alignment
 import ArbitraryTerm (arbitraryLeaf)
 import Control.Arrow
-import Control.Comonad.Cofree
-import Control.Monad.Free hiding (unfold)
+import Control.Comonad.Trans.Cofree
+import Control.Monad.Trans.Free hiding (unfold)
 import Data.Adjoined
 import Data.Copointed
 import Data.Functor.Both as Both
@@ -32,34 +32,34 @@ spec = parallel $ do
   describe "splitDiffByLines" $ do
     prop "preserves line counts in equal sources" $
       \ source ->
-        length (splitDiffByLines (pure source) (Free $ Annotated (pure $ Info (totalRange source) mempty 1) (Indexed . Prelude.fst $ foldl combineIntoLeaves ([], 0) source))) `shouldBe` length (filter (== '\n') $ toString source) + 1
+        length (splitDiffByLines (pure source) (free . Free $ (pure $ Info (totalRange source) mempty 1) :< (Indexed . Prelude.fst $ foldl combineIntoLeaves ([], 0) source))) `shouldBe` length (filter (== '\n') $ toString source) + 1
 
     prop "produces the maximum line count in inequal sources" $
       \ sources -> let ranges = actualLineRanges <$> (totalRange <$> sources) <*> sources in
-        length (splitDiffByLines sources (Free $ Annotated ((\ s -> Info (totalRange s) mempty 0) <$> sources) (Indexed $ leafWithRangesInSources sources <$> runBothWith (zipWith both) ranges))) `shouldBe` runBothWith max ((+ 1) . length . filter (== '\n') . toString <$> sources)
+        length (splitDiffByLines sources (free . Free $ ((\ s -> Info (totalRange s) mempty 0) <$> sources) :< (Indexed $ leafWithRangesInSources sources <$> runBothWith (zipWith both) ranges))) `shouldBe` runBothWith max ((+ 1) . length . filter (== '\n') . toString <$> sources)
 
   describe "splitAbstractedTerm" $ do
     prop "preserves line count" $
       \ source -> let range = totalRange source in
-        splitAbstractedTerm (:<) (Identity source) (Identity (Info range mempty 0)) (Leaf source) `shouldBe` (Identity . lineMap (fmap (((:< Leaf source) . (\ r -> Info r mempty 0) &&& id))) <$> linesInRangeOfSource range source)
+        splitAbstractedTerm ((cofree .) . (:<)) (Identity source) (Identity (Info range mempty 0) :< Leaf source) `shouldBe` (Identity . lineMap (fmap (cofree . (:< Leaf source) . (\ r -> Info r mempty 0) &&& id)) <$> linesInRangeOfSource range source)
 
-    let makeTerm = ((Free .) . Annotated) :: Info -> Syntax (Source Char) (SplitDiff (Source Char) Info) -> SplitDiff (Source Char) Info
+    let makeTerm = ((free .) . (Free .) . (:<)) :: Info -> Syntax (Source Char) (SplitDiff (Source Char) Info) -> SplitDiff (Source Char) Info
     prop "outputs one row for single-line unchanged leaves" $
       forAll (arbitraryLeaf `suchThat` isOnSingleLine) $
-        \ (source, (Info range categories _), syntax) -> splitAbstractedTerm makeTerm (pure source) (pure $ Info range categories 0) syntax `shouldBe` fromList [
+        \ (source, (Info range categories _), syntax) -> splitAbstractedTerm makeTerm (pure source) (pure (Info range categories 0) :< syntax) `shouldBe` fromList [
           both (pure (makeTerm (Info range categories 0) $ Leaf source, Range 0 (length source))) (pure (makeTerm (Info range categories 0) $ Leaf source, Range 0 (length source))) ]
 
     prop "outputs one row for single-line empty unchanged indexed nodes" $
       forAll (arbitrary `suchThat` (\ a -> filter (/= '\n') (toString a) == toString a)) $
-          \ source -> splitAbstractedTerm makeTerm (pure source) (pure $ Info (totalRange source) mempty 0) (Indexed []) `shouldBe` fromList [
+          \ source -> splitAbstractedTerm makeTerm (pure source) (pure (Info (totalRange source) mempty 0) :< Indexed []) `shouldBe` fromList [
             both (pure (makeTerm (Info (totalRange source) mempty 0) $ Indexed [], Range 0 (length source))) (pure (makeTerm (Info (totalRange source) mempty 0) $ Indexed [], Range 0 (length source))) ]
 
     where
       isOnSingleLine (a, _, _) = filter (/= '\n') (toString a) == toString a
 
-      combineIntoLeaves (leaves, start) char = (leaves ++ [ Free $ Annotated (Info <$> pure (Range start $ start + 1) <*> mempty <*> pure 1) (Leaf [ char ]) ], start + 1)
+      combineIntoLeaves (leaves, start) char = (leaves ++ [ free . Free $ (Info <$> pure (Range start $ start + 1) <*> mempty <*> pure 1) :< Leaf [ char ] ], start + 1)
 
-      leafWithRangesInSources sources ranges = Free $ Annotated (Info <$> ranges <*> pure mempty <*> pure 1) (Leaf $ runBothWith (++) (toString <$> sources))
+      leafWithRangesInSources sources ranges = free . Free $ (Info <$> ranges <*> pure mempty <*> pure 1) :< (Leaf $ runBothWith (++) (toString <$> sources))
 
       leafWithRangeInSource source range = Info range mempty 1 :< Leaf source
 

test/ArbitraryTerm.hs

@@ -1,7 +1,8 @@
 module ArbitraryTerm where
 
 import Category
-import Control.Comonad.Cofree
+import Control.Comonad.Trans.Cofree
+import Data.Functor.Foldable
 import Control.Monad
 import Data.Functor.Both
 import qualified Data.OrderedMap as Map
@@ -25,7 +26,7 @@ newtype ArbitraryTerm a annotation = ArbitraryTerm (annotation, Syntax a (Arbitr
 
 unTerm :: ArbitraryTerm a annotation -> Term a annotation
 unTerm = unfold unpack
-  where unpack (ArbitraryTerm (annotation, syntax)) = (annotation, syntax)
+  where unpack (ArbitraryTerm (annotation, syntax)) = annotation :< syntax
 
 instance (Eq a, Eq annotation, Arbitrary a, Arbitrary annotation) => Arbitrary (ArbitraryTerm a annotation) where
   arbitrary = scale (`div` 2) $ sized (\ x -> boundedTerm x x) -- first indicates the cube of the max length of lists, second indicates the cube of the max depth of the tree

test/InterpreterSpec.hs

@@ -4,19 +4,19 @@ import Diff
 import qualified Interpreter as I
 import Range
 import Syntax
-import Control.Comonad.Cofree
-import Control.Monad.Free
+import Control.Comonad.Trans.Cofree
+import Control.Monad.Trans.Free
 import Patch
 import Info
 import Category
 import Test.Hspec
 
 spec :: Spec
-spec = parallel $ do
-  describe "interpret" $ do
+spec = parallel $
+  describe "interpret" $
     it "returns a replacement when comparing two unicode equivalent terms" $
-      I.interpret comparable diffCost (Info range mempty 0 :< Leaf "t\776") (Info range2 mempty 0 :< Leaf "\7831") `shouldBe`
-      Pure (Replace (Info range mempty 0 :< Leaf "t\776") (Info range2 mempty 0 :< Leaf "\7831"))
+      I.interpret comparable diffCost (cofree (Info range mempty 0 :< Leaf "t\776")) (cofree (Info range2 mempty 0 :< Leaf "\7831")) `shouldBe`
+      free (Pure (Replace (cofree (Info range mempty 0 :< Leaf "t\776")) (cofree (Info range2 mempty 0 :< Leaf "\7831"))))
 
     where
       range = Range 0 2

test/PatchOutputSpec.hs

@@ -1,8 +1,8 @@
 module PatchOutputSpec where
 
-import Control.Monad.Free
+import Control.Comonad.Trans.Cofree
+import Control.Monad.Trans.Free
 import Data.Functor.Both
-import Diff
 import Info
 import Range
 import Renderer.Patch
@@ -14,4 +14,4 @@ spec :: Spec
 spec = parallel $
   describe "hunks" $
     it "empty diffs have empty hunks" $
-        hunks (Free . Annotated (pure (Info (Range 0 0) mempty 1)) $ Leaf "") (Both (SourceBlob (fromList "") "abcde" "path2.txt" (Just defaultPlainBlob), SourceBlob (fromList "") "xyz" "path2.txt" (Just defaultPlainBlob))) `shouldBe` [Hunk {offset = Both (0, 0), changes = [], trailingContext = []}]
+        hunks (free . Free $ pure (Info (Range 0 0) mempty 1) :< Leaf "") (Both (SourceBlob (fromList "") "abcde" "path2.txt" (Just defaultPlainBlob), SourceBlob (fromList "") "xyz" "path2.txt" (Just defaultPlainBlob))) `shouldBe` [Hunk {offset = Both (0, 0), changes = [], trailingContext = []}]