Drop dependency on insert-ordered-containers

Fixes #161

hnix.cabal

@@ -2,7 +2,7 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: a04e016a0554c9de3805c58f0b26edabe808e45ef387e065f8aa44c803af866e
+-- hash: b04b1cb6b8d8f2cbb85b7de0ab313e31b2c8e74120b41f5930894323ae11da2e
 
 name:           hnix
 version:        0.5.0
@@ -74,7 +74,6 @@ library
     , directory
     , exceptions
     , filepath
-    , insert-ordered-containers >=0.2.2 && <0.3
     , megaparsec
     , monadlist
     , mtl
@@ -110,7 +109,6 @@ executable hnix
     , deepseq
     , exceptions
     , hnix
-    , insert-ordered-containers >=0.2.2 && <0.3
     , mtl
     , optparse-applicative
     , template-haskell
@@ -142,7 +140,6 @@ test-suite hnix-tests
     , exceptions
     , filepath
     , hnix
-    , insert-ordered-containers >=0.2.2 && <0.3
     , interpolate
     , mtl
     , process
@@ -175,7 +172,6 @@ benchmark hnix-benchmarks
     , deepseq
     , exceptions
     , hnix
-    , insert-ordered-containers >=0.2.2 && <0.3
     , mtl
     , template-haskell
     , text

package.yaml

@@ -20,7 +20,6 @@ dependencies:
   - data-fix
   - deepseq
   - exceptions
-  - insert-ordered-containers   >= 0.2.2 && < 0.3
   - mtl
   - template-haskell
   - text

src/Nix/Builtins.hs

@@ -37,7 +37,6 @@ import           Data.Char (isDigit)
 import           Data.Coerce
 import           Data.Foldable (foldlM)
 import qualified Data.HashMap.Lazy as M
-import qualified Data.HashMap.Strict.InsOrd as OM
 import           Data.List
 import           Data.Maybe
 import           Data.Scientific
@@ -547,7 +546,7 @@ functionArgs fun = force fun $ \case
         return $ flip NVSet M.empty $ valueThunk . NVConstant . NBool <$>
             case p of
                 Param name -> M.singleton name False
-                ParamSet s _ _ -> isJust <$> OM.toHashMap s
+                ParamSet s _ _ -> isJust <$> M.fromList s
     v -> throwError $ "builtins.functionArgs: expected function, got "
             ++ show v
 

src/Nix/Eval.hs

@@ -26,7 +26,6 @@ import           Data.Align.Key
 import           Data.Fix
 import           Data.Functor.Compose
 import qualified Data.HashMap.Lazy as M
-import           Data.HashMap.Strict.InsOrd (toHashMap)
 import           Data.List (intercalate, partition, foldl')
 import           Data.Maybe (fromMaybe, catMaybes)
 import           Data.Text (Text)
@@ -363,7 +362,7 @@ buildArgument params arg = case params of
                         Nothing -> id
                         Just n -> M.insert n $ const $ thunk arg
                 loebM (inject $ alignWithKey (assemble isVariadic)
-                                             args (toHashMap s))
+                                             args (M.fromList s))
             _ -> evalError @v $ "Argument to function must be a set, but saw: "
                     ++ show v
   where

src/Nix/Expr/Shorthands.hs

@@ -7,13 +7,12 @@
 -- 'Fix' wrapper.
 module Nix.Expr.Shorthands where
 
-import           Data.Fix
-import qualified Data.HashMap.Strict.InsOrd as M
-import           Data.Monoid
-import           Data.Text (Text)
-import           Nix.Atoms
-import           Nix.Expr.Types
--- import           Nix.Utils
+import Data.Fix
+import Data.Monoid
+import Data.Text (Text)
+import Nix.Atoms
+import Nix.Expr.Types
+-- import Nix.Utils
 
 -- | Make an integer literal expression.
 mkInt :: Integer -> NExpr
@@ -100,7 +99,7 @@ mkOper2 :: NBinaryOp -> NExpr -> NExpr -> NExpr
 mkOper2 op a = Fix . NBinary op a
 
 mkParamset :: [(Text, Maybe NExpr)] -> Bool -> Params NExpr
-mkParamset params variadic = ParamSet (M.fromList params) variadic Nothing
+mkParamset params variadic = ParamSet params variadic Nothing
 
 mkRecSet :: [Binding NExpr] -> NExpr
 mkRecSet = Fix . NRecSet

src/Nix/Expr/Types.hs

@@ -28,8 +28,6 @@ import           Data.Data
 import           Data.Eq.Deriving
 import           Data.Fix
 import           Data.Functor.Classes
-import           Data.HashMap.Strict.InsOrd (InsOrdHashMap)
-import qualified Data.HashMap.Strict.InsOrd as InsOrd
 import           Data.Text (Text, pack, unpack)
 import           Data.Traversable
 import           GHC.Exts
@@ -127,19 +125,11 @@ data Params r
   -- bind to the set in the function body. The bool indicates whether it is
   -- variadic or not.
   deriving (Ord, Eq, Generic, Generic1, Typeable, Data, Functor, Show,
-            Foldable, Traversable)
+            Foldable, Traversable, NFData, NFData1)
 
