{-# LANGUAGE CPP #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}

{-# OPTIONS_GHC -Wno-orphans #-}

module Nix.Standard where

import           Control.Applicative
import           Control.Comonad                ( Comonad )
import           Control.Comonad.Env            ( ComonadEnv )
import           Control.Monad.Catch     hiding ( catchJust )
#if !MIN_VERSION_base(4,13,0)
import           Control.Monad.Fail             ( MonadFail )
#endif
import           Control.Monad.Free
import           Control.Monad.Reader
import           Control.Monad.Ref
import           Control.Monad.State
import           Data.HashMap.Lazy              ( HashMap )
import qualified Data.HashMap.Strict
import           Data.Text                      ( Text )
import           Data.Typeable
import           GHC.Generics
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
import           Nix.Value
import           Nix.Value.Monad
import           Nix.Var

-- All of the following type classes defer to the underlying 'm'.

deriving instance MonadPutStr (t (Fix1 t)) => MonadPutStr (Fix1 t)
deriving instance MonadHttp (t (Fix1 t)) => MonadHttp (Fix1 t)
deriving instance MonadEnv (t (Fix1 t)) => MonadEnv (Fix1 t)
deriving instance MonadPaths (t (Fix1 t)) => MonadPaths (Fix1 t)
deriving instance MonadInstantiate (t (Fix1 t)) => MonadInstantiate (Fix1 t)
deriving instance MonadExec (t (Fix1 t)) => MonadExec (Fix1 t)
deriving instance MonadIntrospect (t (Fix1 t)) => MonadIntrospect (Fix1 t)

deriving instance MonadPutStr (t (Fix1T t m) m) => MonadPutStr (Fix1T t m)
deriving instance MonadHttp (t (Fix1T t m) m) => MonadHttp (Fix1T t m)
deriving instance MonadEnv (t (Fix1T t m) m) => MonadEnv (Fix1T t m)
deriving instance MonadPaths (t (Fix1T t m) m) => MonadPaths (Fix1T t m)
deriving instance MonadInstantiate (t (Fix1T t m) m) => MonadInstantiate (Fix1T t m)
deriving instance MonadExec (t (Fix1T t m) m) => MonadExec (Fix1T t m)
deriving instance MonadIntrospect (t (Fix1T t m) m) => MonadIntrospect (Fix1T t m)

type MonadFix1T t m = (MonadTrans (Fix1T t), Monad (t (Fix1T t m) m))

instance (MonadFix1T t m, MonadRef m) => MonadRef (Fix1T t m) where
  type Ref (Fix1T t m) = Ref m
  newRef :: a -> Fix1T t m (Ref (Fix1T t m) a)
newRef  = m (Ref m a) -> Fix1T t m (Ref m a)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Ref m a) -> Fix1T t m (Ref m a))
-> (a -> m (Ref m a)) -> a -> Fix1T t m (Ref m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m (Ref m a)
forall (m :: * -> *) a. MonadRef m => a -> m (Ref m a)
newRef
  readRef :: Ref (Fix1T t m) a -> Fix1T t m a
readRef = m a -> Fix1T t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> Fix1T t m a) -> (Ref m a -> m a) -> Ref m a -> Fix1T t m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ref m a -> m a
forall (m :: * -> *) a. MonadRef m => Ref m a -> m a
readRef
  writeRef :: Ref (Fix1T t m) a -> a -> Fix1T t m ()
writeRef Ref (Fix1T t m) a
r = m () -> Fix1T t m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> Fix1T t m ()) -> (a -> m ()) -> a -> Fix1T t m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ref m a -> a -> m ()
forall (m :: * -> *) a. MonadRef m => Ref m a -> a -> m ()
writeRef Ref m a
Ref (Fix1T t m) a
r

instance (MonadFix1T t m, MonadAtomicRef m) => MonadAtomicRef (Fix1T t m) where
  atomicModifyRef :: Ref (Fix1T t m) a -> (a -> (a, b)) -> Fix1T t m b
