module Nix
( module Nix.Cache
, module Nix.Exec
, module Nix.Expr.Types
, module Nix.Expr.Shorthands
, module Nix.Expr.Types.Annotated
, module Nix.Frames
, module Nix.Render.Frame
, module Nix.Normal
, module Nix.Options
, module Nix.String
, module Nix.Parser
, module Nix.Pretty
, module Nix.Reduce
, module Nix.Thunk
, module Nix.Value
, module Nix.XML
, withNixContext
, nixEvalExpr
, nixEvalExprLoc
, nixTracingEvalExprLoc
, evaluateExpression
, processResult
)
where
import Nix.Prelude
import Relude.Unsafe ( (!!) )
import GHC.Err ( errorWithoutStackTrace )
import Data.Fix ( Fix )
import qualified Data.HashMap.Lazy as M
import qualified Data.Text as Text
import qualified Data.Text.Read as Text
import Nix.Builtins
import Nix.Cache
import qualified Nix.Eval as Eval
import Nix.Exec
import Nix.Expr.Types
import Nix.Expr.Shorthands
import Nix.Expr.Types.Annotated
import Nix.Frames
import Nix.String
import Nix.Normal
import Nix.Options
import Nix.Parser
import Nix.Pretty
import Nix.Reduce
import Nix.Render.Frame
import Nix.Thunk
import Nix.Value
import Nix.Value.Monad
import Nix.XML
nixEval
:: (MonadNix e t f m, Has e Options, Functor g)
=> Transform g (m a)
-> Alg g (m a)
-> Maybe Path
-> Fix g
-> m a
nixEval :: Transform g (m a) -> Alg g (m a) -> Maybe Path -> Fix g -> m a
nixEval Transform g (m a)
transform Alg g (m a)
alg Maybe Path
mpath = Maybe Path -> m a -> m a
forall e t (f :: * -> *) (m :: * -> *) r.
(MonadNix e t f m, Has e Options) =>
Maybe Path -> m r -> m r
withNixContext Maybe Path
mpath (m a -> m a) -> Transform g (m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Transform g (m a) -> Alg g (m a) -> Fix g -> m a
forall (f :: * -> *) a.
Functor f =>
Transform f a -> Alg f a -> Fix f -> a
adi Transform g (m a)
transform Alg g (m a)
alg
nixEvalExpr
:: (MonadNix e t f m, Has e Options)
=> Maybe Path
-> NExpr
-> m (NValue t f m)
nixEvalExpr :: Maybe Path -> NExpr -> m (NValue t f m)
nixEvalExpr = Transform NExprF (m (NValue t f m))
-> Alg NExprF (m (NValue t f m))
-> Maybe Path
-> NExpr
-> m (NValue t f m)
forall e t (f :: * -> *) (m :: * -> *) (g :: * -> *) a.
(MonadNix e t f m, Has e Options, Functor g) =>
Transform g (m a) -> Alg g (m a) -> Maybe Path -> Fix g -> m a
nixEval Transform NExprF (m (NValue t f m))
forall a. a -> a
id Alg NExprF (m (NValue t f m))
forall v (m :: * -> *). MonadNixEval v m => NExprF (m v) -> m v
Eval.eval
nixEvalExprLoc
:: forall e t f m
. (MonadNix e t f m, Has e Options)
=> Maybe Path
-> NExprLoc
-> m (NValue t f m)
nixEvalExprLoc :: Maybe Path -> NExprLoc -> m (NValue t f m)
nixEvalExprLoc =
Transform NExprLocF (m (NValue t f m))
-> Alg NExprLocF (m (NValue t f m))
-> Maybe Path
-> NExprLoc
-> m (NValue t f m)
forall e t (f :: * -> *) (m :: * -> *) (g :: * -> *) a.
(MonadNix e t f m, Has e Options, Functor g) =>
Transform g (m a) -> Alg g (m a) -> Maybe Path -> Fix g -> m a
nixEval
Transform NExprLocF (m (NValue t f m))
forall v (m :: * -> *) e a.
(Framed e m, Scoped v m, Has e SrcSpan, Typeable m, Typeable v) =>
TransformF NExprLoc (m a)
Eval.addMetaInfo
Alg NExprLocF (m (NValue t f m))
forall v (m :: * -> *) ann.
MonadNixEval v m =>
AnnF ann NExprF (m v) -> m v
Eval.evalContent
nixTracingEvalExprLoc
:: (MonadNix e t f m, Has e Options, MonadIO m, Alternative m)
=> Maybe Path
-> NExprLoc
-> m (NValue t f m)
nixTracingEvalExprLoc :: Maybe Path -> NExprLoc -> m (NValue t f m)
nixTracingEvalExprLoc Maybe Path
mpath = Maybe Path -> m (NValue t f m) -> m (NValue t f m)
forall e t (f :: * -> *) (m :: * -> *) r.
(MonadNix e t f m, Has e Options) =>
Maybe Path -> m r -> m r
withNixContext Maybe Path
mpath (m (NValue t f m) -> m (NValue t f m))
-> (NExprLoc -> m (NValue t f m)) -> NExprLoc -> m (NValue t f m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NExprLoc -> m (NValue t f m)
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NExprLoc -> m (NValue t f m)
evalExprLoc
evaluateExpression
:: (MonadNix e t f m, Has e Options)
=> Maybe Path
-> (Maybe Path -> NExprLoc -> m (NValue t f m))
-> (NValue t f m -> m a)
-> NExprLoc
-> m a
evaluateExpression :: Maybe Path
-> (Maybe Path -> NExprLoc -> m (NValue t f m))
-> (NValue t f m -> m a)
-> NExprLoc
-> m a
evaluateExpression Maybe Path
mpath Maybe Path -> NExprLoc -> m (NValue t f m)
evaluator NValue t f m -> m a
handler NExprLoc
expr =
do
Options
opts <- m Options
forall e (m :: * -> *).
(MonadReader e m, Has e Options) =>
m Options
askOptions
([(Text, NValue t f m)] -> [(VarName, NValue t f m)]
coerce -> [(VarName, NValue t f m)]
args) <-
(((Text, NExpr) -> m (Text, NValue t f m))
-> [(Text, NExpr)] -> m [(Text, NValue t f m)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (((Text, NExpr) -> m (Text, NValue t f m))
-> [(Text, NExpr)] -> m [(Text, NValue t f m)])
-> ((NExpr -> m (NValue t f m))
-> (Text, NExpr) -> m (Text, NValue t f m))
-> (NExpr -> m (NValue t f m))
-> [(Text, NExpr)]
-> m [(Text, NValue t f m)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NExpr -> m (NValue t f m))
-> (Text, NExpr) -> m (Text, NValue t f m)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse)
NExpr -> m (NValue t f m)
eval'
([(Text, NExpr)] -> m [(Text, NValue t f m)])
-> [(Text, NExpr)] -> m [(Text, NValue t f m)]
forall a b. (a -> b) -> a -> b
$ ((Text -> NExpr) -> (Text, Text) -> (Text, NExpr)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second Text -> NExpr
parseArg ((Text, Text) -> (Text, NExpr))
-> [(Text, Text)] -> [(Text, NExpr)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Options -> [(Text, Text)]
getArg Options
opts)
[(Text, NExpr)] -> [(Text, NExpr)] -> [(Text, NExpr)]
forall a. Semigroup a => a -> a -> a
<> ((Text -> NExpr) -> (Text, Text) -> (Text, NExpr)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second Text -> NExpr
mkStr ((Text, Text) -> (Text, NExpr))
-> [(Text, Text)] -> [(Text, NExpr)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Options -> [(Text, Text)]
getArgstr Options
opts)
NValue t f m
f <- Maybe Path -> NExprLoc -> m (NValue t f m)
evaluator Maybe Path
mpath NExprLoc
expr
NValue t f m
f' <- NValue t f m -> m (NValue t f m)
forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
f
NValue t f m
val <-
case NValue t f m
f' of
NVClosure Params ()
_ NValue t f m -> m (NValue t f m)
g -> NValue t f m -> m (NValue t f m)
g (NValue t f m -> m (NValue t f m))
-> NValue t f m -> m (NValue t f m)
forall a b. (a -> b) -> a -> b
$ PositionSet -> AttrSet (NValue t f m) -> NValue t f m
forall (f :: * -> *) t (m :: * -> *).
Applicative f =>
PositionSet -> AttrSet (NValue t f m) -> NValue t f m
mkNVSet PositionSet
forall a. Monoid a => a
mempty (AttrSet (NValue t f m) -> NValue t f m)
-> AttrSet (NValue t f m) -> NValue t f m
forall a b. (a -> b) -> a -> b
$ [(VarName, NValue t f m)] -> AttrSet (NValue t f m)
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(VarName, NValue t f m)]
args
NValue t f m
_ -> NValue t f m -> m (NValue t f m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure NValue t f m
f
(NValue t f m -> m a) -> NValue t f m -> m a
forall e t (f :: * -> *) (m :: * -> *) a.
(MonadNix e t f m, Has e Options) =>
(NValue t f m -> m a) -> NValue t f m -> m a
processResult NValue t f m -> m a
handler NValue t f m
val
where
parseArg :: Text -> NExpr
parseArg Text
s =
(Doc Void -> NExpr)
-> (NExpr -> NExpr) -> Either (Doc Void) NExpr -> NExpr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
([Char] -> NExpr
forall a. [Char] -> a
errorWithoutStackTrace ([Char] -> NExpr) -> (Doc Void -> [Char]) -> Doc Void -> NExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc Void -> [Char]
forall b a. (Show a, IsString b) => a -> b
show)
NExpr -> NExpr
forall a. a -> a
id
(Text -> Either (Doc Void) NExpr
parseNixText Text
s)
eval' :: NExpr -> m (NValue t f m)
eval' = NValue t f m -> m (NValue t f m)
forall e (m :: * -> *) t (f :: * -> *).
(Framed e m, MonadThunk t m (NValue t f m),
MonadDataErrorContext t f m, HasCitations m (NValue t f m) t,
HasCitations1 m (NValue t f m) f, Ord (ThunkId m)) =>
NValue t f m -> m (NValue t f m)
normalForm (NValue t f m -> m (NValue t f m))
-> (NExpr -> m (NValue t f m)) -> NExpr -> m (NValue t f m)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Maybe Path -> NExpr -> m (NValue t f m)
forall e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, Has e Options) =>
Maybe Path -> NExpr -> m (NValue t f m)
nixEvalExpr Maybe Path
mpath
processResult
:: forall e t f m a
. (MonadNix e t f m, Has e Options)
=> (NValue t f m -> m a)
-> NValue t f m
-> m a
processResult :: (NValue t f m -> m a) -> NValue t f m -> m a
processResult NValue t f m -> m a
h NValue t f m
val =
do
Options
opts <- m Options
forall e (m :: * -> *).
(MonadReader e m, Has e Options) =>
m Options
askOptions
m a -> (Text -> m a) -> Maybe Text -> m a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(NValue t f m -> m a
h NValue t f m
val)
(\ ([Text] -> [VarName]
coerce ([Text] -> [VarName]) -> (Text -> [Text]) -> Text -> [VarName]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> [Text]
Text.splitOn Text
"." -> [VarName]
keys) -> [VarName] -> NValue t f m -> m a
processKeys [VarName]
keys NValue t f m
val)
(Options -> Maybe Text
getAttr Options
opts)
where
processKeys :: [VarName] -> NValue t f m -> m a
processKeys :: [VarName] -> NValue t f m -> m a
processKeys [VarName]
kys NValue t f m
v =
m a -> ([VarName] -> m a) -> [VarName] -> m a
forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
list
(NValue t f m -> m a
h NValue t f m
v)
(\ ((VarName
k : [VarName]
ks) :: [VarName]) ->
do
NValue t f m
v' <- NValue t f m -> m (NValue t f m)
forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
v
case (VarName
k, NValue t f m
v') of
(Reader Int
forall a. Integral a => Reader a
Text.decimal Reader Int
-> (VarName -> Text) -> VarName -> Either [Char] (Int, Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VarName -> Text
coerce -> Right (Int
n,Text
""), NVList [NValue t f m]
xs) -> [VarName] -> NValue t f m -> m a
processKeys [VarName]
ks (NValue t f m -> m a) -> NValue t f m -> m a
forall a b. (a -> b) -> a -> b
$ [NValue t f m]
xs [NValue t f m] -> Int -> NValue t f m
forall a. [a] -> Int -> a
!! Int
n
(VarName
_, NVSet PositionSet
_ AttrSet (NValue t f m)
xs) ->
m a -> (NValue t f m -> m a) -> Maybe (NValue t f m) -> m a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
([Char] -> m a
forall a. [Char] -> a
errorWithoutStackTrace ([Char] -> m a) -> [Char] -> m a
forall a b. (a -> b) -> a -> b
$ [Char]
"Set does not contain key ''" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> VarName -> [Char]
forall b a. (Show a, IsString b) => a -> b
show VarName
k [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"''.")
([VarName] -> NValue t f m -> m a
processKeys [VarName]
ks)
(VarName -> AttrSet (NValue t f m) -> Maybe (NValue t f m)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup VarName
k AttrSet (NValue t f m)
xs)
(VarName
_, NValue t f m
_) -> [Char] -> m a
forall a. [Char] -> a
errorWithoutStackTrace ([Char] -> m a) -> [Char] -> m a
forall a b. (a -> b) -> a -> b
$ [Char]
"Expected a set or list for selector '" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> VarName -> [Char]
forall b a. (Show a, IsString b) => a -> b
show VarName
k [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"', but got: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> NValue t f m -> [Char]
forall b a. (Show a, IsString b) => a -> b
show NValue t f m
v
)
[VarName]
kys