{-# language TypeFamilies #-}
{-# language CPP #-}
{-# language GeneralizedNewtypeDeriving #-}
{-# language UndecidableInstances #-}

{-# options_ghc -Wno-orphans #-}


module Nix.Standard where

import           Nix.Prelude
import           Control.Comonad                ( Comonad )
import           Control.Comonad.Env            ( ComonadEnv )
import           Control.Monad.Catch            ( MonadThrow
                                                , MonadCatch
                                                , MonadMask
                                                )
#if !MIN_VERSION_base(4,13,0)
import           Control.Monad.Fail             ( MonadFail )
#endif
import           Control.Monad.Free             ( Free(Free) )
import           Control.Monad.Reader           ( MonadFix )
import           Control.Monad.Ref              ( MonadRef(newRef)
                                                , MonadAtomicRef
                                                )
import qualified Text.Show
import           Nix.Cited
import           Nix.Cited.Basic
import           Nix.Context
import           Nix.Effects
import           Nix.Effects.Basic
import           Nix.Effects.Derivation
import           Nix.Expr.Types.Annotated
import           Nix.Fresh
import           Nix.Fresh.Basic
import           Nix.Options
import           Nix.Render
import           Nix.Scope
import           Nix.Thunk
import           Nix.Thunk.Basic
import           Nix.Utils.Fix1                 ( Fix1T(Fix1T) )
import           Nix.Value
import           Nix.Value.Monad


newtype StdCited m a =
  StdCited
    (Cited (StdThunk m) (StdCited m) m a)
  deriving
    ( (forall x. StdCited m a -> Rep (StdCited m a) x)
-> (forall x. Rep (StdCited m a) x -> StdCited m a)
-> Generic (StdCited m a)
forall x. Rep (StdCited m a) x -> StdCited m a
forall x. StdCited m a -> Rep (StdCited m a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (m :: * -> *) a x. Rep (StdCited m a) x -> StdCited m a
forall (m :: * -> *) a x. StdCited m a -> Rep (StdCited m a) x
$cto :: forall (m :: * -> *) a x. Rep (StdCited m a) x -> StdCited m a
$cfrom :: forall (m :: * -> *) a x. StdCited m a -> Rep (StdCited m a) x
Generic
    , Typeable
    , a -> StdCited m b -> StdCited m a
(a -> b) -> StdCited m a -> StdCited m b
(forall a b. (a -> b) -> StdCited m a -> StdCited m b)
-> (forall a b. a -> StdCited m b -> StdCited m a)
-> Functor (StdCited m)
forall a b. a -> StdCited m b -> StdCited m a
forall a b. (a -> b) -> StdCited m a -> StdCited m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (m :: * -> *) a b. a -> StdCited m b -> StdCited m a
forall (m :: * -> *) a b. (a -> b) -> StdCited m a -> StdCited m b
<$ :: a -> StdCited m b -> StdCited m a
$c<$ :: forall (m :: * -> *) a b. a -> StdCited m b -> StdCited m a
fmap :: (a -> b) -> StdCited m a -> StdCited m b
$cfmap :: forall (m :: * -> *) a b. (a -> b) -> StdCited m a -> StdCited m b
Functor
    , Functor (StdCited m)
a -> StdCited m a
Functor (StdCited m)
-> (forall a. a -> StdCited m a)
-> (forall a b.
    StdCited m (a -> b) -> StdCited m a -> StdCited m b)
-> (forall a b c.
    (a -> b -> c) -> StdCited m a -> StdCited m b -> StdCited m c)
-> (forall a b. StdCited m a -> StdCited m b -> StdCited m b)
-> (forall a b. StdCited m a -> StdCited m b -> StdCited m a)
-> Applicative (StdCited m)
StdCited m a -> StdCited m b -> StdCited m b
StdCited m a -> StdCited m b -> StdCited m a
StdCited m (a -> b) -> StdCited m a -> StdCited m b
(a -> b -> c) -> StdCited m a -> StdCited m b -> StdCited m c
forall a. a -> StdCited m a
forall a b. StdCited m a -> StdCited m b -> StdCited m a
forall a b. StdCited m a -> StdCited m b -> StdCited m b
forall a b. StdCited m (a -> b) -> StdCited m a -> StdCited m b
forall a b c.
(a -> b -> c) -> StdCited m a -> StdCited m b -> StdCited m c
forall (m :: * -> *). Functor (StdCited m)
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (m :: * -> *) a. a -> StdCited m a
forall (m :: * -> *) a b.
StdCited m a -> StdCited m b -> StdCited m a
forall (m :: * -> *) a b.
StdCited m a -> StdCited m b -> StdCited m b
forall (m :: * -> *) a b.
StdCited m (a -> b) -> StdCited m a -> StdCited m b
forall (m :: * -> *) a b c.
(a -> b -> c) -> StdCited m a -> StdCited m b -> StdCited m c
<* :: StdCited m a -> StdCited m b -> StdCited m a
$c<* :: forall (m :: * -> *) a b.
StdCited m a -> StdCited m b -> StdCited m a
*> :: StdCited m a -> StdCited m b -> StdCited m b
$c*> :: forall (m :: * -> *) a b.
StdCited m a -> StdCited m b -> StdCited m b
liftA2 :: (a -> b -> c) -> StdCited m a -> StdCited m b -> StdCited m c
$cliftA2 :: forall (m :: * -> *) a b c.
(a -> b -> c) -> StdCited m a -> StdCited m b -> StdCited m c
<*> :: StdCited m (a -> b) -> StdCited m a -> StdCited m b
$c<*> :: forall (m :: * -> *) a b.
StdCited m (a -> b) -> StdCited m a -> StdCited m b
pure :: a -> StdCited m a
$cpure :: forall (m :: * -> *) a. a -> StdCited m a
$cp1Applicative :: forall (m :: * -> *). Functor (StdCited m)
Applicative
    , a -> StdCited m a -> Bool
StdCited m m -> m
StdCited m a -> [a]
StdCited m a -> Bool
StdCited m a -> Int
StdCited m a -> a
StdCited m a -> a
StdCited m a -> a
StdCited m a -> a
(a -> m) -> StdCited m a -> m
(a -> m) -> StdCited m a -> m
(a -> b -> b) -> b -> StdCited m a -> b
(a -> b -> b) -> b -> StdCited m a -> b
(b -> a -> b) -> b -> StdCited m a -> b
(b -> a -> b) -> b -> StdCited m a -> b
(a -> a -> a) -> StdCited m a -> a
(a -> a -> a) -> StdCited m a -> a
(forall m. Monoid m => StdCited m m -> m)
-> (forall m a. Monoid m => (a -> m) -> StdCited m a -> m)
-> (forall m a. Monoid m => (a -> m) -> StdCited m a -> m)
-> (forall a b. (a -> b -> b) -> b -> StdCited m a -> b)
-> (forall a b. (a -> b -> b) -> b -> StdCited m a -> b)
-> (forall b a. (b -> a -> b) -> b -> StdCited m a -> b)
-> (forall b a. (b -> a -> b) -> b -> StdCited m a -> b)
-> (forall a. (a -> a -> a) -> StdCited m a -> a)
-> (forall a. (a -> a -> a) -> StdCited m a -> a)
-> (forall a. StdCited m a -> [a])
-> (forall a. StdCited m a -> Bool)
-> (forall a. StdCited m a -> Int)
-> (forall a. Eq a => a -> StdCited m a -> Bool)
-> (forall a. Ord a => StdCited m a -> a)
-> (forall a. Ord a => StdCited m a -> a)
-> (forall a. Num a => StdCited m a -> a)
-> (forall a. Num a => StdCited m a -> a)
-> Foldable (StdCited m)
forall a. Eq a => a -> StdCited m a -> Bool
forall a. Num a => StdCited m a -> a
forall a. Ord a => StdCited m a -> a
forall m. Monoid m => StdCited m m -> m
forall a. StdCited m a -> Bool
forall a. StdCited m a -> Int
forall a. StdCited m a -> [a]
forall a. (a -> a -> a) -> StdCited m a -> a
forall m a. Monoid m => (a -> m) -> StdCited m a -> m
forall b a. (b -> a -> b) -> b -> StdCited m a -> b
forall a b. (a -> b -> b) -> b -> StdCited m a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
forall (m :: * -> *) a. Eq a => a -> StdCited m a -> Bool
forall (m :: * -> *) a. Num a => StdCited m a -> a
forall (m :: * -> *) a. Ord a => StdCited m a -> a
forall (m :: * -> *) m. Monoid m => StdCited m m -> m
forall (m :: * -> *) a. StdCited m a -> Bool
forall (m :: * -> *) a. StdCited m a -> Int
forall (m :: * -> *) a. StdCited m a -> [a]
forall (m :: * -> *) a. (a -> a -> a) -> StdCited m a -> a
forall (m :: * -> *) m a. Monoid m => (a -> m) -> StdCited m a -> m
forall (m :: * -> *) b a. (b -> a -> b) -> b -> StdCited m a -> b
forall (m :: * -> *) a b. (a -> b -> b) -> b -> StdCited m a -> b
product :: StdCited m a -> a
$cproduct :: forall (m :: * -> *) a. Num a => StdCited m a -> a
sum :: StdCited m a -> a
$csum :: forall (m :: * -> *) a. Num a => StdCited m a -> a
minimum :: StdCited m a -> a
$cminimum :: forall (m :: * -> *) a. Ord a => StdCited m a -> a
maximum :: StdCited m a -> a
$cmaximum :: forall (m :: * -> *) a. Ord a => StdCited m a -> a
elem :: a -> StdCited m a -> Bool
$celem :: forall (m :: * -> *) a. Eq a => a -> StdCited m a -> Bool
length :: StdCited m a -> Int
$clength :: forall (m :: * -> *) a. StdCited m a -> Int
null :: StdCited m a -> Bool
$cnull :: forall (m :: * -> *) a. StdCited m a -> Bool
toList :: StdCited m a -> [a]
$ctoList :: forall (m :: * -> *) a. StdCited m a -> [a]
foldl1 :: (a -> a -> a) -> StdCited m a -> a
$cfoldl1 :: forall (m :: * -> *) a. (a -> a -> a) -> StdCited m a -> a
foldr1 :: (a -> a -> a) -> StdCited m a -> a
$cfoldr1 :: forall (m :: * -> *) a. (a -> a -> a) -> StdCited m a -> a
foldl' :: (b -> a -> b) -> b -> StdCited m a -> b
$cfoldl' :: forall (m :: * -> *) b a. (b -> a -> b) -> b -> StdCited m a -> b
foldl :: (b -> a -> b) -> b -> StdCited m a -> b
$cfoldl :: forall (m :: * -> *) b a. (b -> a -> b) -> b -> StdCited m a -> b
foldr' :: (a -> b -> b) -> b -> StdCited m a -> b
$cfoldr' :: forall (m :: * -> *) a b. (a -> b -> b) -> b -> StdCited m a -> b
foldr :: (a -> b -> b) -> b -> StdCited m a -> b
$cfoldr :: forall (m :: * -> *) a b. (a -> b -> b) -> b -> StdCited m a -> b
foldMap' :: (a -> m) -> StdCited m a -> m
$cfoldMap' :: forall (m :: * -> *) m a. Monoid m => (a -> m) -> StdCited m a -> m
foldMap :: (a -> m) -> StdCited m a -> m
$cfoldMap :: forall (m :: * -> *) m a. Monoid m => (a -> m) -> StdCited m a -> m
fold :: StdCited m m -> m
$cfold :: forall (m :: * -> *) m. Monoid m => StdCited m m -> m
Foldable
    , Functor (StdCited m)
Foldable (StdCited m)
Functor (StdCited m)
-> Foldable (StdCited m)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> StdCited m a -> f (StdCited m b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    StdCited m (f a) -> f (StdCited m a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> StdCited m a -> m (StdCited m b))
-> (forall (m :: * -> *) a.
    Monad m =>
    StdCited m (m a) -> m (StdCited m a))
-> Traversable (StdCited m)
(a -> f b) -> StdCited m a -> f (StdCited m b)
forall (m :: * -> *). Functor (StdCited m)
forall (m :: * -> *). Foldable (StdCited m)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
StdCited m (m a) -> m (StdCited m a)
forall (f :: * -> *) a.
Applicative f =>
StdCited m (f a) -> f (StdCited m a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> StdCited m a -> m (StdCited m b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> StdCited m a -> f (StdCited m b)
forall (m :: * -> *) (m :: * -> *) a.
Monad m =>
StdCited m (m a) -> m (StdCited m a)
forall (m :: * -> *) (f :: * -> *) a.
Applicative f =>
StdCited m (f a) -> f (StdCited m a)
forall (m :: * -> *) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> StdCited m a -> m (StdCited m b)
forall (m :: * -> *) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> StdCited m a -> f (StdCited m b)
sequence :: StdCited m (m a) -> m (StdCited m a)
$csequence :: forall (m :: * -> *) (m :: * -> *) a.
Monad m =>
StdCited m (m a) -> m (StdCited m a)
mapM :: (a -> m b) -> StdCited m a -> m (StdCited m b)
$cmapM :: forall (m :: * -> *) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> StdCited m a -> m (StdCited m b)
sequenceA :: StdCited m (f a) -> f (StdCited m a)
$csequenceA :: forall (m :: * -> *) (f :: * -> *) a.
Applicative f =>
StdCited m (f a) -> f (StdCited m a)
traverse :: (a -> f b) -> StdCited m a -> f (StdCited m b)
$ctraverse :: forall (m :: * -> *) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> StdCited m a -> f (StdCited m b)
$cp2Traversable :: forall (m :: * -> *). Foldable (StdCited m)
$cp1Traversable :: forall (m :: * -> *). Functor (StdCited m)
Traversable
    , Functor (StdCited m)
Functor (StdCited m)
-> (forall a. StdCited m a -> a)
-> (forall a. StdCited m a -> StdCited m (StdCited m a))
-> (forall a b.
    (StdCited m a -> b) -> StdCited m a -> StdCited m b)
-> Comonad (StdCited m)
StdCited m a -> a
StdCited m a -> StdCited m (StdCited m a)
(StdCited m a -> b) -> StdCited m a -> StdCited m b
forall a. StdCited m a -> a
forall a. StdCited m a -> StdCited m (StdCited m a)
forall a b. (StdCited m a -> b) -> StdCited m a -> StdCited m b
forall (m :: * -> *). Functor (StdCited m)
forall (w :: * -> *).
Functor w
-> (forall a. w a -> a)
-> (forall a. w a -> w (w a))
-> (forall a b. (w a -> b) -> w a -> w b)
-> Comonad w
forall (m :: * -> *) a. StdCited m a -> a
forall (m :: * -> *) a. StdCited m a -> StdCited m (StdCited m a)
forall (m :: * -> *) a b.
(StdCited m a -> b) -> StdCited m a -> StdCited m b
extend :: (StdCited m a -> b) -> StdCited m a -> StdCited m b
$cextend :: forall (m :: * -> *) a b.
(StdCited m a -> b) -> StdCited m a -> StdCited m b
duplicate :: StdCited m a -> StdCited m (StdCited m a)
$cduplicate :: forall (m :: * -> *) a. StdCited m a -> StdCited m (StdCited m a)
extract :: StdCited m a -> a
$cextract :: forall (m :: * -> *) a. StdCited m a -> a
$cp1Comonad :: forall (m :: * -> *). Functor (StdCited m)
Comonad
    , ComonadEnv [Provenance m (StdValue m)]
    )

newtype StdThunk m =
  StdThunk
    (StdCited m (NThunkF m (StdValue m)))
type StdValue' m = NValue' (StdThunk m) (StdCited m) m (StdValue m)
type StdValue m = NValue (StdThunk m) (StdCited m) m
type StandardIO = StandardT (StdIdT IO)
type StdVal = StdValue StandardIO
type StdThun = StdThunk StandardIO
type StdIO = StandardIO ()

-- | Type alias:
--
-- > Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
type CitedStdThunk m = Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))

instance Show (StdThunk m) where
  show :: StdThunk m -> String
show StdThunk m
_ = Text -> String
forall a. ToString a => a -> String
toString Text
thunkStubText

instance HasCitations1 m (StdValue m) (StdCited m) where
  citations1 :: StdCited m a -> [Provenance m (StdValue m)]
citations1 (StdCited Cited (StdThunk m) (StdCited m) m a
c) = Cited (StdThunk m) (StdCited m) m a -> [Provenance m (StdValue m)]
forall (m :: * -> *) v (f :: * -> *) a.
HasCitations1 m v f =>
f a -> [Provenance m v]
citations1 Cited (StdThunk m) (StdCited m) m a
c
  addProvenance1 :: Provenance m (StdValue m) -> StdCited m a -> StdCited m a
addProvenance1 Provenance m (StdValue m)
x (StdCited Cited (StdThunk m) (StdCited m) m a
c) = Cited (StdThunk m) (StdCited m) m a -> StdCited m a
forall (m :: * -> *) a.
Cited (StdThunk m) (StdCited m) m a -> StdCited m a
StdCited (Cited (StdThunk m) (StdCited m) m a -> StdCited m a)
-> Cited (StdThunk m) (StdCited m) m a -> StdCited m a
forall a b. (a -> b) -> a -> b
$ Provenance m (StdValue m)
-> Cited (StdThunk m) (StdCited m) m a
-> Cited (StdThunk m) (StdCited m) m a
forall (m :: * -> *) v (f :: * -> *) a.
HasCitations1 m v f =>
Provenance m v -> f a -> f a
addProvenance1 Provenance m (StdValue m)
x Cited (StdThunk m) (StdCited m) m a
c

instance HasCitations m (StdValue m) (StdThunk m) where
  citations :: StdThunk m -> [Provenance m (StdValue m)]
citations (StdThunk StdCited m (NThunkF m (StdValue m))
c) = StdCited m (NThunkF m (StdValue m)) -> [Provenance m (StdValue m)]
forall (m :: * -> *) v (f :: * -> *) a.
HasCitations1 m v f =>
f a -> [Provenance m v]
citations1 StdCited m (NThunkF m (StdValue m))
c
  addProvenance :: Provenance m (StdValue m) -> StdThunk m -> StdThunk m
addProvenance Provenance m (StdValue m)
x (StdThunk StdCited m (NThunkF m (StdValue m))
c) = StdCited m (NThunkF m (StdValue m)) -> StdThunk m
forall (m :: * -> *).
StdCited m (NThunkF m (StdValue m)) -> StdThunk m
StdThunk (StdCited m (NThunkF m (StdValue m)) -> StdThunk m)
-> StdCited m (NThunkF m (StdValue m)) -> StdThunk m
forall a b. (a -> b) -> a -> b
$ Provenance m (StdValue m)
-> StdCited m (NThunkF m (StdValue m))
-> StdCited m (NThunkF m (StdValue m))
forall (m :: * -> *) v (f :: * -> *) a.
HasCitations1 m v f =>
Provenance m v -> f a -> f a
addProvenance1 Provenance m (StdValue m)
x StdCited m (NThunkF m (StdValue m))
c

instance MonadReader (Context m (StdValue m)) m => Scoped (StdValue m) m where
  askScopes :: m (Scopes m (StdValue m))
askScopes   = m (Scopes m (StdValue m))
forall (m :: * -> *) a e.
(MonadReader e m, Has e (Scopes m a)) =>
m (Scopes m a)
askScopesReader
  clearScopes :: m r -> m r
clearScopes = forall e r.
(MonadReader e m, Has e (Scopes m (StdValue m))) =>
m r -> m r
forall (m :: * -> *) a e r.
(MonadReader e m, Has e (Scopes m a)) =>
m r -> m r
clearScopesReader @m @(StdValue m)
  pushScopes :: Scopes m (StdValue m) -> m r -> m r
pushScopes  = Scopes m (StdValue m) -> m r -> m r
forall e (m :: * -> *) a r.
(MonadReader e m, Has e (Scopes m a)) =>
Scopes m a -> m r -> m r
pushScopesReader
  lookupVar :: VarName -> m (Maybe (StdValue m))
lookupVar   = VarName -> m (Maybe (StdValue m))
forall (m :: * -> *) a e.
(MonadReader e m, Has e (Scopes m a)) =>
VarName -> m (Maybe a)
lookupVarReader

instance
  ( MonadFix m
  , MonadFile m
  , MonadCatch m
  , MonadEnv m
  , MonadPaths m
  , MonadExec m
  , MonadHttp m
  , MonadInstantiate m
  , MonadIntrospect m
  , MonadPlus m
  , MonadPutStr m
  , MonadStore m
  , MonadAtomicRef m
  , Typeable m
  , Scoped (StdValue m) m
  , MonadReader (Context m (StdValue m)) m
  , MonadState (HashMap Path NExprLoc, HashMap Text Text) m
  , MonadDataErrorContext (StdThunk m) (StdCited m) m
  , MonadThunk (StdThunk m) m (StdValue m)
  , MonadValue (StdValue m) m
  )
  => MonadEffects (StdThunk m) (StdCited m) m where
  toAbsolutePath :: Path -> m Path
toAbsolutePath   = Path -> m Path
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Path -> m Path
defaultToAbsolutePath
  findEnvPath :: String -> m Path
findEnvPath      = String -> m Path
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
String -> m Path
defaultFindEnvPath
  findPath :: [NValue (StdThunk m) (StdCited m) m] -> Path -> m Path
findPath         = [NValue (StdThunk m) (StdCited m) m] -> Path -> m Path
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
[NValue t f m] -> Path -> m Path
defaultFindPath
  importPath :: Path -> m (NValue (StdThunk m) (StdCited m) m)
importPath       = Path -> m (NValue (StdThunk m) (StdCited m) m)
forall e t (f :: * -> *) (m :: * -> *) b.
(MonadNix e t f m, MonadState (HashMap Path NExprLoc, b) m) =>
Path -> m (NValue t f m)
defaultImportPath
  pathToDefaultNix :: Path -> m Path
pathToDefaultNix = Path -> m Path
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Path -> m Path
defaultPathToDefaultNix
  derivationStrict :: NValue (StdThunk m) (StdCited m) m
-> m (NValue (StdThunk m) (StdCited m) m)
derivationStrict = NValue (StdThunk m) (StdCited m) m
-> m (NValue (StdThunk m) (StdCited m) m)
forall e t (f :: * -> *) (m :: * -> *) b.
(MonadNix e t f m, MonadState (b, HashMap Text Text) m) =>
NValue t f m -> m (NValue t f m)
defaultDerivationStrict
  traceEffect :: String -> m ()
traceEffect      = String -> m ()
forall (m :: * -> *). MonadPutStr m => String -> m ()
defaultTraceEffect

-- 2021-07-24:
-- This instance currently is to satisfy @MonadThunk@ requirements for @normalForm@ function.
-- As it is seen from the instance - it does superficial type class jump.
-- It is just a type boundary for thunking.
instance
  ( Typeable       m
  , MonadThunkId   m
  , MonadAtomicRef m
  , MonadCatch     m
  , MonadReader (Context m (StdValue m)) m
  )
  => MonadThunk (StdThunk m) m (StdValue m) where

  thunkId
    :: StdThunk m
    -> ThunkId  m
  thunkId :: StdThunk m -> ThunkId m
thunkId = forall t (m :: * -> *) a. MonadThunk t m a => t -> ThunkId m
forall (m :: * -> *) a.
MonadThunk (CitedStdThunk m) m a =>
CitedStdThunk m -> ThunkId m
thunkId @(CitedStdThunk m) (CitedStdThunk m -> ThunkId m)
-> (StdThunk m -> CitedStdThunk m) -> StdThunk m -> ThunkId m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce
  {-# inline thunkId #-}

  thunk
    :: m (StdValue m)
    -> m (StdThunk m)
  thunk :: m (StdValue m) -> m (StdThunk m)
thunk = (CitedStdThunk m -> StdThunk m)
-> m (CitedStdThunk m) -> m (StdThunk m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CitedStdThunk m -> StdThunk m
coerce (m (CitedStdThunk m) -> m (StdThunk m))
-> (m (StdValue m) -> m (CitedStdThunk m))
-> m (StdValue m)
-> m (StdThunk m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (m :: * -> *) a. MonadThunk t m a => m a -> m t
forall (m :: * -> *) a.
MonadThunk (CitedStdThunk m) m a =>
m a -> m (CitedStdThunk m)
thunk @(CitedStdThunk m)
  {-# inline thunk #-}

  query
    :: m (StdValue m)
    ->    StdThunk m
    -> m (StdValue m)
  query :: m (StdValue m) -> StdThunk m -> m (StdValue m)
query m (StdValue m)
b = m (StdValue m) -> CitedStdThunk m -> m (StdValue m)
forall t (m :: * -> *) a. MonadThunk t m a => m a -> t -> m a
query @(CitedStdThunk m) m (StdValue m)
b (CitedStdThunk m -> m (StdValue m))
-> (StdThunk m -> CitedStdThunk m) -> StdThunk m -> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce
  {-# inline query #-}

  force
    ::    StdThunk m
    -> m (StdValue m)
  force :: StdThunk m -> m (StdValue m)
force = forall t (m :: * -> *) a. MonadThunk t m a => t -> m a
forall (m :: * -> *) a.
MonadThunk (CitedStdThunk m) m a =>
CitedStdThunk m -> m a
force @(CitedStdThunk m) (CitedStdThunk m -> m (StdValue m))
-> (StdThunk m -> CitedStdThunk m) -> StdThunk m -> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce
  {-# inline force #-}

  forceEff
    ::    StdThunk m
    -> m (StdValue m)
  forceEff :: StdThunk m -> m (StdValue m)
forceEff = forall t (m :: * -> *) a. MonadThunk t m a => t -> m a
forall (m :: * -> *) a.
MonadThunk (CitedStdThunk m) m a =>
CitedStdThunk m -> m a
forceEff @(CitedStdThunk m) (CitedStdThunk m -> m (StdValue m))
-> (StdThunk m -> CitedStdThunk m) -> StdThunk m -> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce
  {-# inline forceEff #-}

  further
    ::    StdThunk m
    -> m (StdThunk m)
  further :: StdThunk m -> m (StdThunk m)
further = (CitedStdThunk m -> StdThunk m)
-> m (CitedStdThunk m) -> m (StdThunk m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CitedStdThunk m -> StdThunk m
coerce (m (CitedStdThunk m) -> m (StdThunk m))
-> (StdThunk m -> m (CitedStdThunk m))
-> StdThunk m
-> m (StdThunk m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (m :: * -> *) a. MonadThunk t m a => t -> m t
forall (m :: * -> *) a.
MonadThunk (CitedStdThunk m) m a =>
CitedStdThunk m -> m (CitedStdThunk m)
further @(CitedStdThunk m) (CitedStdThunk m -> m (CitedStdThunk m))
-> (StdThunk m -> CitedStdThunk m)
-> StdThunk m
-> m (CitedStdThunk m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce
  {-# inline further #-}


-- * @instance MonadThunkF@ (Kleisli functor HOFs)

-- Please do not use MonadThunkF instances to define MonadThunk. as MonadThunk uses specialized functions.
instance
  ( Typeable       m
  , MonadThunkId   m
  , MonadAtomicRef m
  , MonadCatch     m
  , MonadReader (Context m (StdValue m)) m
  )
  => MonadThunkF (StdThunk m) m (StdValue m) where

  queryF
    :: ( StdValue m
       -> m r
       )
    -> m r
    -> StdThunk m
    -> m r
  queryF :: (StdValue m -> m r) -> m r -> StdThunk m -> m r
queryF StdValue m -> m r
k m r
b = (StdValue m -> m r) -> m r -> CitedStdThunk m -> m r
forall t (m :: * -> *) a r.
MonadThunkF t m a =>
(a -> m r) -> m r -> t -> m r
queryF @(CitedStdThunk m) StdValue m -> m r
k m r
b (CitedStdThunk m -> m r)
-> (StdThunk m -> CitedStdThunk m) -> StdThunk m -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce

  forceF
    :: ( StdValue m
       -> m r
       )
    -> StdThunk m
    -> m r
  forceF :: (StdValue m -> m r) -> StdThunk m -> m r
forceF StdValue m -> m r
k = (StdValue m -> m r) -> CitedStdThunk m -> m r
forall t (m :: * -> *) a r.
MonadThunkF t m a =>
(a -> m r) -> t -> m r
forceF @(CitedStdThunk m) StdValue m -> m r
k (CitedStdThunk m -> m r)
-> (StdThunk m -> CitedStdThunk m) -> StdThunk m -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce

  forceEffF
    :: ( StdValue m
       -> m r
       )
    -> StdThunk m
    -> m r
  forceEffF :: (StdValue m -> m r) -> StdThunk m -> m r
forceEffF StdValue m -> m r
k = (StdValue m -> m r) -> CitedStdThunk m -> m r
forall t (m :: * -> *) a r.
MonadThunkF t m a =>
(a -> m r) -> t -> m r
forceEffF @(CitedStdThunk m) StdValue m -> m r
k (CitedStdThunk m -> m r)
-> (StdThunk m -> CitedStdThunk m) -> StdThunk m -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce

  furtherF
    :: ( m (StdValue m)
       -> m (StdValue m)
       )
    ->    StdThunk m
    -> m (StdThunk m)
  furtherF :: (m (StdValue m) -> m (StdValue m)) -> StdThunk m -> m (StdThunk m)
furtherF m (StdValue m) -> m (StdValue m)
k = (CitedStdThunk m -> StdThunk m)
-> m (CitedStdThunk m) -> m (StdThunk m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CitedStdThunk m -> StdThunk m
coerce (m (CitedStdThunk m) -> m (StdThunk m))
-> (StdThunk m -> m (CitedStdThunk m))
-> StdThunk m
-> m (StdThunk m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (m (StdValue m) -> m (StdValue m))
-> CitedStdThunk m -> m (CitedStdThunk m)
forall t (m :: * -> *) a.
MonadThunkF t m a =>
(m a -> m a) -> t -> m t
furtherF @(CitedStdThunk m) m (StdValue m) -> m (StdValue m)
k (CitedStdThunk m -> m (CitedStdThunk m))
-> (StdThunk m -> CitedStdThunk m)
-> StdThunk m
-> m (CitedStdThunk m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce


-- * @instance MonadValue (StdValue m) m@

instance
  ( MonadAtomicRef m
  , MonadCatch m
  , Typeable m
  , MonadReader (Context m (StdValue m)) m
  , MonadThunkId m
  )
  => MonadValue (StdValue m) m where

  defer
    :: m (StdValue m)
    -> m (StdValue m)
  defer :: m (StdValue m) -> m (StdValue m)
defer = (CitedStdThunk m -> StdValue m)
-> m (CitedStdThunk m) -> m (StdValue m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (StdThunk m -> StdValue m
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StdThunk m -> StdValue m)
-> (CitedStdThunk m -> StdThunk m) -> CitedStdThunk m -> StdValue m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CitedStdThunk m -> StdThunk m
coerce) (m (CitedStdThunk m) -> m (StdValue m))
-> (m (StdValue m) -> m (CitedStdThunk m))
-> m (StdValue m)
-> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (m :: * -> *) a. MonadThunk t m a => m a -> m t
forall (m :: * -> *) a.
MonadThunk (CitedStdThunk m) m a =>
m a -> m (CitedStdThunk m)
thunk @(CitedStdThunk m)

  demand
    :: StdValue m
    -> m (StdValue m)
  demand :: StdValue m -> m (StdValue m)
demand = StdValue m -> m (StdValue m)
go -- lock to ensure no type class jumps.
   where
    go :: StdValue m -> m (StdValue m)
    go :: StdValue m -> m (StdValue m)
go =
      (StdThunk m -> m (StdValue m))
-> (NValue' (StdThunk m) (StdCited m) m (StdValue m)
    -> m (StdValue m))
-> StdValue m
-> m (StdValue m)
forall a b (f :: * -> *).
(a -> b) -> (f (Free f a) -> b) -> Free f a -> b
free
        (StdValue m -> m (StdValue m)
go (StdValue m -> m (StdValue m))
-> (StdThunk m -> m (StdValue m)) -> StdThunk m -> m (StdValue m)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall t (m :: * -> *) a. MonadThunk t m a => t -> m a
forall (m :: * -> *) a.
MonadThunk (CitedStdThunk m) m a =>
CitedStdThunk m -> m a
force @(CitedStdThunk m) (CitedStdThunk m -> m (StdValue m))
-> (StdThunk m -> CitedStdThunk m) -> StdThunk m -> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce)
        (StdValue m -> m (StdValue m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StdValue m -> m (StdValue m))
-> (NValue' (StdThunk m) (StdCited m) m (StdValue m) -> StdValue m)
-> NValue' (StdThunk m) (StdCited m) m (StdValue m)
-> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NValue' (StdThunk m) (StdCited m) m (StdValue m) -> StdValue m
forall (f :: * -> *) a. f (Free f a) -> Free f a
Free)

  inform
    :: StdValue m
    -> m (StdValue m)
  inform :: StdValue m -> m (StdValue m)
inform = StdValue m -> m (StdValue m)
go -- lock to ensure no type class jumps.
   where
    go :: StdValue m -> m (StdValue m)
    go :: StdValue m -> m (StdValue m)
go =
      (StdThunk m -> m (StdValue m))
-> (NValue' (StdThunk m) (StdCited m) m (StdValue m)
    -> m (StdValue m))
-> StdValue m
-> m (StdValue m)
forall a b (f :: * -> *).
(a -> b) -> (f (Free f a) -> b) -> Free f a -> b
free
        ((StdThunk m -> StdValue m
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StdThunk m -> StdValue m)
-> (CitedStdThunk m -> StdThunk m) -> CitedStdThunk m -> StdValue m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CitedStdThunk m -> StdThunk m
coerce (CitedStdThunk m -> StdValue m)
-> m (CitedStdThunk m) -> m (StdValue m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (m (CitedStdThunk m) -> m (StdValue m))
-> (StdThunk m -> m (CitedStdThunk m))
-> StdThunk m
-> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall t (m :: * -> *) a. MonadThunk t m a => t -> m t
forall (m :: * -> *) a.
MonadThunk (CitedStdThunk m) m a =>
CitedStdThunk m -> m (CitedStdThunk m)
further @(CitedStdThunk m) (CitedStdThunk m -> m (CitedStdThunk m))
-> (StdThunk m -> CitedStdThunk m)
-> StdThunk m
-> m (CitedStdThunk m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> CitedStdThunk m
coerce))
        ((NValue' (StdThunk m) (StdCited m) m (StdValue m) -> StdValue m
forall (f :: * -> *) a. f (Free f a) -> Free f a
Free (NValue' (StdThunk m) (StdCited m) m (StdValue m) -> StdValue m)
-> m (NValue' (StdThunk m) (StdCited m) m (StdValue m))
-> m (StdValue m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (m (NValue' (StdThunk m) (StdCited m) m (StdValue m))
 -> m (StdValue m))
-> (NValue' (StdThunk m) (StdCited m) m (StdValue m)
    -> m (NValue' (StdThunk m) (StdCited m) m (StdValue m)))
-> NValue' (StdThunk m) (StdCited m) m (StdValue m)
-> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall x. m x -> m x)
-> (StdValue m -> m (StdValue m))
-> NValue' (StdThunk m) (StdCited m) m (StdValue m)
-> m (NValue' (StdThunk m) (StdCited m) m (StdValue m))
forall (f :: * -> *) (m :: * -> *) (n :: * -> *) a b t.
(Traversable f, Monad m, Monad n) =>
(forall x. n x -> m x)
-> (a -> n b) -> NValue' t f m a -> n (NValue' t f m b)
bindNValue' forall a. a -> a
forall x. m x -> m x
id StdValue m -> m (StdValue m)
go)


-- * @instance MonadValueF (StdValue m) m@

instance
  ( MonadAtomicRef m
  , MonadCatch m
  , Typeable m
  , MonadReader (Context m (StdValue m)) m
  , MonadThunkId m
  )
  => MonadValueF (StdValue m) m where

  demandF
    :: ( StdValue m
      -> m r
      )
    -> StdValue m
    -> m r
  demandF :: (StdValue m -> m r) -> StdValue m -> m r
demandF StdValue m -> m r
f = StdValue m -> m r
f (StdValue m -> m r)
-> (StdValue m -> m (StdValue m)) -> StdValue m -> m r
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< StdValue m -> m (StdValue m)
forall v (m :: * -> *). MonadValue v m => v -> m v
demand

  informF
    :: ( m (StdValue m)
      -> m (StdValue m)
      )
    -> StdValue m
    -> m (StdValue m)
  informF :: (m (StdValue m) -> m (StdValue m)) -> StdValue m -> m (StdValue m)
informF m (StdValue m) -> m (StdValue m)
f = m (StdValue m) -> m (StdValue m)
f (m (StdValue m) -> m (StdValue m))
-> (StdValue m -> m (StdValue m)) -> StdValue m -> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdValue m -> m (StdValue m)
forall v (m :: * -> *). MonadValue v m => v -> m v
inform


{------------------------------------------------------------------------}

-- jww (2019-03-22): NYI
-- whileForcingThunk
--   :: forall t f m s e r . (Exception s, Convertible e t f m) => s -> m r -> m r
-- whileForcingThunk frame =
--   withFrame Debug (ForcingThunk @t @f @m) . withFrame Debug frame

newtype StandardTF r m a
  = StandardTF
      (ReaderT
        (Context r (StdValue r))
        (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
        a
      )
  deriving
    ( a -> StandardTF r m b -> StandardTF r m a
(a -> b) -> StandardTF r m a -> StandardTF r m b
(forall a b. (a -> b) -> StandardTF r m a -> StandardTF r m b)
-> (forall a b. a -> StandardTF r m b -> StandardTF r m a)
-> Functor (StandardTF r m)
forall a b. a -> StandardTF r m b -> StandardTF r m a
forall a b. (a -> b) -> StandardTF r m a -> StandardTF r m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (r :: * -> *) (m :: * -> *) a b.
Functor m =>
a -> StandardTF r m b -> StandardTF r m a
forall (r :: * -> *) (m :: * -> *) a b.
Functor m =>
(a -> b) -> StandardTF r m a -> StandardTF r m b
<$ :: a -> StandardTF r m b -> StandardTF r m a
$c<$ :: forall (r :: * -> *) (m :: * -> *) a b.
Functor m =>
a -> StandardTF r m b -> StandardTF r m a
fmap :: (a -> b) -> StandardTF r m a -> StandardTF r m b
$cfmap :: forall (r :: * -> *) (m :: * -> *) a b.
Functor m =>
(a -> b) -> StandardTF r m a -> StandardTF r m b
Functor
    , Functor (StandardTF r m)
a -> StandardTF r m a
Functor (StandardTF r m)
-> (forall a. a -> StandardTF r m a)
-> (forall a b.
    StandardTF r m (a -> b) -> StandardTF r m a -> StandardTF r m b)
-> (forall a b c.
    (a -> b -> c)
    -> StandardTF r m a -> StandardTF r m b -> StandardTF r m c)
-> (forall a b.
    StandardTF r m a -> StandardTF r m b -> StandardTF r m b)
-> (forall a b.
    StandardTF r m a -> StandardTF r m b -> StandardTF r m a)
-> Applicative (StandardTF r m)
StandardTF r m a -> StandardTF r m b -> StandardTF r m b
StandardTF r m a -> StandardTF r m b -> StandardTF r m a
StandardTF r m (a -> b) -> StandardTF r m a -> StandardTF r m b
(a -> b -> c)
-> StandardTF r m a -> StandardTF r m b -> StandardTF r m c
forall a. a -> StandardTF r m a
forall a b.
StandardTF r m a -> StandardTF r m b -> StandardTF r m a
forall a b.
StandardTF r m a -> StandardTF r m b -> StandardTF r m b
forall a b.
StandardTF r m (a -> b) -> StandardTF r m a -> StandardTF r m b
forall a b c.
(a -> b -> c)
-> StandardTF r m a -> StandardTF r m b -> StandardTF r m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (r :: * -> *) (m :: * -> *).
Monad m =>
Functor (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) a.
Monad m =>
a -> StandardTF r m a
forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m a -> StandardTF r m b -> StandardTF r m a
forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m a -> StandardTF r m b -> StandardTF r m b
forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m (a -> b) -> StandardTF r m a -> StandardTF r m b
forall (r :: * -> *) (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> StandardTF r m a -> StandardTF r m b -> StandardTF r m c
<* :: StandardTF r m a -> StandardTF r m b -> StandardTF r m a
$c<* :: forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m a -> StandardTF r m b -> StandardTF r m a
*> :: StandardTF r m a -> StandardTF r m b -> StandardTF r m b
$c*> :: forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m a -> StandardTF r m b -> StandardTF r m b
liftA2 :: (a -> b -> c)
-> StandardTF r m a -> StandardTF r m b -> StandardTF r m c
$cliftA2 :: forall (r :: * -> *) (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> StandardTF r m a -> StandardTF r m b -> StandardTF r m c
<*> :: StandardTF r m (a -> b) -> StandardTF r m a -> StandardTF r m b
$c<*> :: forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m (a -> b) -> StandardTF r m a -> StandardTF r m b
pure :: a -> StandardTF r m a
$cpure :: forall (r :: * -> *) (m :: * -> *) a.
Monad m =>
a -> StandardTF r m a
$cp1Applicative :: forall (r :: * -> *) (m :: * -> *).
Monad m =>
Functor (StandardTF r m)
Applicative
    , Applicative (StandardTF r m)
StandardTF r m a
Applicative (StandardTF r m)
-> (forall a. StandardTF r m a)
-> (forall a.
    StandardTF r m a -> StandardTF r m a -> StandardTF r m a)
-> (forall a. StandardTF r m a -> StandardTF r m [a])
-> (forall a. StandardTF r m a -> StandardTF r m [a])
-> Alternative (StandardTF r m)
StandardTF r m a -> StandardTF r m a -> StandardTF r m a
StandardTF r m a -> StandardTF r m [a]
StandardTF r m a -> StandardTF r m [a]
forall a. StandardTF r m a
forall a. StandardTF r m a -> StandardTF r m [a]
forall a. StandardTF r m a -> StandardTF r m a -> StandardTF r m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (r :: * -> *) (m :: * -> *).
MonadPlus m =>
Applicative (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a
forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a -> StandardTF r m [a]
forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a -> StandardTF r m a -> StandardTF r m a
many :: StandardTF r m a -> StandardTF r m [a]
$cmany :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a -> StandardTF r m [a]
some :: StandardTF r m a -> StandardTF r m [a]
$csome :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a -> StandardTF r m [a]
<|> :: StandardTF r m a -> StandardTF r m a -> StandardTF r m a
$c<|> :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a -> StandardTF r m a -> StandardTF r m a
empty :: StandardTF r m a
$cempty :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a
$cp1Alternative :: forall (r :: * -> *) (m :: * -> *).
MonadPlus m =>
Applicative (StandardTF r m)
Alternative
    , Applicative (StandardTF r m)
a -> StandardTF r m a
Applicative (StandardTF r m)
-> (forall a b.
    StandardTF r m a -> (a -> StandardTF r m b) -> StandardTF r m b)
-> (forall a b.
    StandardTF r m a -> StandardTF r m b -> StandardTF r m b)
-> (forall a. a -> StandardTF r m a)
-> Monad (StandardTF r m)
StandardTF r m a -> (a -> StandardTF r m b) -> StandardTF r m b
StandardTF r m a -> StandardTF r m b -> StandardTF r m b
forall a. a -> StandardTF r m a
forall a b.
StandardTF r m a -> StandardTF r m b -> StandardTF r m b
forall a b.
StandardTF r m a -> (a -> StandardTF r m b) -> StandardTF r m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
forall (r :: * -> *) (m :: * -> *).
Monad m =>
Applicative (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) a.
Monad m =>
a -> StandardTF r m a
forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m a -> StandardTF r m b -> StandardTF r m b
forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m a -> (a -> StandardTF r m b) -> StandardTF r m b
return :: a -> StandardTF r m a
$creturn :: forall (r :: * -> *) (m :: * -> *) a.
Monad m =>
a -> StandardTF r m a
>> :: StandardTF r m a -> StandardTF r m b -> StandardTF r m b
$c>> :: forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m a -> StandardTF r m b -> StandardTF r m b
>>= :: StandardTF r m a -> (a -> StandardTF r m b) -> StandardTF r m b
$c>>= :: forall (r :: * -> *) (m :: * -> *) a b.
Monad m =>
StandardTF r m a -> (a -> StandardTF r m b) -> StandardTF r m b
$cp1Monad :: forall (r :: * -> *) (m :: * -> *).
Monad m =>
Applicative (StandardTF r m)
Monad
    , Monad (StandardTF r m)
Monad (StandardTF r m)
-> (forall a. String -> StandardTF r m a)
-> MonadFail (StandardTF r m)
String -> StandardTF r m a
forall a. String -> StandardTF r m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (r :: * -> *) (m :: * -> *).
MonadFail m =>
Monad (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) a.
MonadFail m =>
String -> StandardTF r m a
fail :: String -> StandardTF r m a
$cfail :: forall (r :: * -> *) (m :: * -> *) a.
MonadFail m =>
String -> StandardTF r m a
$cp1MonadFail :: forall (r :: * -> *) (m :: * -> *).
MonadFail m =>
Monad (StandardTF r m)
MonadFail
    , Monad (StandardTF r m)
Alternative (StandardTF r m)
StandardTF r m a
Alternative (StandardTF r m)
-> Monad (StandardTF r m)
-> (forall a. StandardTF r m a)
-> (forall a.
    StandardTF r m a -> StandardTF r m a -> StandardTF r m a)
-> MonadPlus (StandardTF r m)
StandardTF r m a -> StandardTF r m a -> StandardTF r m a
forall a. StandardTF r m a
forall a. StandardTF r m a -> StandardTF r m a -> StandardTF r m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
forall (r :: * -> *) (m :: * -> *).
MonadPlus m =>
Monad (StandardTF r m)
forall (r :: * -> *) (m :: * -> *).
MonadPlus m =>
Alternative (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a
forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a -> StandardTF r m a -> StandardTF r m a
mplus :: StandardTF r m a -> StandardTF r m a -> StandardTF r m a
$cmplus :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a -> StandardTF r m a -> StandardTF r m a
mzero :: StandardTF r m a
$cmzero :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a
$cp2MonadPlus :: forall (r :: * -> *) (m :: * -> *).
MonadPlus m =>
Monad (StandardTF r m)
$cp1MonadPlus :: forall (r :: * -> *) (m :: * -> *).
MonadPlus m =>
Alternative (StandardTF r m)
MonadPlus
    , Monad (StandardTF r m)
Monad (StandardTF r m)
-> (forall a. (a -> StandardTF r m a) -> StandardTF r m a)
-> MonadFix (StandardTF r m)
(a -> StandardTF r m a) -> StandardTF r m a
forall a. (a -> StandardTF r m a) -> StandardTF r m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall (r :: * -> *) (m :: * -> *).
MonadFix m =>
Monad (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) a.
MonadFix m =>
(a -> StandardTF r m a) -> StandardTF r m a
mfix :: (a -> StandardTF r m a) -> StandardTF r m a
$cmfix :: forall (r :: * -> *) (m :: * -> *) a.
MonadFix m =>
(a -> StandardTF r m a) -> StandardTF r m a
$cp1MonadFix :: forall (r :: * -> *) (m :: * -> *).
MonadFix m =>
Monad (StandardTF r m)
MonadFix
    , Monad (StandardTF r m)
Monad (StandardTF r m)
-> (forall a. IO a -> StandardTF r m a) -> MonadIO (StandardTF r m)
IO a -> StandardTF r m a
forall a. IO a -> StandardTF r m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall (r :: * -> *) (m :: * -> *).
MonadIO m =>
Monad (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) a.
MonadIO m =>
IO a -> StandardTF r m a
liftIO :: IO a -> StandardTF r m a
$cliftIO :: forall (r :: * -> *) (m :: * -> *) a.
MonadIO m =>
IO a -> StandardTF r m a
$cp1MonadIO :: forall (r :: * -> *) (m :: * -> *).
MonadIO m =>
Monad (StandardTF r m)
MonadIO
    , MonadThrow (StandardTF r m)
MonadThrow (StandardTF r m)
-> (forall e a.
    Exception e =>
    StandardTF r m a -> (e -> StandardTF r m a) -> StandardTF r m a)
-> MonadCatch (StandardTF r m)
StandardTF r m a -> (e -> StandardTF r m a) -> StandardTF r m a
forall e a.
Exception e =>
StandardTF r m a -> (e -> StandardTF r m a) -> StandardTF r m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (r :: * -> *) (m :: * -> *).
MonadCatch m =>
MonadThrow (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
StandardTF r m a -> (e -> StandardTF r m a) -> StandardTF r m a
catch :: StandardTF r m a -> (e -> StandardTF r m a) -> StandardTF r m a
$ccatch :: forall (r :: * -> *) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
StandardTF r m a -> (e -> StandardTF r m a) -> StandardTF r m a
$cp1MonadCatch :: forall (r :: * -> *) (m :: * -> *).
MonadCatch m =>
MonadThrow (StandardTF r m)
MonadCatch
    , Monad (StandardTF r m)
e -> StandardTF r m a
Monad (StandardTF r m)
-> (forall e a. Exception e => e -> StandardTF r m a)
-> MonadThrow (StandardTF r m)
forall e a. Exception e => e -> StandardTF r m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall (r :: * -> *) (m :: * -> *).
MonadThrow m =>
Monad (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> StandardTF r m a
throwM :: e -> StandardTF r m a
$cthrowM :: forall (r :: * -> *) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> StandardTF r m a
$cp1MonadThrow :: forall (r :: * -> *) (m :: * -> *).
MonadThrow m =>
Monad (StandardTF r m)
MonadThrow
    , MonadCatch (StandardTF r m)
MonadCatch (StandardTF r m)
-> (forall b.
    ((forall a. StandardTF r m a -> StandardTF r m a)
     -> StandardTF r m b)
    -> StandardTF r m b)
-> (forall b.
    ((forall a. StandardTF r m a -> StandardTF r m a)
     -> StandardTF r m b)
    -> StandardTF r m b)
-> (forall a b c.
    StandardTF r m a
    -> (a -> ExitCase b -> StandardTF r m c)
    -> (a -> StandardTF r m b)
    -> StandardTF r m (b, c))
-> MonadMask (StandardTF r m)
StandardTF r m a
-> (a -> ExitCase b -> StandardTF r m c)
-> (a -> StandardTF r m b)
-> StandardTF r m (b, c)
((forall a. StandardTF r m a -> StandardTF r m a)
 -> StandardTF r m b)
-> StandardTF r m b
((forall a. StandardTF r m a -> StandardTF r m a)
 -> StandardTF r m b)
-> StandardTF r m b
forall b.
((forall a. StandardTF r m a -> StandardTF r m a)
 -> StandardTF r m b)
-> StandardTF r m b
forall a b c.
StandardTF r m a
-> (a -> ExitCase b -> StandardTF r m c)
-> (a -> StandardTF r m b)
-> StandardTF r m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
forall (r :: * -> *) (m :: * -> *).
MonadMask m =>
MonadCatch (StandardTF r m)
forall (r :: * -> *) (m :: * -> *) b.
MonadMask m =>
((forall a. StandardTF r m a -> StandardTF r m a)
 -> StandardTF r m b)
-> StandardTF r m b
forall (r :: * -> *) (m :: * -> *) a b c.
MonadMask m =>
StandardTF r m a
-> (a -> ExitCase b -> StandardTF r m c)
-> (a -> StandardTF r m b)
-> StandardTF r m (b, c)
generalBracket :: StandardTF r m a
-> (a -> ExitCase b -> StandardTF r m c)
-> (a -> StandardTF r m b)
-> StandardTF r m (b, c)
$cgeneralBracket :: forall (r :: * -> *) (m :: * -> *) a b c.
MonadMask m =>
StandardTF r m a
-> (a -> ExitCase b -> StandardTF r m c)
-> (a -> StandardTF r m b)
-> StandardTF r m (b, c)
uninterruptibleMask :: ((forall a. StandardTF r m a -> StandardTF r m a)
 -> StandardTF r m b)
-> StandardTF r m b
$cuninterruptibleMask :: forall (r :: * -> *) (m :: * -> *) b.
MonadMask m =>
((forall a. StandardTF r m a -> StandardTF r m a)
 -> StandardTF r m b)
-> StandardTF r m b
mask :: ((forall a. StandardTF r m a -> StandardTF r m a)
 -> StandardTF r m b)
-> StandardTF r m b
$cmask :: forall (r :: * -> *) (m :: * -> *) b.
MonadMask m =>
((forall a. StandardTF r m a -> StandardTF r m a)
 -> StandardTF r m b)
-> StandardTF r m b
$cp1MonadMask :: forall (r :: * -> *) (m :: * -> *).
MonadMask m =>
MonadCatch (StandardTF r m)
MonadMask
    , MonadReader (Context r (StdValue r))
    , MonadState (HashMap Path NExprLoc, HashMap Text Text)
    )

instance MonadTrans (StandardTF r) where
  lift :: m a -> StandardTF r m a
lift = ReaderT
  (Context r (StdValue r))
  (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
  a
-> StandardTF r m a
forall (r :: * -> *) (m :: * -> *) a.
ReaderT
  (Context r (StdValue r))
  (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
  a
-> StandardTF r m a
StandardTF (ReaderT
   (Context r (StdValue r))
   (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
   a
 -> StandardTF r m a)
-> (m a
    -> ReaderT
         (Context r (StdValue r))
         (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
         a)
-> m a
-> StandardTF r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateT (HashMap Path NExprLoc, HashMap Text Text) m a
-> ReaderT
     (Context r (StdValue r))
     (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
     a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (StateT (HashMap Path NExprLoc, HashMap Text Text) m a
 -> ReaderT
      (Context r (StdValue r))
      (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
      a)
-> (m a -> StateT (HashMap Path NExprLoc, HashMap Text Text) m a)
-> m a
-> ReaderT
     (Context r (StdValue r))
     (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> StateT (HashMap Path NExprLoc, HashMap Text Text) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
  {-# inline lift #-}

instance (MonadPutStr r, MonadPutStr m)
  => MonadPutStr (StandardTF r m)
instance (MonadHttp r, MonadHttp m)
  => MonadHttp (StandardTF r m)
instance (MonadEnv r, MonadEnv m)
  => MonadEnv (StandardTF r m)
instance (MonadPaths r, MonadPaths m)
  => MonadPaths (StandardTF r m)
instance (MonadInstantiate r, MonadInstantiate m)
  => MonadInstantiate (StandardTF r m)
instance (MonadExec r, MonadExec m)
  => MonadExec (StandardTF r m)
instance (MonadIntrospect r, MonadIntrospect m)
  => MonadIntrospect (StandardTF r m)

---------------------------------------------------------------------------------

type StandardT m = Fix1T StandardTF m

instance MonadTrans (Fix1T StandardTF) where
  lift :: m a -> Fix1T StandardTF m a
lift = StandardTF (Fix1T StandardTF m) m a -> Fix1T StandardTF m a
forall k (t :: (k -> *) -> (* -> *) -> k -> *) (m :: * -> *)
       (a :: k).
t (Fix1T t m) m a -> Fix1T t m a
Fix1T (StandardTF (Fix1T StandardTF m) m a -> Fix1T StandardTF m a)
-> (m a -> StandardTF (Fix1T StandardTF m) m a)
-> m a
-> Fix1T StandardTF m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> StandardTF (Fix1T StandardTF m) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
  {-# inline lift #-}

instance MonadThunkId m
  => MonadThunkId (StandardT m) where

  type ThunkId (StandardT m) = ThunkId m

mkStandardT
  :: ReaderT
      (Context (StandardT m) (StdValue (StandardT m)))
      (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
      a
  -> StandardT m a
mkStandardT :: ReaderT
  (Context (StandardT m) (StdValue (StandardT m)))
  (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
  a
-> StandardT m a
mkStandardT = ReaderT
  (Context (StandardT m) (StdValue (StandardT m)))
  (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
  a
-> StandardT m a
coerce

runStandardT
  :: StandardT m a
  -> ReaderT
      (Context (StandardT m) (StdValue (StandardT m)))
      (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
      a
runStandardT :: StandardT m a
-> ReaderT
     (Context (StandardT m) (StdValue (StandardT m)))
     (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
     a
runStandardT = StandardT m a
-> ReaderT
     (Context (StandardT m) (StdValue (StandardT m)))
     (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
     a
coerce

runWithBasicEffects
  :: (MonadIO m, MonadAtomicRef m)
  => Options
  -> StandardT (StdIdT m) a
  -> m a
runWithBasicEffects :: Options -> StandardT (StdIdT m) a -> m a
runWithBasicEffects Options
opts =
  FreshIdT Int m a -> m a
forall (m :: * -> *) b. MonadRef m => FreshIdT Int m b -> m b
fun (FreshIdT Int m a -> m a)
-> (StandardT (StdIdT m) a -> FreshIdT Int m a)
-> StandardT (StdIdT m) a
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m) a
-> (HashMap Path NExprLoc, HashMap Text Text) -> FreshIdT Int m a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
`evalStateT` (HashMap Path NExprLoc, HashMap Text Text)
forall a. Monoid a => a
mempty) (StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m) a
 -> FreshIdT Int m a)
-> (StandardT (StdIdT m) a
    -> StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m) a)
-> StandardT (StdIdT m) a
-> FreshIdT Int m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ReaderT
  (Context (StandardT (StdIdT m)) (StdValue (StandardT (StdIdT m))))
  (StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m))
  a
-> Context (StandardT (StdIdT m)) (StdValue (StandardT (StdIdT m)))
-> StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m) a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
`runReaderT` Options
-> Context (StandardT (StdIdT m)) (StdValue (StandardT (StdIdT m)))
forall (m :: * -> *) t. Options -> Context m t
newContext Options
opts) (ReaderT
   (Context (StandardT (StdIdT m)) (StdValue (StandardT (StdIdT m))))
   (StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m))
   a
 -> StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m) a)
-> (StandardT (StdIdT m) a
    -> ReaderT
         (Context (StandardT (StdIdT m)) (StdValue (StandardT (StdIdT m))))
         (StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m))
         a)
-> StandardT (StdIdT m) a
-> StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StandardT (StdIdT m) a
-> ReaderT
     (Context (StandardT (StdIdT m)) (StdValue (StandardT (StdIdT m))))
     (StateT (HashMap Path NExprLoc, HashMap Text Text) (StdIdT m))
     a
forall (m :: * -> *) a.
StandardT m a
-> ReaderT
     (Context (StandardT m) (StdValue (StandardT m)))
     (StateT (HashMap Path NExprLoc, HashMap Text Text) m)
     a
runStandardT
 where
  fun :: FreshIdT Int m b -> m b
fun FreshIdT Int m b
action =
    FreshIdT Int m b -> Ref m Int -> m b
forall (m :: * -> *) i a.
Functor m =>
FreshIdT i m a -> Ref m i -> m a
runFreshIdT FreshIdT Int m b
action (Ref m Int -> m b) -> m (Ref m Int) -> m b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Int -> m (Ref m Int)
forall (m :: * -> *) a. MonadRef m => a -> m (Ref m a)
newRef (Int
1 :: Int)

runWithBasicEffectsIO :: Options -> StandardIO a -> IO a
runWithBasicEffectsIO :: Options -> StandardIO a -> IO a
runWithBasicEffectsIO = Options -> StandardIO a -> IO a
forall (m :: * -> *) a.
(MonadIO m, MonadAtomicRef m) =>
Options -> StandardT (StdIdT m) a -> m a
runWithBasicEffects