From bfed38e678ed4aa20540c80232ab97826e0f4a29 Mon Sep 17 00:00:00 2001 From: Anton-Latukha Date: Mon, 31 May 2021 16:30:22 +0300 Subject: [PATCH] Var: reduce module See: https://github.com/haskell-nix/hnix/issues/946 --- ChangeLog.md | 17 +++++++++++------ main/Main.hs | 6 +++--- src/Nix/Fresh.hs | 11 +++++------ src/Nix/Lint.hs | 31 +++++++++++++++---------------- src/Nix/Standard.hs | 10 +++++----- src/Nix/Thunk/Basic.hs | 30 ++++++++++++++++-------------- src/Nix/Type/Infer.hs | 5 ++--- src/Nix/Var.hs | 26 +------------------------- 8 files changed, 58 insertions(+), 78 deletions(-) diff --git a/ChangeLog.md b/ChangeLog.md index 6d84b2ab1..10b5872fe 100644 --- a/ChangeLog.md +++ b/ChangeLog.md @@ -3,11 +3,20 @@ ## [(diff)](https://github.com/haskell-nix/hnix/compare/0.13.1...master#files_bucket) WIP -Breaking: +* Breaking: * `Nix.Effects`: * rm `pathExits` in favour of `doesPathExist` (in `Nix.Render`: `class MonadFile`: `doesPathExist`) + * `Nix.Var`: was found being superflous ([report](https://github.com/haskell-nix/hnix/issues/946)), so reduced. use `Control.Monad.Ref` instead. + + * `Nix.Normal` + * rename `opaque(,->Val)`, indicate that it is a literal. + + * `Nix.Thunk`: + * `class MonadThunkId m => MonadThunk{,F} t m a`: + * rename `query(M->){,F}` + * Additional: * `Nix.Utils`: @@ -25,6 +34,7 @@ Breaking: * `Nix.Type.Env`: * added instances: * `Env`: `{Semigroup,Monoid,One}` + * `Nix`: * changed argument order: * `nixEval`: @@ -38,11 +48,6 @@ Breaking: * `Nix.Normal` * add `thunkVal` literal & use it where appropriate `{deThunk, removeEffects}` - * rename `opaque(,->Val)`, indicate that it is a literal. - - * `Nix.Thunk`: - * `class MonadThunkId m => MonadThunk{,F} t m a`: - * rename `query(M->){,F}` ### [(diff)](https://github.com/haskell-nix/hnix/compare/0.13.0.1...0.13.1#files_bucket) 0.13.1 (2021-05-22) diff --git a/main/Main.hs b/main/Main.hs index ae376538f..137a6884d 100644 --- a/main/Main.hs +++ b/main/Main.hs @@ -10,9 +10,10 @@ import Control.Comonad ( extract ) import qualified Control.DeepSeq as Deep import qualified Control.Exception as Exc import GHC.Err ( errorWithoutStackTrace ) +import Control.Monad.Free +import Control.Monad.Ref ( MonadRef(readRef) ) import Control.Monad.Catch import System.IO ( hPutStrLn, getContents ) -import Control.Monad.Free import qualified Data.HashMap.Lazy as M import qualified Data.Map as Map import Data.Maybe ( fromJust ) @@ -29,7 +30,6 @@ import Nix.Standard import Nix.Thunk.Basic import qualified Nix.Type.Env as Env import qualified Nix.Type.Infer as HM -import Nix.Var import Nix.Value.Monad import Options.Applicative hiding ( ParserResult(..) ) import Prettyprinter hiding ( list ) @@ -184,7 +184,7 @@ main = path = prefix <> k (_, descend) = filterEntry path k - val <- readVar @(StandardT (StdIdT IO)) ref + val <- readRef @(StandardT (StdIdT IO)) ref case val of Computed _ -> pure (k, Nothing) _ -> diff --git a/src/Nix/Fresh.hs b/src/Nix/Fresh.hs index ee29f6e8a..5fe4d5d32 100644 --- a/src/Nix/Fresh.hs +++ b/src/Nix/Fresh.hs @@ -15,14 +15,13 @@ import Control.Monad.Catch ( MonadCatch ) import Control.Monad.Except ( MonadFix ) import Control.Monad.Ref ( MonadAtomicRef(..) - , MonadRef() + , MonadRef(Ref) ) -import Nix.Var import Nix.Thunk -newtype FreshIdT i m a = FreshIdT { unFreshIdT :: ReaderT (Var m i) m a } +newtype FreshIdT i m a = FreshIdT { unFreshIdT :: ReaderT (Ref m i) m a } deriving ( Functor , Applicative @@ -46,7 +45,7 @@ instance MonadBase b m => MonadBase b (FreshIdT i m) where liftBase = FreshIdT . liftBase instance - ( MonadVar m + ( MonadAtomicRef m , Eq i , Ord i , Show i @@ -58,7 +57,7 @@ instance type ThunkId (FreshIdT i m) = i freshId = FreshIdT $ do v <- ask - atomicModifyVar v (\i -> (succ i, i)) + atomicModifyRef v (\i -> (succ i, i)) -runFreshIdT :: Functor m => Var m i -> FreshIdT i m a -> m a +runFreshIdT :: Functor m => Ref m i -> FreshIdT i m a -> m a runFreshIdT i m = runReaderT (unFreshIdT m) i diff --git a/src/Nix/Lint.hs b/src/Nix/Lint.hs index 3dbe971de..f76addfae 100644 --- a/src/Nix/Lint.hs +++ b/src/Nix/Lint.hs @@ -39,7 +39,6 @@ import Nix.Options import Nix.Scope import Nix.Thunk import Nix.Thunk.Basic -import Nix.Var import Nix.Value.Monad data TAtom @@ -87,7 +86,7 @@ data NSymbolicF r type SThunk (m :: * -> *) = NThunkF m (Symbolic m) -type SValue (m :: * -> *) = Var m (NSymbolicF (NTypeF m (Symbolic m))) +type SValue (m :: * -> *) = Ref m (NSymbolicF (NTypeF m (Symbolic m))) data Symbolic m = SV { getSV :: SValue m } | ST { getST :: SThunk m } @@ -95,32 +94,32 @@ instance Show (Symbolic m) where show _ = "" everyPossible - :: MonadVar m + :: MonadAtomicRef m => m (Symbolic m) everyPossible = packSymbolic NAny mkSymbolic - :: MonadVar m + :: MonadAtomicRef m => [NTypeF m (Symbolic m)] -> m (Symbolic m) mkSymbolic xs = packSymbolic (NMany xs) packSymbolic - :: MonadVar m + :: MonadAtomicRef m => NSymbolicF (NTypeF m (Symbolic m)) -> m (Symbolic m) -packSymbolic = fmap SV . newVar +packSymbolic = fmap SV . newRef unpackSymbolic - :: (MonadVar m, MonadThunkId m, MonadCatch m) + :: (MonadAtomicRef m, MonadThunkId m, MonadCatch m) => Symbolic m -> m (NSymbolicF (NTypeF m (Symbolic m))) -unpackSymbolic = readVar . getSV <=< demand +unpackSymbolic = readRef . getSV <=< demand type MonadLint e m = ( Scoped (Symbolic m) m , Framed e m - , MonadVar m + , MonadAtomicRef m , MonadCatch m , MonadThunkId m ) @@ -237,21 +236,21 @@ unify -> Symbolic m -> m (Symbolic m) unify context (SV x) (SV y) = do - x' <- readVar x - y' <- readVar y + x' <- readRef x + y' <- readRef y case (x', y') of (NAny, _) -> do - writeVar x y' + writeRef x y' pure $ SV y (_, NAny) -> do - writeVar y x' + writeRef y x' pure $ SV x (NMany xs, NMany ys) -> do m <- merge context xs ys bool (do - writeVar x (NMany m) - writeVar y (NMany m) + writeRef x (NMany m) + writeRef y (NMany m) packSymbolic (NMany m) ) (do @@ -468,7 +467,7 @@ instance MonadCatch (Lint s) where runLintM :: Options -> Lint s a -> ST s a runLintM opts action = do - i <- newVar (1 :: Int) + i <- newRef (1 :: Int) runFreshIdT i $ (`runReaderT` newContext opts) $ runLint action symbolicBaseEnv diff --git a/src/Nix/Standard.hs b/src/Nix/Standard.hs index e7fb92125..7509b27d1 100644 --- a/src/Nix/Standard.hs +++ b/src/Nix/Standard.hs @@ -9,7 +9,7 @@ module Nix.Standard where -import Control.Applicative +import Prelude hiding ( force ) import Control.Comonad ( Comonad ) import Control.Comonad.Env ( ComonadEnv ) import Control.Monad.Catch ( MonadThrow @@ -21,7 +21,9 @@ import Control.Monad.Fail ( MonadFail ) #endif import Control.Monad.Free ( Free(Pure, Free) ) import Control.Monad.Reader ( MonadFix ) -import Control.Monad.Ref ( MonadAtomicRef ) +import Control.Monad.Ref ( MonadRef(newRef) + , MonadAtomicRef + ) import qualified Text.Show import Nix.Cited import Nix.Cited.Basic @@ -41,8 +43,6 @@ import Nix.Utils ( free ) import Nix.Utils.Fix1 ( Fix1T(Fix1T) ) import Nix.Value import Nix.Value.Monad -import Nix.Var -import Prelude hiding (force) newtype StdCited m a = @@ -345,7 +345,7 @@ runWithBasicEffects opts = go . (`evalStateT` mempty) . (`runReaderT` newContext opts) . runStandardT where go action = do - i <- newVar (1 :: Int) + i <- newRef (1 :: Int) runFreshIdT i action runWithBasicEffectsIO :: Options -> StandardT (StdIdT IO) a -> IO a diff --git a/src/Nix/Thunk/Basic.hs b/src/Nix/Thunk/Basic.hs index 470a80541..e84a5ca7c 100644 --- a/src/Nix/Thunk/Basic.hs +++ b/src/Nix/Thunk/Basic.hs @@ -12,12 +12,14 @@ module Nix.Thunk.Basic import Prelude hiding ( force ) import Relude.Extra ( dup ) +import Control.Monad.Ref ( MonadRef(Ref, newRef, readRef, writeRef) + , MonadAtomicRef(atomicModifyRef) + ) import Control.Monad.Catch ( MonadCatch(..) , MonadThrow(throwM) ) import qualified Text.Show import Nix.Thunk -import Nix.Var -- * Data type @Deferred@ @@ -43,10 +45,10 @@ deferred f1 f2 = -- | Thunk resource reference (@ref-tf: Ref m@), and as such also also hold -- a @Bool@ lock flag. -type ThunkRef m = Var m Bool +type ThunkRef m = Ref m Bool -- | Reference (@ref-tf: Ref m v@) to a value that the thunk holds. -type ThunkValueRef m v = Var m (Deferred m v) +type ThunkValueRef m v = Ref m (Deferred m v) -- | @ref-tf@ lock instruction for @Ref m@ (@ThunkRef@). lock :: Bool -> (Bool, Bool) @@ -63,7 +65,7 @@ lockThunk ) => ThunkRef m -> m Bool -lockThunk r = atomicModifyVar r lock +lockThunk r = atomicModifyRef r lock -- | Takes @ref-tf: Ref m@ reference, returns Bool result of the operation. unlockThunk @@ -72,7 +74,7 @@ unlockThunk ) => ThunkRef m -> m Bool -unlockThunk r = atomicModifyVar r unlock +unlockThunk r = atomicModifyRef r unlock -- * Data type for thunks: @NThunkF@ @@ -87,7 +89,7 @@ instance (Eq v, Eq (ThunkId m)) => Eq (NThunkF m v) where instance Show (NThunkF m v) where show Thunk{} = "" -type MonadBasicThunk m = (MonadThunkId m, MonadVar m) +type MonadBasicThunk m = (MonadThunkId m, MonadAtomicRef m) -- ** @instance MonadThunk NThunkF@ @@ -103,13 +105,13 @@ instance (MonadBasicThunk m, MonadCatch m) do freshThunkId <- freshId liftA2 (Thunk freshThunkId) - (newVar False ) - (newVar $ Deferred action) + (newRef False ) + (newRef $ Deferred action) query :: m v -> NThunkF m v -> m v query vStub (Thunk _ _ lTValRef) = do - v <- readVar lTValRef + v <- readRef lTValRef deferred pure (const vStub) v force :: NThunkF m v -> m v @@ -122,7 +124,7 @@ instance (MonadBasicThunk m, MonadCatch m) further t@(Thunk _ _ ref) = do _ <- - atomicModifyVar + atomicModifyRef ref dup pure t @@ -142,7 +144,7 @@ forceMain -> m v forceMain (Thunk vTId vTRef vTValRef) = do - v <- readVar vTValRef + v <- readRef vTValRef deferred pure fCompute v where fCompute vDefferred = @@ -152,7 +154,7 @@ forceMain (Thunk vTId vTRef vTValRef) = fLockFailed (do v <- vDefferred `catch` fBindFailed - writeVar vTValRef $ Computed v -- Proclaim value computed + writeRef vTValRef $ Computed v -- Proclaim value computed unlockRef pure v ) @@ -190,7 +192,7 @@ instance (MonadBasicThunk m, MonadCatch m) where go = do - eres <- readVar thunkValRef + eres <- readRef thunkValRef res <- deferred k @@ -217,7 +219,7 @@ instance (MonadBasicThunk m, MonadCatch m) -> m (NThunkF m v) furtherF k t@(Thunk _ _ ref) = do - _modifiedIt <- atomicModifyVar ref $ + _modifiedIt <- atomicModifyRef ref $ \x -> deferred (const (x, x)) diff --git a/src/Nix/Type/Infer.hs b/src/Nix/Type/Infer.hs index cbc3ef760..c385b8ab5 100644 --- a/src/Nix/Type/Infer.hs +++ b/src/Nix/Type/Infer.hs @@ -72,7 +72,6 @@ import Nix.Type.Env import qualified Nix.Type.Env as Env import Nix.Type.Type import Nix.Value.Monad -import Nix.Var normalizeScheme :: Scheme -> Scheme @@ -645,7 +644,7 @@ instance ActiveTypeVars a => ActiveTypeVars [a] where type MonadInfer m = ({- MonadThunkId m,-} - MonadVar m, MonadFix m) + MonadAtomicRef m, MonadFix m) -- | Run the inference monad runInfer' :: MonadInfer m => InferT s m a -> m (Either InferError a) @@ -659,7 +658,7 @@ runInfer :: (forall s . InferT s (FreshIdT Int (ST s)) a) -> Either InferError a runInfer m = runST $ do - i <- newVar (1 :: Int) + i <- newRef (1 :: Int) runFreshIdT i $ runInfer' m inferType diff --git a/src/Nix/Var.hs b/src/Nix/Var.hs index 75c16e8d8..40c5cd167 100644 --- a/src/Nix/Var.hs +++ b/src/Nix/Var.hs @@ -5,15 +5,7 @@ {-# OPTIONS_GHC -Wno-orphans #-} -module Nix.Var - ( Var - , MonadVar - , eqVar - , newVar - , readVar - , writeVar - , atomicModifyVar - ) +module Nix.Var () where import Control.Monad.Ref @@ -23,25 +15,9 @@ import Type.Reflection ( (:~:)(Refl) ) import Unsafe.Coerce ( unsafeCoerce ) -type Var m = Ref m - -type MonadVar m = MonadAtomicRef m - eqVar :: GEq (Ref m) => Ref m a -> Ref m a -> Bool eqVar a b = isJust $ geq a b -newVar :: MonadRef m => a -> m (Ref m a) -newVar = newRef - -readVar :: MonadRef m => Ref m a -> m a -readVar = readRef - -writeVar :: MonadRef m => Ref m a -> a -> m () -writeVar = writeRef - -atomicModifyVar :: MonadAtomicRef m => Ref m a -> (a -> (a, b)) -> m b -atomicModifyVar = atomicModifyRef - --TODO: Upstream GEq instances -- Upstream thread: https://github.com/haskellari/some/pull/34 instance GEq IORef where