atomicModifyRef Ref (Fix1T t m) a
r = m b -> Fix1T t m b
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m b -> Fix1T t m b)
-> ((a -> (a, b)) -> m b) -> (a -> (a, b)) -> Fix1T t m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ref m a -> (a -> (a, b)) -> m b
forall (m :: * -> *) a b.
MonadAtomicRef m =>
Ref m a -> (a -> (a, b)) -> m b
atomicModifyRef Ref m a
Ref (Fix1T t m) a
r

instance (MonadFix1T t m, MonadFail (Fix1T t m), MonadFile m) => MonadFile (Fix1T t m)

instance (MonadFix1T t m, MonadStore m) => MonadStore (Fix1T t m) where
  addToStore :: Text
-> String -> Bool -> Bool -> Fix1T t m (Either ErrorCall StorePath)
addToStore Text
a String
b Bool
c Bool
d = m (Either ErrorCall StorePath)
-> Fix1T t m (Either ErrorCall StorePath)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Either ErrorCall StorePath)
 -> Fix1T t m (Either ErrorCall StorePath))
-> m (Either ErrorCall StorePath)
-> Fix1T t m (Either ErrorCall StorePath)
forall a b. (a -> b) -> a -> b
$ Text -> String -> Bool -> Bool -> m (Either ErrorCall StorePath)
forall (m :: * -> *).
MonadStore m =>
Text -> String -> Bool -> Bool -> m (Either ErrorCall StorePath)
addToStore Text
a String
b Bool
c Bool
d
  addTextToStore' :: Text
-> Text
-> StorePathSet
-> Bool
-> Fix1T t m (Either ErrorCall StorePath)
addTextToStore' Text
a Text
b StorePathSet
c Bool
d = m (Either ErrorCall StorePath)
-> Fix1T t m (Either ErrorCall StorePath)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Either ErrorCall StorePath)
 -> Fix1T t m (Either ErrorCall StorePath))
-> m (Either ErrorCall StorePath)
-> Fix1T t m (Either ErrorCall StorePath)
forall a b. (a -> b) -> a -> b
$ Text
-> Text -> StorePathSet -> Bool -> m (Either ErrorCall StorePath)
forall (m :: * -> *).
MonadStore m =>
Text
-> Text -> StorePathSet -> Bool -> m (Either ErrorCall StorePath)
addTextToStore' Text
a Text
b StorePathSet
c Bool
d

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

newtype StdCited m a = StdCited
  { StdCited m a -> Cited (StdThunk m) (StdCited m) 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
  { StdThunk m -> StdCited m (NThunkF m (StdValue m))
_stdThunk :: StdCited m (NThunkF m (StdValue m)) }

type StdValue m = NValue (StdThunk m) (StdCited m) m

instance Show (StdThunk m) where
  show :: StdThunk m -> String
show StdThunk m
_ = String
"<thunk>"

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 (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 (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 :: 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 :: Text -> m (Maybe (StdValue m))
lookupVar     = Text -> m (Maybe (StdValue m))
forall (m :: * -> *) a e.
(MonadReader e m, Has e (Scopes m a)) =>
Text -> 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 FilePath NExprLoc, Data.HashMap.Strict.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
  makeAbsolutePath :: String -> m String
makeAbsolutePath = String -> m String
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
String -> m String
defaultMakeAbsolutePath
  findEnvPath :: String -> m String
findEnvPath      = String -> m String
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
String -> m String
defaultFindEnvPath
  findPath :: [NValue (StdThunk m) (StdCited m) m] -> String -> m String
findPath         = [NValue (StdThunk m) (StdCited m) m] -> String -> m String
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
[NValue t f m] -> String -> m String
defaultFindPath
  importPath :: String -> m (NValue (StdThunk m) (StdCited m) m)
importPath       = String -> m (NValue (StdThunk m) (StdCited m) m)
forall e t (f :: * -> *) (m :: * -> *) b.
(MonadNix e t f m, MonadState (HashMap String NExprLoc, b) m) =>
String -> m (NValue t f m)
defaultImportPath
  pathToDefaultNix :: String -> m String
pathToDefaultNix = String -> m String
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
String -> m String
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

instance ( MonadAtomicRef m
         , MonadCatch m
         , Typeable m
         , MonadReader (Context m (StdValue m)) m
         , MonadThunkId m
         )
  => MonadThunk (StdThunk m) m (StdValue m) where
  thunk :: m (StdValue m) -> m (StdThunk m)
thunk   = (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
 -> StdThunk m)
-> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> m (StdThunk m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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)
-> (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
    -> StdCited m (NThunkF m (StdValue m)))
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
-> StdThunk m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
-> StdCited m (NThunkF m (StdValue m))
forall (m :: * -> *) a.
Cited (StdThunk m) (StdCited m) m a -> StdCited m a
StdCited) (m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
 -> m (StdThunk m))
-> (m (StdValue m)
    -> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))))