-instance NFData a => NFData (Params a) where
-    rnf (Param !_) = ()
-    rnf (ParamSet !s !_ !_) = InsOrd.size s `seq` ()
-
-instance NFData1 Params where
-    liftRnf _ (Param !_) = ()
-    liftRnf _ (ParamSet !s !_ !_) = InsOrd.size s `seq` ()
-
--- This uses InsOrdHashMap because nix XML serialization preserves the order of
--- the param set.
-type ParamSet r = InsOrdHashMap VarName (Maybe r)
+-- This uses an association list because nix XML serialization preserves the
+-- order of the param set.
+type ParamSet r = [(VarName, Maybe r)]
 
 instance IsString (Params r) where
   fromString = Param . fromString

src/Nix/Lint.hs

@@ -20,7 +20,6 @@ import           Data.Coerce
 import           Data.Fix
 import           Data.HashMap.Lazy (HashMap)
 import qualified Data.HashMap.Lazy as M
-import qualified Data.HashMap.Strict.InsOrd as OM
 import           Data.List
 import           Data.Maybe
 import           Data.Text (Text)

src/Nix/Parser.hs

@@ -17,7 +17,6 @@ import           Control.Monad.IO.Class
 import           Data.Char (isAlpha, isDigit, isSpace)
 import           Data.Functor
 import qualified Data.List.NonEmpty as NE
-import qualified Data.HashMap.Strict.InsOrd as M
 import           Data.Text hiding (map, empty)
 import           Nix.Expr hiding (($>))
 import           Nix.Parser.Library
@@ -292,7 +291,7 @@ argExpr = choice [atLeft, onlyname, atRight] <* symbol ":" where
   -- Return the parameters set.
   params = do
     (args, dotdots) <- braces getParams
-    return (dotdots, M.fromList args)
+    return (dotdots, args)
 
   -- Collects the parameters within curly braces. Returns the parameters and
   -- a boolean indicating if the parameters are variadic.

src/Nix/Pretty.hs

@@ -9,7 +9,6 @@ import           Control.Monad
 import           Data.Fix
 import           Data.HashMap.Lazy (toList)
 import qualified Data.HashMap.Lazy as M
-import qualified Data.HashMap.Strict.InsOrd as OM
 import qualified Data.HashSet as HashSet
 import           Data.List (isPrefixOf, sort)
 import           Data.Maybe (isJust)
@@ -105,8 +104,8 @@ prettyParamSet args var =
       Nothing -> text (unpack n)
       Just v -> text (unpack n) <+> text "?" <+> withoutParens v
     prettyArgs
-        | var = map prettySetArg (OM.toList args)
-        | otherwise = map prettySetArg (OM.toList args) ++ [text "..."]
+        | var = map prettySetArg args
+        | otherwise = map prettySetArg args ++ [text "..."]
     sep = align (comma <> space)
 
 prettyBind :: Binding NixDoc -> Doc

src/Nix/XML.hs

@@ -4,7 +4,6 @@ module Nix.XML where
 
 import           Data.Fix
 import qualified Data.HashMap.Lazy as M
-import qualified Data.HashMap.Strict.InsOrd as OM
 import           Data.List
 import           Data.Ord
 import qualified Data.Text as Text
@@ -53,4 +52,4 @@ paramsXML (ParamSet s b mname) =
     nattr = maybe [] ((:[]) . Attr (unqual "name") . Text.unpack) mname
 
 paramSetXML :: ParamSet r -> [Content]
-paramSetXML m = map (\(k,_) -> Elem $ mkElem "attr" "name" (Text.unpack k)) $ OM.toList m
+paramSetXML = map (\(k,_) -> Elem $ mkElem "attr" "name" (Text.unpack k))

tests/ParserTests.hs

@@ -6,16 +6,15 @@
 
 module ParserTests (tests) where
 
-import           Data.Fix
-import qualified Data.HashMap.Strict.InsOrd as OM
-import           Data.Text (Text, unpack)
-import           Data.Semigroup
-import           Nix.Atoms
-import           Nix.Expr
-import           Nix.Parser
-import           Test.Tasty
-import           Test.Tasty.HUnit
-import           Test.Tasty.TH
+import Data.Fix
+import Data.Semigroup
+import Data.Text (Text, unpack)
+import Nix.Atoms
+import Nix.Expr
+import Nix.Parser
+import Test.Tasty
+import Test.Tasty.HUnit
+import Test.Tasty.TH
 
 case_constant_int :: Assertion
 case_constant_int = assertParseText "234" $ mkInt 234
@@ -173,9 +172,9 @@ case_lambda_pattern = do
  where
   fixed args = ParamSet args False
   variadic args = ParamSet args True
-  args = OM.fromList [("b", Nothing), ("c", Just $ mkInt 1)]
-  vargs = OM.fromList [("b", Nothing), ("c", Just $ mkInt 1)]
-  args2 = OM.fromList [("b", Just lam)]
+  args = [("b", Nothing), ("c", Just $ mkInt 1)]
+  vargs = [("b", Nothing), ("c", Just $ mkInt 1)]
+  args2 = [("b", Just lam)]
   lam = Fix $ NAbs (Param "x") (mkSym "x")
 
 case_lambda_app_int :: Assertion