{-# language GeneralizedNewtypeDeriving #-}
{-# language UndecidableInstances #-}
{-# language PatternSynonyms    #-}

module Nix.Cited.Basic where

import           Nix.Prelude
import           Control.Comonad                ( Comonad )
import           Control.Comonad.Env            ( ComonadEnv )
import           Control.Monad.Catch     hiding ( catchJust )
import           Nix.Cited
import           Nix.Eval                      as Eval
                                                ( EvalFrame(EvaluatingExpr,ForcingExpr) )
import           Nix.Exec
import           Nix.Expr.Types.Annotated
import           Nix.Frames
import           Nix.Options
import           Nix.Thunk
import           Nix.Value


-- * data type @Cited@

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


-- ** Helpers

-- | @Cited@ pattern.
-- > pattern CitedP m a = Cited (NCited m a)
pattern CitedP
  :: [Provenance m (NValue t f m)]
  -> a
  -> Cited t f m a
pattern $bCitedP :: [Provenance m (NValue t f m)] -> a -> Cited t f m a
$mCitedP :: forall r (m :: * -> *) t (f :: * -> *) a.
Cited t f m a
-> ([Provenance m (NValue t f m)] -> a -> r) -> (Void# -> r) -> r
CitedP m a = Cited (NCited m a)
{-# complete CitedP #-}

-- | Take:
-- 1. Provenence info.
-- 2. Value (like thunk)
-- -> Produce cited value (thunk)
cite
  :: Functor m
  => [Provenance m (NValue t f m)]
  -> m a
  -> m (Cited t f m a)
cite :: [Provenance m (NValue t f m)] -> m a -> m (Cited t f m a)
cite [Provenance m (NValue t f m)]
v = (a -> Cited t f m a) -> m a -> m (Cited t f m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (NCited m (NValue t f m) a -> Cited t f m a
forall t (f :: * -> *) (m :: * -> *) a.
NCited m (NValue t f m) a -> Cited t f m a
Cited (NCited m (NValue t f m) a -> Cited t f m a)
-> (a -> NCited m (NValue t f m) a) -> a -> Cited t f m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Provenance m (NValue t f m)] -> a -> NCited m (NValue t f m) a
forall (m :: * -> *) v a. [Provenance m v] -> a -> NCited m v a
NCited [Provenance m (NValue t f m)]
v)


-- ** instances

instance
  HasCitations1 m (NValue t f m) (Cited t f m)
 where

  citations1 :: Cited t f m a -> [Provenance m (NValue t f m)]
citations1 (Cited NCited m (NValue t f m) a
c) = NCited m (NValue t f m) a -> [Provenance m (NValue t f m)]
forall (m :: * -> *) v a.
HasCitations m v a =>
a -> [Provenance m v]
citations NCited m (NValue t f m) a
c
  addProvenance1 :: Provenance m (NValue t f m) -> Cited t f m a -> Cited t f m a
addProvenance1 Provenance m (NValue t f m)
x (Cited NCited m (NValue t f m) a
c) = NCited m (NValue t f m) a -> Cited t f m a
forall t (f :: * -> *) (m :: * -> *) a.
NCited m (NValue t f m) a -> Cited t f m a
Cited (NCited m (NValue t f m) a -> Cited t f m a)
-> NCited m (NValue t f m) a -> Cited t f m a
forall a b. (a -> b) -> a -> b
$ Provenance m (NValue t f m)
-> NCited m (NValue t f m) a -> NCited m (NValue t f m) a
forall (m :: * -> *) v a.
HasCitations m v a =>
Provenance m v -> a -> a
addProvenance Provenance m (NValue t f m)
x NCited m (NValue t f m) a
c

instance
  ( Has e Options
  , Framed e m
  , MonadThunk t m v
  , Typeable m
  , Typeable f
  , Typeable u
  , MonadCatch m
  )
  => MonadThunk (Cited u f m t) m v where

  thunk :: m v -> m (Cited u f m t)
  thunk :: m v -> m (Cited u f m t)
thunk m v
mv =
    do
      Options
opts <- m Options
forall e (m :: * -> *).
(MonadReader e m, Has e Options) =>
m Options
askOptions

      (m t -> m (Cited u f m t))
-> (m t -> m (Cited u f m t)) -> Bool -> m t -> m (Cited u f m t)
forall a. a -> a -> Bool -> a
bool
        ([Provenance m (NValue u f m)] -> m t -> m (Cited u f m t)
forall (m :: * -> *) t (f :: * -> *) a.
Functor m =>
[Provenance m (NValue t f m)] -> m a -> m (Cited t f m a)
cite [Provenance m (NValue u f m)]
forall a. Monoid a => a
mempty)
        (\ m t
mt ->
          do
            Frames
frames <- m Frames
forall e (m :: * -> *). (MonadReader e m, Has e Frames) => m Frames
askFrames

            -- Gather the current evaluation context at the time of thunk
            -- creation, and record it along with the thunk.
            let
              fun :: SomeException -> [Provenance m (NValue u f m)]
              fun :: SomeException -> [Provenance m (NValue u f m)]
fun (SomeException -> Maybe (EvalFrame m (NValue u f m))
forall e. Exception e => SomeException -> Maybe e
fromException -> Just (EvaluatingExpr Scopes m (NValue u f m)
scope (Ann SrcSpan
s NExprF (Ann SrcSpan NExprF)
e))) =
                OneItem [Provenance m (NValue u f m)]
-> [Provenance m (NValue u f m)]
forall x. One x => OneItem x -> x
one (OneItem [Provenance m (NValue u f m)]
 -> [Provenance m (NValue u f m)])
-> OneItem [Provenance m (NValue u f m)]
-> [Provenance m (NValue u f m)]
forall a b. (a -> b) -> a -> b
$ Scopes m (NValue u f m)
-> NExprLocF (Maybe (NValue u f m)) -> Provenance m (NValue u f m)
forall (m :: * -> *) v.
Scopes m v -> NExprLocF (Maybe v) -> Provenance m v
Provenance Scopes m (NValue u f m)
scope (NExprLocF (Maybe (NValue u f m)) -> Provenance m (NValue u f m))
-> NExprLocF (Maybe (NValue u f m)) -> Provenance m (NValue u f m)
forall a b. (a -> b) -> a -> b
$ SrcSpan
-> NExprF (Maybe (NValue u f m))
-> NExprLocF (Maybe (NValue u f m))
forall ann (f :: * -> *) a. ann -> f a -> Compose (AnnUnit ann) f a
AnnF SrcSpan
s (Maybe (NValue u f m)
forall a. Maybe a
Nothing Maybe (NValue u f m)
-> NExprF (Ann SrcSpan NExprF) -> NExprF (Maybe (NValue u f m))
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ NExprF (Ann SrcSpan NExprF)
e)
              fun SomeException
_ = [Provenance m (NValue u f m)]
forall a. Monoid a => a
mempty

              ps :: [Provenance m (NValue u f m)]
              ps :: [Provenance m (NValue u f m)]
ps = (NixFrame -> [Provenance m (NValue u f m)])
-> Frames -> [Provenance m (NValue u f m)]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (SomeException -> [Provenance m (NValue u f m)]
fun (SomeException -> [Provenance m (NValue u f m)])
-> (NixFrame -> SomeException)
-> NixFrame
-> [Provenance m (NValue u f m)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixFrame -> SomeException
frame) Frames
frames

            [Provenance m (NValue u f m)] -> m t -> m (Cited u f m t)
forall (m :: * -> *) t (f :: * -> *) a.
Functor m =>
[Provenance m (NValue t f m)] -> m a -> m (Cited t f m a)
cite [Provenance m (NValue u f m)]
ps m t
mt
        )
        (Options -> Bool
isThunks Options
opts)
        (m v -> m t
forall t (m :: * -> *) a. MonadThunk t m a => m a -> m t
thunk m v
mv)

  thunkId :: Cited u f m t -> ThunkId m
  thunkId :: Cited u f m t -> ThunkId m
thunkId (CitedP [Provenance m (NValue u f m)]
_ t
t) = t -> ThunkId m
forall t (m :: * -> *) a. MonadThunk t m a => t -> ThunkId m
thunkId @_ @m t
t

  query :: m v -> Cited u f m t -> m v
  query :: m v -> Cited u f m t -> m v
query m v
m (CitedP [Provenance m (NValue u f m)]
_ t
t) = m v -> t -> m v
forall t (m :: * -> *) a. MonadThunk t m a => m a -> t -> m a
query m v
m t
t

  -- | The ThunkLoop exception is thrown as an exception with MonadThrow,
  --   which does not capture the current stack frame information to provide
  --   it in a NixException, so we catch and re-throw it here using
  --   'throwError' from Frames.hs.
  force :: Cited u f m t -> m v
  force :: Cited u f m t -> m v
force (CitedP [Provenance m (NValue u f m)]
ps t
t) = [Provenance m (NValue u f m)] -> m v -> m v
forall (m :: * -> *) v e a.
(MonadCatch m, Typeable m, Typeable v, Has e Frames,
 MonadReader e m) =>
[Provenance m v] -> m a -> m a
handleDisplayProvenance [Provenance m (NValue u f m)]
ps (m v -> m v) -> m v -> m v
forall a b. (a -> b) -> a -> b
$ t -> m v
forall t (m :: * -> *) a. MonadThunk t m a => t -> m a
force t
t

  forceEff :: Cited u f m t -> m v
  forceEff :: Cited u f m t -> m v
forceEff (CitedP [Provenance m (NValue u f m)]
ps t
t) = [Provenance m (NValue u f m)] -> m v -> m v
forall (m :: * -> *) v e a.
(MonadCatch m, Typeable m, Typeable v, Has e Frames,
 MonadReader e m) =>
[Provenance m v] -> m a -> m a
handleDisplayProvenance [Provenance m (NValue u f m)]
ps (m v -> m v) -> m v -> m v
forall a b. (a -> b) -> a -> b
$ t -> m v
forall t (m :: * -> *) a. MonadThunk t m a => t -> m a
forceEff t
t

  further :: Cited u f m t -> m (Cited u f m t)
  further :: Cited u f m t -> m (Cited u f m t)
further (CitedP [Provenance m (NValue u f m)]
ps t
t) = [Provenance m (NValue u f m)] -> m t -> m (Cited u f m t)
forall (m :: * -> *) t (f :: * -> *) a.
Functor m =>
[Provenance m (NValue t f m)] -> m a -> m (Cited t f m a)
cite [Provenance m (NValue u f m)]
ps (m t -> m (Cited u f m t)) -> m t -> m (Cited u f m t)
forall a b. (a -> b) -> a -> b
$ t -> m t
forall t (m :: * -> *) a. MonadThunk t m a => t -> m t
further t
t


-- ** Kleisli functor HOFs

-- Please, do not use MonadThunkF for MonadThunk, later uses more straight-forward specialized line of functions.
instance
  ( Has e Options
  , Framed e m
  , MonadThunkF t m v
  , Typeable m
  , Typeable f
  , Typeable u
  , MonadCatch m
  )
  => MonadThunkF (Cited u f m t) m v where

  queryF :: (v -> m r) -> m r -> Cited u f m t -> m r
  queryF :: (v -> m r) -> m r -> Cited u f m t -> m r
queryF v -> m r
k m r
m (CitedP [Provenance m (NValue u f m)]
_ t
t) = (v -> m r) -> m r -> t -> m r
forall t (m :: * -> *) a r.
MonadThunkF t m a =>
(a -> m r) -> m r -> t -> m r
queryF v -> m r
k m r
m t
t

  forceF :: (v -> m r) -> Cited u f m t -> m r
  forceF :: (v -> m r) -> Cited u f m t -> m r
forceF v -> m r
k (CitedP [Provenance m (NValue u f m)]
ps t
t) = [Provenance m (NValue u f m)] -> m r -> m r
forall (m :: * -> *) v e a.
(MonadCatch m, Typeable m, Typeable v, Has e Frames,
 MonadReader e m) =>
[Provenance m v] -> m a -> m a
handleDisplayProvenance [Provenance m (NValue u f m)]
ps (m r -> m r) -> m r -> m r
forall a b. (a -> b) -> a -> b
$ (v -> m r) -> t -> m r
forall t (m :: * -> *) a r.
MonadThunkF t m a =>
(a -> m r) -> t -> m r
forceF v -> m r
k t
t

  forceEffF :: (v -> m r) -> Cited u f m t -> m r
  forceEffF :: (v -> m r) -> Cited u f m t -> m r
forceEffF v -> m r
k (CitedP [Provenance m (NValue u f m)]
ps t
t) = [Provenance m (NValue u f m)] -> m r -> m r
forall (m :: * -> *) v e a.
(MonadCatch m, Typeable m, Typeable v, Has e Frames,
 MonadReader e m) =>
[Provenance m v] -> m a -> m a
handleDisplayProvenance [Provenance m (NValue u f m)]
ps (m r -> m r) -> m r -> m r
forall a b. (a -> b) -> a -> b
$ (v -> m r) -> t -> m r
forall t (m :: * -> *) a r.
MonadThunkF t m a =>
(a -> m r) -> t -> m r
forceEffF v -> m r
k t
t

  furtherF :: (m v -> m v) -> Cited u f m t -> m (Cited u f m t)
  furtherF :: (m v -> m v) -> Cited u f m t -> m (Cited u f m t)
furtherF m v -> m v
k (CitedP [Provenance m (NValue u f m)]
ps t
t) = [Provenance m (NValue u f m)] -> m t -> m (Cited u f m t)
forall (m :: * -> *) t (f :: * -> *) a.
Functor m =>
[Provenance m (NValue t f m)] -> m a -> m (Cited t f m a)
cite [Provenance m (NValue u f m)]
ps (m t -> m (Cited u f m t)) -> m t -> m (Cited u f m t)
forall a b. (a -> b) -> a -> b
$ (m v -> m v) -> t -> m t
forall t (m :: * -> *) a.
MonadThunkF t m a =>
(m a -> m a) -> t -> m t
furtherF m v -> m v
k t
t


-- * Representation

handleDisplayProvenance
  :: (MonadCatch m
    , Typeable m
    , Typeable v
    , Has e Frames
    , MonadReader e m
    )
  => [Provenance m v]
  -> m a
  -> m a
handleDisplayProvenance :: [Provenance m v] -> m a -> m a
handleDisplayProvenance [Provenance m v]
ps m a
f =
  m a -> (ThunkLoop -> m a) -> m a
forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
m a -> (e -> m a) -> m a
catch
    ([Provenance m v] -> m a -> m a
forall (m :: * -> *) e v a.
(MonadThrow m, MonadReader e m, Has e Frames, Typeable m,
 Typeable v) =>
[Provenance m v] -> m a -> m a
displayProvenance [Provenance m v]
ps m a
f)
    (forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
forall e (m :: * -> *) a.
(Framed e m, Exception ThunkLoop, MonadThrow m) =>
ThunkLoop -> m a
throwError @ThunkLoop)

displayProvenance
  :: (MonadThrow m
    , MonadReader e m
    , Has e Frames
    , Typeable m
    , Typeable v
    )
  => [Provenance m v]
  -> m a
  -> m a
displayProvenance :: [Provenance m v] -> m a -> m a
displayProvenance =
  (m a -> m a)
-> ([Provenance m v] -> m a -> m a)
-> [Provenance m v]
-> m a
-> m a
forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
list
    m a -> m a
forall a. a -> a
id
    (\ (Provenance Scopes m v
scope e :: NExprLocF (Maybe v)
e@(AnnF SrcSpan
s NExprF (Maybe v)
_) : [Provenance m v]
_) ->
      NixLevel -> EvalFrame m v -> m a -> m a
forall s e (m :: * -> *) a.
(Framed e m, Exception s) =>
NixLevel -> s -> m a -> m a
withFrame NixLevel
Info (EvalFrame m v -> m a -> m a) -> EvalFrame m v -> m a -> m a
forall a b. (a -> b) -> a -> b
$ Scopes m v -> Ann SrcSpan NExprF -> EvalFrame m v
forall (m :: * -> *) v.
Scopes m v -> Ann SrcSpan NExprF -> EvalFrame m v
ForcingExpr Scopes m v
scope (Ann SrcSpan NExprF -> EvalFrame m v)
-> Ann SrcSpan NExprF -> EvalFrame m v
forall a b. (a -> b) -> a -> b
$ SrcSpan -> NExprLocF (Maybe v) -> Ann SrcSpan NExprF
forall r. SrcSpan -> NExprLocF r -> Ann SrcSpan NExprF
wrapExprLoc SrcSpan
s NExprLocF (Maybe v)
e
    )