-> m (StdValue m)
-> m (StdThunk m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (StdValue m)
-> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
forall t (m :: * -> *) a. MonadThunk t m a => m a -> m t
thunk
  thunkId :: StdThunk m -> ThunkId m
thunkId = Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
-> ThunkId m
forall t (m :: * -> *) a. MonadThunk t m a => t -> ThunkId m
thunkId (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
 -> ThunkId m)
-> (StdThunk m
    -> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> StdThunk m
-> ThunkId m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdCited m (NThunkF m (StdValue m))
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
forall (m :: * -> *) a.
StdCited m a -> Cited (StdThunk m) (StdCited m) m a
_stdCited (StdCited m (NThunkF m (StdValue m))
 -> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> (StdThunk m -> StdCited m (NThunkF m (StdValue m)))
-> StdThunk m
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> StdCited m (NThunkF m (StdValue m))
forall (m :: * -> *).
StdThunk m -> StdCited m (NThunkF m (StdValue m))
_stdThunk
  queryM :: StdThunk m -> m r -> (StdValue m -> m r) -> m r
queryM StdThunk m
x m r
b StdValue m -> m r
f = Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
-> m r -> (StdValue m -> m r) -> m r
forall t (m :: * -> *) a r.
MonadThunk t m a =>
t -> m r -> (a -> m r) -> m r
queryM (StdCited m (NThunkF m (StdValue m))
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
forall (m :: * -> *) a.
StdCited m a -> Cited (StdThunk m) (StdCited m) m a
_stdCited (StdThunk m -> StdCited m (NThunkF m (StdValue m))
forall (m :: * -> *).
StdThunk m -> StdCited m (NThunkF m (StdValue m))
_stdThunk StdThunk m
x)) m r
b StdValue m -> m r
f
  force :: StdThunk m -> (StdValue m -> m r) -> m r
force    = Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
-> (StdValue m -> m r) -> m r
forall t (m :: * -> *) a r.
MonadThunk t m a =>
t -> (a -> m r) -> m r
force (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
 -> (StdValue m -> m r) -> m r)
-> (StdThunk m
    -> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> StdThunk m
-> (StdValue m -> m r)
-> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdCited m (NThunkF m (StdValue m))
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
forall (m :: * -> *) a.
StdCited m a -> Cited (StdThunk m) (StdCited m) m a
_stdCited (StdCited m (NThunkF m (StdValue m))
 -> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> (StdThunk m -> StdCited m (NThunkF m (StdValue m)))
-> StdThunk m
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> StdCited m (NThunkF m (StdValue m))
forall (m :: * -> *).
StdThunk m -> StdCited m (NThunkF m (StdValue m))
_stdThunk
  forceEff :: StdThunk m -> (StdValue m -> m r) -> m r
forceEff = Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
-> (StdValue m -> m r) -> m r
forall t (m :: * -> *) a r.
MonadThunk t m a =>
t -> (a -> m r) -> m r
forceEff (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
 -> (StdValue m -> m r) -> m r)
-> (StdThunk m
    -> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> StdThunk m
-> (StdValue m -> m r)
-> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdCited m (NThunkF m (StdValue m))
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
forall (m :: * -> *) a.
StdCited m a -> Cited (StdThunk m) (StdCited m) m a
_stdCited (StdCited m (NThunkF m (StdValue m))
 -> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> (StdThunk m -> StdCited m (NThunkF m (StdValue m)))
-> StdThunk m
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> StdCited m (NThunkF m (StdValue m))
forall (m :: * -> *).
StdThunk m -> StdCited m (NThunkF m (StdValue m))
_stdThunk
  further :: StdThunk m -> (m (StdValue m) -> m (StdValue m)) -> m (StdThunk m)
further  = ((Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
 -> StdThunk m)
-> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> m (StdThunk m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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)
-> (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
    -> StdCited m (NThunkF m (StdValue m)))
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
-> StdThunk m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
-> StdCited m (NThunkF m (StdValue m))
forall (m :: * -> *) a.
Cited (StdThunk m) (StdCited m) m a -> StdCited m a
StdCited) (m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
 -> m (StdThunk m))
-> ((m (StdValue m) -> m (StdValue m))
    -> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))))
-> (m (StdValue m) -> m (StdValue m))
-> m (StdThunk m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) (((m (StdValue m) -> m (StdValue m))
  -> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))))
 -> (m (StdValue m) -> m (StdValue m)) -> m (StdThunk m))
-> (StdThunk m
    -> (m (StdValue m) -> m (StdValue m))
    -> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))))
