Imports updated

package.json

@@ -14,7 +14,9 @@
        PAKCS/KiCS2 distributions.",
     "category": [ "Rewriting", "Narrowing" ],
     "dependencies": {
-        "abstract-curry": ">= 2.0.0"
+        "base"          : ">= 1.0.0, < 2.0.0",
+        "abstract-curry": ">= 2.0.0",
+        "finite-map"    : ">= 0.0.1"
     },
     "compilerCompatibility": {
         "pakcs": ">= 2.0.0",

src/Rewriting/Files.curry

@@ -16,7 +16,8 @@ module Rewriting.Files
 
 import AbstractCurry.Files (tryReadCurryFile)
 import AbstractCurry.Types
-import FiniteMap (FM, listToFM)
+import Data.FiniteMap (FM, listToFM)
+
 import Rewriting.Rules (Rule, TRS, rCons)
 import Rewriting.Substitution
 import Rewriting.Term (Term (..), tConst)

src/Rewriting/Narrowing.curry

@@ -15,9 +15,10 @@ module Rewriting.Narrowing
   , dotifyNarrowingTree, writeNarrowingTree
   ) where
 
-import FiniteMap (eltsFM)
 import Maybe (fromMaybe, mapMaybe)
 import List (maximum)
+
+import Data.FiniteMap (eltsFM)
 import Rewriting.DefinitionalTree
 import Rewriting.Position
 import Rewriting.Rules

src/Rewriting/Substitution.curry

@@ -12,10 +12,11 @@ module Rewriting.Substitution
   , applySubstEq, applySubstEqs, restrictSubst, composeSubst
   ) where
 
-import FiniteMap
 import Function (both)
 import List (intercalate)
 import Maybe (fromMaybe)
+
+import Data.FiniteMap
 import Rewriting.Term
 
 -- ---------------------------------------------------------------------------

src/Rewriting/Term.curry

@@ -19,10 +19,11 @@ module Rewriting.Term
   ) where
 
 import Char      ( isAlphaNum )
-import FiniteMap ( listToFM, lookupFM )
 import List      ( nub, intercalate, maximum, minimum )
 import Maybe     ( fromMaybe )
 
+import Data.FiniteMap ( listToFM, lookupFM )
+
 -- ---------------------------------------------------------------------------
 -- Representation of first-order terms and term equations
 -- ---------------------------------------------------------------------------

src/Rewriting/Unification.curry

@@ -15,8 +15,9 @@ module Rewriting.Unification
   ) where
 
 import Either (isRight)
-import FiniteMap (FM, emptyFM, addToFM, lookupFM)
 import List (mapAccumL)
+
+import Data.FiniteMap (FM, emptyFM, addToFM, lookupFM)
 import Rewriting.Substitution (Subst, emptySubst, extendSubst)
 import Rewriting.Term (VarIdx, Term (..), TermEq, TermEqs)
 import Rewriting.UnificationSpec (UnificationError (..), showUnificationError)