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

{-# options_ghc -Wno-orphans #-}


module Nix.Standard where

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
    , (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
<$ :: forall a b. a -> StdCited m b -> StdCited m a
$c<$ :: forall (m :: * -> *) a b. a -> StdCited m b -> StdCited m a
fmap :: forall a b. (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)
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)
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
<* :: forall a b. StdCited m a -> StdCited m b -> StdCited m a
$c<* :: forall (m :: * -> *) a b.
StdCited m a -> StdCited m b -> StdCited m a
*> :: forall a b. StdCited m a -> StdCited m b -> StdCited m b
$c*> :: forall (m :: * -> *) a b.
StdCited m a -> StdCited m b -> StdCited m b
liftA2 :: forall a b c.
(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
<*> :: forall a b. 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 :: forall a. a -> StdCited m a
$cpure :: forall (m :: * -> *) a. a -> StdCited m a
Applicative
    , (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 :: forall a. Num a => StdCited m a -> a
$cproduct :: forall (m :: * -> *) a. Num a => StdCited m a -> a
sum :: forall a. Num a => StdCited m a -> a
$csum :: forall (m :: * -> *) a. Num a => StdCited m a -> a
minimum :: forall a. Ord a => StdCited m a -> a
$cminimum :: forall (m :: * -> *) a. Ord a => StdCited m a -> a
maximum :: forall a. Ord a => StdCited m a -> a
$cmaximum :: forall (m :: * -> *) a. Ord a => StdCited m a -> a
elem :: forall a. Eq a => a -> StdCited m a -> Bool
$celem :: forall (m :: * -> *) a. Eq a => a -> StdCited m a -> Bool
length :: forall a. StdCited m a -> Int
$clength :: forall (m :: * -> *) a. StdCited m a -> Int
null :: forall a. StdCited m a -> Bool
$cnull :: forall (m :: * -> *) a. StdCited m a -> Bool
toList :: forall a. StdCited m a -> [a]
$ctoList :: forall (m :: * -> *) a. StdCited m a -> [a]
foldl1 :: forall a. (a -> a -> a) -> StdCited m a -> a
$cfoldl1 :: forall (m :: * -> *) a. (a -> a -> a) -> StdCited m a -> a
foldr1 :: forall a. (a -> a -> a) -> StdCited m a -> a
$cfoldr1 :: forall (m :: * -> *) a. (a -> a -> a) -> StdCited m a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> StdCited m a -> b
$cfoldl' :: forall (m :: * -> *) b a. (b -> a -> b) -> b -> StdCited m a -> b
foldl :: forall b a. (b -> a -> b) -> b -> StdCited m a -> b
$cfoldl :: forall (m :: * -> *) b a. (b -> a -> b) -> b -> StdCited m a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> StdCited m a -> b
$cfoldr' :: forall (m :: * -> *) a b. (a -> b -> b) -> b -> StdCited m a -> b
foldr :: forall a b. (a -> b -> b) -> b -> StdCited m a -> b
$cfoldr :: forall (m :: * -> *) a b. (a -> b -> b) -> b -> StdCited m a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> StdCited m a -> m
$cfoldMap' :: forall (m :: * -> *) m a. Monoid m => (a -> m) -> StdCited m a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> StdCited m a -> m
$cfoldMap :: forall (m :: * -> *) m a. Monoid m => (a -> m) -> StdCited m a -> m
fold :: forall m. Monoid m => 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)
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 :: forall (m :: * -> *) a.
Monad m =>
StdCited m (m a) -> m (StdCited m a)
$csequence :: forall (m :: * -> *) (m :: * -> *) a.
Monad m =>
StdCited m (m a) -> m (StdCited m a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(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 :: forall (f :: * -> *) a.
Applicative f =>
StdCited m (f a) -> f (StdCited m a)
$csequenceA :: forall (m :: * -> *) (f :: * -> *) a.
Applicative f =>
StdCited m (f a) -> f (StdCited m a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(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)
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)
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 :: forall a b. (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 :: forall a. StdCited m a -> StdCited m (StdCited m a)
$cduplicate :: forall (m :: * -> *) a. StdCited m a -> StdCited m (StdCited m a)
extract :: forall a. StdCited m a -> a
$cextract :: forall (m :: * -> *) a. StdCited m a -> a
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 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 :: forall a. 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 :: forall a. 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
  currentScopes :: m (Scopes m (StdValue m))
currentScopes = m (Scopes m (StdValue m))
forall (m :: * -> *) a e.
(MonadReader e m, Has e (Scopes m a)) =>
m (Scopes m a)
currentScopesReader
  clearScopes :: forall r. m r -> m r
clearScopes   = forall (m :: * -> *) a e r.
(MonadReader e m, Has e (Scopes m a)) =>
m r -> m r
clearScopesReader @m @(StdValue m)
  pushScopes :: forall r. 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
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
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 = 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
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
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
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 :: forall r. (StdValue m -> m r) -> m r -> StdThunk m -> m r
queryF StdValue m -> m r
k m r
b = 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 :: forall r. (StdValue m -> m r) -> StdThunk m -> m r
forceF StdValue m -> m r
k = 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 :: forall r. (StdValue m -> m r) -> StdThunk m -> m r
forceEffF StdValue m -> m r
k = 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
. 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
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
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
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 :: forall r. (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
    ( (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
<$ :: forall a 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 :: forall a b. (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)
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)
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
<* :: forall a b.
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
*> :: forall a b.
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 :: forall a b c.
(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
<*> :: forall a b.
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 :: forall a. a -> StandardTF r m a
$cpure :: forall (r :: * -> *) (m :: * -> *) a.
Monad m =>
a -> StandardTF r m a
Applicative
    , Applicative (StandardTF r m)
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)
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 :: forall a. StandardTF r m a -> StandardTF r m [a]
$cmany :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a -> StandardTF r m [a]
some :: forall a. StandardTF r m a -> StandardTF r m [a]
$csome :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a -> StandardTF r m [a]
<|> :: forall 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 :: forall a. StandardTF r m a
$cempty :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a
Alternative
    , Applicative (StandardTF r m)
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)
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 :: forall a. a -> StandardTF r m a
$creturn :: forall (r :: * -> *) (m :: * -> *) a.
Monad m =>
a -> StandardTF r m a
>> :: forall a b.
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
>>= :: forall a 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
Monad
    , Monad (StandardTF r m)
Monad (StandardTF r m)
-> (forall a. String -> StandardTF r m a)
-> MonadFail (StandardTF r m)
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 :: forall a. String -> StandardTF r m a
$cfail :: forall (r :: * -> *) (m :: * -> *) a.
MonadFail m =>
String -> StandardTF r m a
MonadFail
    , Monad (StandardTF r m)
Alternative (StandardTF r m)
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)
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 :: forall a. 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 :: forall a. StandardTF r m a
$cmzero :: forall (r :: * -> *) (m :: * -> *) a.
MonadPlus m =>
StandardTF r m a
MonadPlus
    , Monad (StandardTF r m)
Monad (StandardTF r m)
-> (forall a. (a -> StandardTF r m a) -> StandardTF r m a)
-> MonadFix (StandardTF r m)
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 :: forall a. (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
MonadFix
    , Monad (StandardTF r m)
Monad (StandardTF r m)
-> (forall a. IO a -> StandardTF r m a) -> MonadIO (StandardTF r m)
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 :: forall a. IO a -> StandardTF r m a
$cliftIO :: forall (r :: * -> *) (m :: * -> *) a.
MonadIO m =>
IO a -> StandardTF r m a
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)
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 :: forall e a.
Exception e =>
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
MonadCatch
    , Monad (StandardTF r m)
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 :: forall e a. Exception e => e -> StandardTF r m a
$cthrowM :: forall (r :: * -> *) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> StandardTF r m a
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)
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 :: 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)
$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 b.
((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 b.
((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
MonadMask
    , MonadReader (Context r (StdValue r))
    , MonadState (HashMap Path NExprLoc, HashMap Text Text)
    )

instance MonadTrans (StandardTF r) where
  lift :: forall (m :: * -> *) a. Monad m => 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 :: forall (m :: * -> *) a. Monad m => 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 :: forall (m :: * -> *) a.
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 :: forall (m :: * -> *) a.
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 :: forall (m :: * -> *) a.
(MonadIO m, MonadAtomicRef m) =>
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
go (FreshIdT Int m a -> m a)
-> (StandardT (FreshIdT Int m) a -> FreshIdT Int m a)
-> StandardT (FreshIdT Int m) a
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StateT
  (HashMap Path NExprLoc, HashMap Text Text) (FreshIdT Int 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) (FreshIdT Int m) a
 -> FreshIdT Int m a)
-> (StandardT (FreshIdT Int m) a
    -> StateT
         (HashMap Path NExprLoc, HashMap Text Text) (FreshIdT Int m) a)
-> StandardT (FreshIdT Int m) a
-> FreshIdT Int m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ReaderT
  (Context
     (StandardT (FreshIdT Int m))
     (StdValue (StandardT (FreshIdT Int m))))
  (StateT
     (HashMap Path NExprLoc, HashMap Text Text) (FreshIdT Int m))
  a
-> Context
     (StandardT (FreshIdT Int m))
     (StdValue (StandardT (FreshIdT Int m)))
-> StateT
     (HashMap Path NExprLoc, HashMap Text Text) (FreshIdT Int m) a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
`runReaderT` Options
-> Context
     (StandardT (FreshIdT Int m))
     (StdValue (StandardT (FreshIdT Int m)))
forall (m :: * -> *) t. Options -> Context m t
newContext Options
opts) (ReaderT
   (Context
      (StandardT (FreshIdT Int m))
      (StdValue (StandardT (FreshIdT Int m))))
   (StateT
      (HashMap Path NExprLoc, HashMap Text Text) (FreshIdT Int m))
   a
 -> StateT
      (HashMap Path NExprLoc, HashMap Text Text) (FreshIdT Int m) a)
-> (StandardT (FreshIdT Int m) a
    -> ReaderT
         (Context
            (StandardT (FreshIdT Int m))
            (StdValue (StandardT (FreshIdT Int m))))
         (StateT
            (HashMap Path NExprLoc, HashMap Text Text) (FreshIdT Int m))
         a)
-> StandardT (FreshIdT Int m) a
-> StateT
     (HashMap Path NExprLoc, HashMap Text Text) (FreshIdT Int m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StandardT (FreshIdT Int m) a
-> ReaderT
     (Context
        (StandardT (FreshIdT Int m))
        (StdValue (StandardT (FreshIdT Int m))))
     (StateT
        (HashMap Path NExprLoc, HashMap Text Text) (FreshIdT Int 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
  go :: FreshIdT Int m b -> m b
go FreshIdT Int m b
action = do
    Ref m Int
i <- Int -> m (Ref m Int)
forall (m :: * -> *) a. MonadRef m => a -> m (Ref m a)
newRef (Int
1 :: Int)
    Ref m Int -> FreshIdT Int m b -> m b
forall (m :: * -> *) i a.
Functor m =>
Ref m i -> FreshIdT i m a -> m a
runFreshIdT Ref m Int
i FreshIdT Int m b
action

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