-> StdThunk m
-> (m (StdValue m) -> m (StdValue m))
-> m (StdThunk m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
-> (m (StdValue m) -> m (StdValue m))
-> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
forall t (m :: * -> *) a.
MonadThunk t m a =>
t -> (m a -> m a) -> m t
further (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
 -> (m (StdValue m) -> m (StdValue m))
 -> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))))
-> (StdThunk m
    -> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> StdThunk m
-> (m (StdValue m) -> m (StdValue m))
-> m (Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdCited m (NThunkF m (StdValue m))
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
forall (m :: * -> *) a.
StdCited m a -> Cited (StdThunk m) (StdCited m) m a
_stdCited (StdCited m (NThunkF m (StdValue m))
 -> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m)))
-> (StdThunk m -> StdCited m (NThunkF m (StdValue m)))
-> StdThunk m
-> Cited (StdThunk m) (StdCited m) m (NThunkF m (StdValue m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StdThunk m -> StdCited m (NThunkF m (StdValue m))
forall (m :: * -> *).
StdThunk m -> StdCited m (NThunkF m (StdValue m))
_stdThunk

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 = (StdThunk m -> StdValue m) -> m (StdThunk m) -> m (StdValue m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap StdThunk m -> StdValue m
forall (f :: * -> *) a. a -> Free f a
Pure (m (StdThunk m) -> m (StdValue m))
-> (m (StdValue m) -> m (StdThunk m))
-> m (StdValue m)
-> m (StdValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (StdValue m) -> m (StdThunk m)
forall t (m :: * -> *) a. MonadThunk t m a => m a -> m t
thunk

  demand :: StdValue m -> (StdValue m -> m r) -> m r
demand (Pure StdThunk m
v) StdValue m -> m r
f = StdThunk m -> (StdValue m -> m r) -> m r
forall t (m :: * -> *) a r.
MonadThunk t m a =>
t -> (a -> m r) -> m r
force StdThunk m
v ((StdValue m -> (StdValue m -> m r) -> m r)
-> (StdValue m -> m r) -> StdValue m -> m r
forall a b c. (a -> b -> c) -> b -> a -> c
flip StdValue m -> (StdValue m -> m r) -> m r
forall v (m :: * -> *) r. MonadValue v m => v -> (v -> m r) -> m r
demand StdValue m -> m r
f)
  demand (Free NValue' (StdThunk m) (StdCited m) m (StdValue m)
v) StdValue m -> m r
f = StdValue m -> m r
f (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)
v)

  inform :: StdValue m -> (m (StdValue m) -> m (StdValue m)) -> m (StdValue m)
inform (Pure StdThunk m
t) m (StdValue m) -> m (StdValue m)
f = StdThunk m -> StdValue m
forall (f :: * -> *) a. a -> Free f a
Pure (StdThunk m -> StdValue m) -> m (StdThunk m) -> m (StdValue m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StdThunk m -> (m (StdValue m) -> m (StdValue m)) -> m (StdThunk m)
forall t (m :: * -> *) a.
MonadThunk t m a =>
t -> (m a -> m a) -> m t
further StdThunk m
t m (StdValue m) -> m (StdValue m)
f
  inform (Free NValue' (StdThunk m) (StdCited m) m (StdValue m)
v) m (StdValue m) -> m (StdValue m)
f = 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
<$> (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) -> m (StdValue m)) -> m (StdValue m))
-> (m (StdValue m) -> m (StdValue m))
-> StdValue m
-> m (StdValue m)
forall a b c. (a -> b -> c) -> b -> a -> c
flip StdValue m -> (m (StdValue m) -> m (StdValue m)) -> m (StdValue m)
forall v (m :: * -> *). MonadValue v m => v -> (m v -> m v) -> m v
inform m (StdValue m) -> m (StdValue m)
f) NValue' (StdThunk m) (StdCited m) m (StdValue m)
v

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

-- 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 FilePath 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 FilePath NExprLoc, HashMap Text Text)
    )

