Remove use of LinkedHashMap package (#913)

Author: MatthewDaggitt

cabal.project.config

@@ -4,13 +4,6 @@
 -- different configurations for Vehicle. See `cabal.project` for more
 -- details.
 
--- 03-11-2022:
--- The package linkedhashmap seems unmaintained. The latest update seems to
--- have been in 2015. Unfortunately, it requires containers <0.6.
--- See: https://github.com/vehicle-lang/vehicle/issues/191
-
-allow-newer: linkedhashmap-0.4.0.0:containers
-
 -- 03-04-2023:
 -- The package terminal-size, which is a dependency of terminal-progress-bar,
 -- requires Win32>=2.13.2.0 && <2.14 since version 0.3.4. Unfortunately, the

vehicle/src/Vehicle/Compile/FunctionaliseResources.hs

@@ -7,10 +7,10 @@ import Control.Monad (when)
 import Control.Monad.Reader (MonadReader (..), ReaderT (..))
 import Control.Monad.Writer (MonadWriter (..), execWriterT)
 import Data.Bifunctor (Bifunctor (..))
-import Data.LinkedHashMap (LinkedHashMap)
-import Data.LinkedHashMap qualified as LinkedHashMap (empty, filterWithKey, insert, member, toList)
 import Data.Map (Map)
 import Data.Map qualified as Map (fromList, insert, lookup)
+import Data.Map.Ordered (OMap)
+import Data.Map.Ordered qualified as OMap (assocs, empty, filter, member, (>|))
 import Data.Maybe (catMaybes)
 import Data.Set (Set)
 import Data.Set qualified as Set (fromList, member, singleton)
@@ -48,7 +48,7 @@ functionaliseResources ::
   m (Prog builtin)
 functionaliseResources prog =
   logCompilerPass MidDetail currentPass $ do
-    runReaderT (functionaliseProg prog) (FuncState LinkedHashMap.empty mempty)
+    runReaderT (functionaliseProg prog) (FuncState OMap.empty mempty)
 
 --------------------------------------------------------------------------------
 -- Utilities
@@ -57,14 +57,14 @@ currentPass :: CompilerPass
 currentPass = "resource functionalisation"
 
 data FuncState builtin = FuncState
-  { resourceDeclarations :: LinkedHashMap Name (Type builtin),
+  { resourceDeclarations :: OMap Name (Type builtin),
     resourceUsageFreeCtx :: GenericFreeCtx [Name]
   }
 
 addResourceDeclaration :: Identifier -> Type builtin -> FuncState builtin -> FuncState builtin
 addResourceDeclaration resource typ FuncState {..} =
   FuncState
-    { resourceDeclarations = LinkedHashMap.insert (nameOf resource) typ resourceDeclarations,
+    { resourceDeclarations = resourceDeclarations OMap.>| (nameOf resource, typ),
       ..
     }
 
@@ -134,7 +134,7 @@ findResourceUses e = do
       args' <- traverse (traverse recGo) args
       FuncState {..} <- ask
       let name = nameOf ident
-      when (name `LinkedHashMap.member` resourceDeclarations) $ do
+      when (name `OMap.member` resourceDeclarations) $ do
         tell (Set.singleton name)
       let resourceArgs = lookupInFreeCtx ident resourceUsageFreeCtx
       tell (Set.fromList resourceArgs)
@@ -171,7 +171,7 @@ replaceResourceUses (mkBinder, binders, binderNames) initialExpr = do
                 return $ BoundVar p resourceIx
 
       newFun <-
-        if name `LinkedHashMap.member` resourceDeclarations
+        if name `OMap.member` resourceDeclarations
           then mkResourceVar name
           else return $ FreeVar p ident
 
@@ -188,8 +188,8 @@ createBinders ::
   m (Binder builtin -> Expr builtin -> Expr builtin, [Binder builtin], [Name])
 createBinders isType p idents = do
   FuncState {..} <- ask
-  let identsAndTypes = LinkedHashMap.filterWithKey (\i _ -> Set.member i idents) resourceDeclarations
-  let identsAndTypesList = LinkedHashMap.toList identsAndTypes
+  let identsAndTypes = OMap.filter (\i _ -> Set.member i idents) resourceDeclarations
+  let identsAndTypesList = OMap.assocs identsAndTypes
   let mkBindingForm ident
         | isType = BinderDisplayForm OnlyType True
         | otherwise = BinderDisplayForm (OnlyName (nameOf ident)) True

vehicle/src/Vehicle/Compile/Monomorphisation.hs

@@ -17,11 +17,11 @@ import Control.Monad.State
   )
 import Control.Monad.Writer (MonadWriter (..), runWriterT)
 import Data.Bifunctor (Bifunctor (..))
-import Data.Foldable (traverse_)
+import Data.Foldable (Foldable (..), traverse_)
 import Data.HashMap.Strict (HashMap)
 import Data.HashMap.Strict qualified as HashMap
 import Data.Hashable (Hashable)
-import Data.LinkedHashSet qualified as HashSet (fromList, toList)
+import Data.List (nub)
 import Data.List.NonEmpty (NonEmpty)
 import Data.List.NonEmpty qualified as NonEmpty
 import Data.Map (Map)
@@ -190,8 +190,10 @@ calculateMonomorphisations declType allApplications = do
   MonoSettings {..} <- ask
   let calculateMonomorphisation = obtainArgsToMonomorphise isMonomorphisableBinder declType
   let monomorphisations = fmap (fst . calculateMonomorphisation) allApplications
-  let uniqueMonomorphisations = HashSet.fromList $ NonEmpty.toList monomorphisations
-  return $ HashSet.toList uniqueMonomorphisations
+  -- This is inefficient and not strictly semantically correct.
+  -- Semantic equality is difficult however.
+  let uniqueMonomorphisations = nub $ NonEmpty.toList monomorphisations
+  return $ toList uniqueMonomorphisations
 
 performMonomorphisation ::
   (MonadCollect builtin m) =>

vehicle/vehicle.cabal

@@ -300,7 +300,6 @@ library
     , filepath               >=1.4      && <2
     , gitrev                 >=1.3      && <2
     , hashable               >=1.3      && <2
-    , linkedhashmap          >=0.4      && <1
     , mnist-idx              >=0.1.3.1  && <0.2
     , mtl                    >=2.2      && <3
     , optparse-applicative   >=0.16     && <1