Split MonadFreshId off into its own file

hnix.cabal

@@ -449,6 +449,7 @@ library
       Nix.Expr.Types
       Nix.Expr.Types.Annotated
       Nix.Frames
+      Nix.Fresh
       Nix.Json
       Nix.Lint
       Nix.Normal

src/Nix/Exec.hs

@@ -57,6 +57,7 @@ import           Nix.Effects
 import           Nix.Eval as Eval
 import           Nix.Expr
 import           Nix.Frames
+import           Nix.Fresh
 import           Nix.String
 import           Nix.Normal
 import           Nix.Options

src/Nix/Fresh.hs

@@ -0,0 +1,77 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE DefaultSignatures #-}
+{-# LANGUAGE DeriveFunctor #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+{-# OPTIONS_GHC -Wno-orphans #-}
+
+module Nix.Fresh where
+
+import Control.Applicative
+import Control.Monad.Catch
+import Control.Monad.Except
+import Control.Monad.Reader
+import Control.Monad.Ref
+import Control.Monad.ST
+import Control.Monad.State.Strict
+import Control.Monad.Writer
+#ifdef MIN_VERSION_haskeline
+import System.Console.Haskeline.MonadException hiding (catch)
+#endif
+
+-- TODO better fresh name supply
+class Monad m => MonadFreshId i m | m -> i where
+  freshId :: m i
+  default freshId :: (MonadFreshId i m', MonadTrans t, m ~ (t m')) => m i
+  freshId = lift freshId
+
+newtype FreshIdT i m a = FreshIdT { unFreshIdT :: StateT i m a }
+  deriving
+    ( Functor
+    , Applicative
+    , Alternative
+    , Monad
+    , MonadPlus
+    , MonadTrans
+    , MonadFix
+    , MonadRef
+    , MonadAtomicRef
+    , MonadIO
+    , MonadCatch
+    , MonadThrow
+#ifdef MIN_VERSION_haskeline
+    , MonadException
+#endif
+    )
+
+instance (Monad m, Num i) => MonadFreshId i (FreshIdT i m) where
+  freshId = FreshIdT $ get <* modify (+ 1)
+
+runFreshIdT :: Functor m => i -> FreshIdT i m a -> m a
+runFreshIdT i m = fst <$> runStateT (unFreshIdT m) i
+
+instance MonadFreshId i m => MonadFreshId i (ReaderT r m)
+instance (Monoid w, MonadFreshId i m) => MonadFreshId i (WriterT w m)
+instance MonadFreshId i m => MonadFreshId i (ExceptT e m)
+instance MonadFreshId i m => MonadFreshId i (StateT s m)
+
+-- Orphan instance needed by Infer.hs and Lint.hs
+
+-- Since there's no forking, it's automatically atomic.
+instance MonadAtomicRef (ST s) where
+  atomicModifyRef r f = do
+    v <- readRef r
+    let (a, b) = f v
+    writeRef r a
+    return b
+  atomicModifyRef' r f = do
+    v <- readRef r
+    let (a, b) = f v
+    writeRef r $! a
+    return b

src/Nix/Lint.hs

@@ -45,6 +45,7 @@ import           Nix.Eval (MonadEval(..))
 import qualified Nix.Eval as Eval
 import           Nix.Expr
 import           Nix.Frames
+import           Nix.Fresh
 import           Nix.String
 import           Nix.Options
 import           Nix.Scope

src/Nix/Thunk.hs

@@ -1,101 +1,38 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE ConstraintKinds #-}
-{-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE DeriveFoldable #-}
 {-# LANGUAGE DeriveFunctor #-}
 {-# LANGUAGE DeriveTraversable #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TupleSections #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
 
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 module Nix.Thunk where
 
-import Control.Applicative
 import Control.Exception hiding (catch)
 import Control.Monad.Catch
-import Control.Monad.Except
-import Control.Monad.Reader
 import Control.Monad.Ref
-import Control.Monad.State.Strict
-import Control.Monad.ST
-import Control.Monad.Writer
 import Data.GADT.Compare
 import Data.IORef
 import Data.Maybe
 import Data.STRef
 import Data.Typeable
-#ifdef MIN_VERSION_haskeline
-import System.Console.Haskeline.MonadException hiding (catch)
-#endif
 
 import Unsafe.Coerce
 
+import Nix.Fresh
 import Nix.Utils
 
--- Since there's no forking, it's automatically atomic.
-instance MonadAtomicRef (ST s) where
-  atomicModifyRef r f = do
-    v <- readRef r
-    let (a, b) = f v
-    writeRef r a
-    return b
-  atomicModifyRef' r f = do
-    v <- readRef r
-    let (a, b) = f v
-    writeRef r $! a
-    return b
-
 data Deferred m v = Deferred (m v) | Computed v
     deriving (Functor, Foldable, Traversable)
 
 type Var m = Ref m
 
--- TODO better fresh name supply
-class Monad m => MonadFreshId i m | m -> i where
-  freshId :: m i
-  default freshId :: (MonadFreshId i m', MonadTrans t, m ~ (t m')) => m i
-  freshId = lift freshId
-
-newtype FreshIdT i m a = FreshIdT { unFreshIdT :: StateT i m a }
-  deriving
-    ( Functor
-    , Applicative
-    , Alternative
-    , Monad
-    , MonadPlus
-    , MonadTrans
-    , MonadFix
-    , MonadRef
-    , MonadAtomicRef
-    , MonadIO
-    , MonadCatch
-    , MonadThrow
-#ifdef MIN_VERSION_haskeline
-    , MonadException
-#endif
-    )
-
-instance (Monad m, Num i) => MonadFreshId i (FreshIdT i m) where
-  freshId = FreshIdT $ get <* modify (+ 1)
-
-runFreshIdT :: Functor m => i -> FreshIdT i m a -> m a
-runFreshIdT i m = fst <$> runStateT (unFreshIdT m) i
-
-instance MonadFreshId i m => MonadFreshId i (ReaderT r m)
-instance (Monoid w, MonadFreshId i m) => MonadFreshId i (WriterT w m)
-instance MonadFreshId i m => MonadFreshId i (ExceptT e m)
-instance MonadFreshId i m => MonadFreshId i (StateT s m)
-
 --TODO: Eliminate the old MonadVar shims
 type MonadVar m =
   ( MonadAtomicRef m

src/Nix/Type/Infer.hs

@@ -49,6 +49,7 @@ import           Nix.Eval (MonadEval(..))
 import qualified Nix.Eval as Eval
 import           Nix.Expr.Types
 import           Nix.Expr.Types.Annotated
+import           Nix.Fresh
 import           Nix.String
 import           Nix.Scope
 import           Nix.Thunk