instance MonadTrans (StandardTF r) where
  lift :: m a -> StandardTF r m a
lift = ReaderT
  (Context r (StdValue r))
  (StateT (HashMap String NExprLoc, HashMap Text Text) m)
  a
-> StandardTF r m a
forall (r :: * -> *) (m :: * -> *) a.
ReaderT
  (Context r (StdValue r))
  (StateT (HashMap String NExprLoc, HashMap Text Text) m)
  a
-> StandardTF r m a
StandardTF (ReaderT
   (Context r (StdValue r))
   (StateT (HashMap String NExprLoc, HashMap Text Text) m)
   a
 -> StandardTF r m a)
-> (m a
    -> ReaderT
         (Context r (StdValue r))
         (StateT (HashMap String NExprLoc, HashMap Text Text) m)
         a)
-> m a
-> StandardTF r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateT (HashMap String NExprLoc, HashMap Text Text) m a
-> ReaderT
     (Context r (StdValue r))
     (StateT (HashMap String NExprLoc, HashMap Text Text) m)
     a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (StateT (HashMap String NExprLoc, HashMap Text Text) m a
 -> ReaderT
      (Context r (StdValue r))
      (StateT (HashMap String NExprLoc, HashMap Text Text) m)
      a)
-> (m a -> StateT (HashMap String NExprLoc, HashMap Text Text) m a)
-> m a
-> ReaderT
     (Context r (StdValue r))
     (StateT (HashMap String NExprLoc, HashMap Text Text) m)
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> StateT (HashMap String NExprLoc, HashMap Text Text) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
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

instance MonadThunkId m => MonadThunkId (Fix1T StandardTF m) where
  type ThunkId (Fix1T StandardTF m) = ThunkId m

mkStandardT
  :: ReaderT
       (Context (StandardT m) (StdValue (StandardT m)))
       (StateT (HashMap FilePath NExprLoc, Data.HashMap.Strict.HashMap Text Text) m)
       a
  -> StandardT m a
mkStandardT :: ReaderT
  (Context (StandardT m) (StdValue (StandardT m)))
  (StateT (HashMap String NExprLoc, HashMap Text Text) m)
  a
-> StandardT m a
mkStandardT = StandardTF (StandardT m) m a -> StandardT m a
forall k (t :: (k -> *) -> (* -> *) -> k -> *) (m :: * -> *)
       (a :: k).
t (Fix1T t m) m a -> Fix1T t m a
Fix1T (StandardTF (StandardT m) m a -> StandardT m a)
-> (ReaderT
      (Context (StandardT m) (StdValue (StandardT m)))
      (StateT (HashMap String NExprLoc, HashMap Text Text) m)
      a
    -> StandardTF (StandardT m) m a)
-> ReaderT
     (Context (StandardT m) (StdValue (StandardT m)))
     (StateT (HashMap String NExprLoc, HashMap Text Text) m)
     a
-> StandardT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReaderT
  (Context (StandardT m) (StdValue (StandardT m)))
  (StateT (HashMap String NExprLoc, HashMap Text Text) m)
  a
-> StandardTF (StandardT m) m a
forall (r :: * -> *) (m :: * -> *) a.
ReaderT
  (Context r (StdValue r))
  (StateT (HashMap String NExprLoc, HashMap Text Text) m)
  a
-> StandardTF r m a
StandardTF

runStandardT
  :: StandardT m a
  -> ReaderT
       (Context (StandardT m) (StdValue (StandardT m)))
       (StateT (HashMap FilePath NExprLoc, Data.HashMap.Strict.HashMap Text Text) m)
       a
runStandardT :: StandardT m a
-> ReaderT
     (Context (StandardT m) (StdValue (StandardT m)))
     (StateT (HashMap String NExprLoc, HashMap Text Text) m)
     a
runStandardT (Fix1T (StandardTF ReaderT
  (Context (StandardT m) (StdValue (StandardT m)))
  (StateT (HashMap String NExprLoc, HashMap Text Text) m)
  a
m)) = ReaderT
  (Context (StandardT m) (StdValue (StandardT m)))
  (StateT (HashMap String NExprLoc, HashMap Text Text) m)
  a
m

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
go (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 String NExprLoc, HashMap Text Text) (StdIdT m) a
-> (HashMap String NExprLoc, HashMap Text Text) -> FreshIdT Int m a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
`evalStateT` (HashMap String NExprLoc, HashMap Text Text)
forall a. Monoid a => a
mempty) (StateT (HashMap String NExprLoc, HashMap Text Text) (StdIdT m) a
 -> FreshIdT Int m a)
-> (StandardT (StdIdT m) a
    -> StateT
         (HashMap String 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 String NExprLoc, HashMap Text Text) (StdIdT m))
  a
-> Context (StandardT (StdIdT m)) (StdValue (StandardT (StdIdT m)))
-> StateT (HashMap String 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 String NExprLoc, HashMap Text Text) (StdIdT m))
   a
 -> StateT
      (HashMap String NExprLoc, HashMap Text Text) (StdIdT m) a)
-> (StandardT (StdIdT m) a
    -> ReaderT
         (Context (StandardT (StdIdT m)) (StdValue (StandardT (StdIdT m))))
         (StateT (HashMap String NExprLoc, HashMap Text Text) (StdIdT m))
         a)
-> StandardT (StdIdT m) a
-> StateT (HashMap String 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 String NExprLoc, HashMap Text Text) (StdIdT m))
     a
forall (m :: * -> *) a.
StandardT m a
-> ReaderT
     (Context (StandardT m) (StdValue (StandardT m)))
     (StateT (HashMap String 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)
newVar (Int
1 :: Int)
    Ref m Int -> FreshIdT Int m b -> m b
forall (m :: * -> *) i a.
Functor m =>
Var 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 :: 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