{-# language CPP #-}
{-# language AllowAmbiguousTypes #-}
{-# language ConstraintKinds #-}
{-# language FunctionalDependencies #-}
{-# language KindSignatures #-}
{-# language MonoLocalBinds #-}
{-# language MultiWayIf #-}
{-# language PartialTypeSignatures #-}
{-# language QuasiQuotes #-}
{-# language PatternSynonyms #-}
{-# language TemplateHaskell #-}
{-# language UndecidableInstances #-}
{-# language PackageImports #-}
{-# options_ghc -fno-warn-name-shadowing #-}
module Nix.Builtins
( withNixContext
, builtins
)
where
import Nix.Prelude
import GHC.Exception ( ErrorCall(ErrorCall) )
import Control.Monad ( foldM )
import Control.Monad.Catch ( MonadCatch(catch) )
import Control.Monad.ListM ( sortByM )
import "hashing" Crypto.Hash
import qualified "hashing" Crypto.Hash.MD5 as MD5
import qualified "hashing" Crypto.Hash.SHA1 as SHA1
import qualified "hashing" Crypto.Hash.SHA256 as SHA256
import qualified "hashing" Crypto.Hash.SHA512 as SHA512
import qualified Data.Aeson as A
#if MIN_VERSION_aeson(2,0,0)
import qualified Data.Aeson.Key as AKM
import qualified Data.Aeson.KeyMap as AKM
#endif
import Data.Align ( alignWith )
import Data.Array
import Data.Bits
import qualified Data.ByteString as B
import Data.ByteString.Base16 as Base16
import Data.Char ( isDigit )
import Data.Foldable ( foldrM )
import Data.Fix ( foldFix )
import Data.List ( partition )
import qualified Data.HashSet as HS
import qualified Data.HashMap.Lazy as M
import Data.Scientific
import qualified Data.Set as S
import qualified Data.Text as Text
import Data.Text.Read ( decimal )
import qualified Data.Text.Lazy.Builder as Builder
import Data.These ( fromThese, These )
import qualified Data.Time.Clock.POSIX as Time
import qualified Data.Vector as V
import NeatInterpolation ( text )
import Nix.Atoms
import Nix.Convert
import Nix.Effects
import Nix.Effects.Basic ( fetchTarball )
import Nix.Exec
import Nix.Expr.Types
import qualified Nix.Eval as Eval
import Nix.Frames
import Nix.Json
import Nix.Normal
import Nix.Options
import Nix.Parser
import Nix.Render
import Nix.Scope
import Nix.String
import Nix.String.Coerce
import Nix.Value
import Nix.Value.Equal
import Nix.Value.Monad
import Nix.XML
import System.Nix.Base32 as Base32
import System.PosixCompat.Files ( isRegularFile
, isDirectory
, isSymbolicLink
)
import qualified Text.Show
import Text.Regex.TDFA ( Regex
, makeRegex
, matchOnceText
, matchAllText
)
newtype Prim m a = Prim (m a)
data BuiltinType = Normal | TopLevel
data Builtin v =
Builtin
{ forall v. Builtin v -> BuiltinType
_kind :: BuiltinType
, forall v. Builtin v -> (VarName, v)
mapping :: (VarName, v)
}
class ToBuiltin t f m a | a -> m where
toBuiltin :: Text -> a -> m (NValue t f m)
instance
( MonadNix e t f m
, ToValue a m (NValue t f m)
)
=> ToBuiltin t f m (Prim m a) where
toBuiltin :: Text -> Prim m a -> m (NValue t f m)
toBuiltin Text
_ Prim m a
p = forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue @a @m forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< coerce :: forall a b. Coercible a b => a -> b
coerce Prim m a
p
instance
( MonadNix e t f m
, FromValue a m (Deeper (NValue t f m))
, ToBuiltin t f m b
)
=> ToBuiltin t f m (a -> b) where
toBuiltin :: Text -> (a -> b) -> m (NValue t f m)
toBuiltin Text
name a -> b
f =
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
VarName
-> (NValue t w m -> m (Free (NValue' t w m) a))
-> Free (NValue' t w m) a
NVBuiltin (coerce :: forall a b. Coercible a b => a -> b
coerce Text
name) forall a b. (a -> b) -> a -> b
$ forall t (f :: * -> *) (m :: * -> *) a.
ToBuiltin t f m a =>
Text -> a -> m (NValue t f m)
toBuiltin Text
name forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Deeper a
Deeper
newtype WValue t f m = WValue (NValue t f m)
instance NVConstraint f => Eq (WValue t f m) where
WValue (NVConstant (NFloat Float
x)) == :: WValue t f m -> WValue t f m -> Bool
== WValue (NVConstant (NInt Integer
y)) =
Float
x forall a. Eq a => a -> a -> Bool
== forall a. Num a => Integer -> a
fromInteger Integer
y
WValue (NVConstant (NInt Integer
x)) == WValue (NVConstant (NFloat Float
y)) =
forall a. Num a => Integer -> a
fromInteger Integer
x forall a. Eq a => a -> a -> Bool
== Float
y
WValue (NVConstant (NInt Integer
x)) == WValue (NVConstant (NInt Integer
y)) = Integer
x forall a. Eq a => a -> a -> Bool
== Integer
y
WValue (NVConstant (NFloat Float
x)) == WValue (NVConstant (NFloat Float
y)) = Float
x forall a. Eq a => a -> a -> Bool
== Float
y
WValue (NVPath Path
x ) == WValue (NVPath Path
y ) = Path
x forall a. Eq a => a -> a -> Bool
== Path
y
WValue (NVStr NixString
x) == WValue (NVStr NixString
y) =
NixString -> Text
ignoreContext NixString
x forall a. Eq a => a -> a -> Bool
== NixString -> Text
ignoreContext NixString
y
WValue t f m
_ == WValue t f m
_ = Bool
False
instance NVConstraint f => Ord (WValue t f m) where
WValue (NVConstant (NFloat Float
x)) <= :: WValue t f m -> WValue t f m -> Bool
<= WValue (NVConstant (NInt Integer
y)) =
Float
x forall a. Ord a => a -> a -> Bool
<= forall a. Num a => Integer -> a
fromInteger Integer
y
WValue (NVConstant (NInt Integer
x)) <= WValue (NVConstant (NFloat Float
y)) =
forall a. Num a => Integer -> a
fromInteger Integer
x forall a. Ord a => a -> a -> Bool
<= Float
y
WValue (NVConstant (NInt Integer
x)) <= WValue (NVConstant (NInt Integer
y)) = Integer
x forall a. Ord a => a -> a -> Bool
<= Integer
y
WValue (NVConstant (NFloat Float
x)) <= WValue (NVConstant (NFloat Float
y)) = Float
x forall a. Ord a => a -> a -> Bool
<= Float
y
WValue (NVPath Path
x ) <= WValue (NVPath Path
y ) = Path
x forall a. Ord a => a -> a -> Bool
<= Path
y
WValue (NVStr NixString
x) <= WValue (NVStr NixString
y) =
NixString -> Text
ignoreContext NixString
x forall a. Ord a => a -> a -> Bool
<= NixString -> Text
ignoreContext NixString
y
WValue t f m
_ <= WValue t f m
_ = Bool
False
pattern NVBool :: MonadNix e t f m => Bool -> NValue t f m
pattern $bNVBool :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Bool -> NValue t f m
$mNVBool :: forall {r} {e} {t} {f :: * -> *} {m :: * -> *}.
MonadNix e t f m =>
NValue t f m -> (Bool -> r) -> ((# #) -> r) -> r
NVBool a = NVConstant (NBool a)
data NixPathEntryType
= PathEntryPath
| PathEntryURI
deriving (Int -> NixPathEntryType -> ShowS
[NixPathEntryType] -> ShowS
NixPathEntryType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NixPathEntryType] -> ShowS
$cshowList :: [NixPathEntryType] -> ShowS
show :: NixPathEntryType -> String
$cshow :: NixPathEntryType -> String
showsPrec :: Int -> NixPathEntryType -> ShowS
$cshowsPrec :: Int -> NixPathEntryType -> ShowS
Show, NixPathEntryType -> NixPathEntryType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NixPathEntryType -> NixPathEntryType -> Bool
$c/= :: NixPathEntryType -> NixPathEntryType -> Bool
== :: NixPathEntryType -> NixPathEntryType -> Bool
$c== :: NixPathEntryType -> NixPathEntryType -> Bool
Eq)
uriAwareSplit :: Text -> [(Text, NixPathEntryType)]
uriAwareSplit :: Text -> [(Text, NixPathEntryType)]
uriAwareSplit Text
txt =
case (Char -> Bool) -> Text -> (Text, Text)
Text.break (forall a. Eq a => a -> a -> Bool
== Char
':') Text
txt of
(Text
e1, Text
e2)
| Text -> Bool
Text.null Text
e2 -> forall x. One x => OneItem x -> x
one (Text
e1, NixPathEntryType
PathEntryPath)
| Text
"://" Text -> Text -> Bool
`Text.isPrefixOf` Text
e2 ->
let ((Text
suffix, NixPathEntryType
_) : [(Text, NixPathEntryType)]
path) = Text -> [(Text, NixPathEntryType)]
uriAwareSplit (Int -> Text -> Text
Text.drop Int
3 Text
e2) in
(Text
e1 forall a. Semigroup a => a -> a -> a
<> Text
"://" forall a. Semigroup a => a -> a -> a
<> Text
suffix, NixPathEntryType
PathEntryURI) forall a. a -> [a] -> [a]
: [(Text, NixPathEntryType)]
path
| Bool
otherwise -> (Text
e1, NixPathEntryType
PathEntryPath) forall a. a -> [a] -> [a]
: Text -> [(Text, NixPathEntryType)]
uriAwareSplit (Int -> Text -> Text
Text.drop Int
1 Text
e2)
foldNixPath
:: forall e t f m r
. MonadNix e t f m
=> r
-> (Path -> Maybe Text -> NixPathEntryType -> r -> m r)
-> m r
foldNixPath :: forall e t (f :: * -> *) (m :: * -> *) r.
MonadNix e t f m =>
r -> (Path -> Maybe Text -> NixPathEntryType -> r -> m r) -> m r
foldNixPath r
z Path -> Maybe Text -> NixPathEntryType -> r -> m r
f =
do
Maybe (NValue t f m)
mres <- forall a (m :: * -> *). Scoped a m => VarName -> m (Maybe a)
lookupVar VarName
"__includes"
[NixString]
dirs <-
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
forall (f :: * -> *) a. (Applicative f, Monoid a) => f a
stub
((forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Deeper a
Deeper) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall v (m :: * -> *). MonadValue v m => v -> m v
demand)
Maybe (NValue t f m)
mres
Maybe Text
mPath <- forall (m :: * -> *). MonadEnv m => Text -> m (Maybe Text)
getEnvVar Text
"NIX_PATH"
Maybe Text
mDataDir <- forall (m :: * -> *). MonadEnv m => Text -> m (Maybe Text)
getEnvVar Text
"NIX_DATA_DIR"
Path
dataDir <-
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
forall (m :: * -> *). MonadPaths m => m Path
getDataDir
(forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToString a => a -> String
toString)
Maybe Text
mDataDir
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> b -> m b) -> b -> t a -> m b
foldrM
(Text, NixPathEntryType) -> r -> m r
fun
r
z
forall a b. (a -> b) -> a -> b
$ (Text -> (Text, NixPathEntryType)
fromInclude forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixString -> Text
ignoreContext forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [NixString]
dirs)
forall a. Semigroup a => a -> a -> a
<> Text -> [(Text, NixPathEntryType)]
uriAwareSplit forall b a. Monoid b => (a -> b) -> Maybe a -> b
`whenJust` Maybe Text
mPath
forall a. Semigroup a => a -> a -> a
<> forall x. One x => OneItem x -> x
one (Text -> (Text, NixPathEntryType)
fromInclude forall a b. (a -> b) -> a -> b
$ Text
"nix=" forall a. Semigroup a => a -> a -> a
<> forall a. IsString a => String -> a
fromString (coerce :: forall a b. Coercible a b => a -> b
coerce Path
dataDir) forall a. Semigroup a => a -> a -> a
<> Text
"/nix/corepkgs")
where
fromInclude :: Text -> (Text, NixPathEntryType)
fromInclude :: Text -> (Text, NixPathEntryType)
fromInclude Text
x =
(Text
x, ) forall a b. (a -> b) -> a -> b
$
forall a. a -> a -> Bool -> a
bool
NixPathEntryType
PathEntryPath
NixPathEntryType
PathEntryURI
(Text
"://" Text -> Text -> Bool
`Text.isInfixOf` Text
x)
fun :: (Text, NixPathEntryType) -> r -> m r
fun :: (Text, NixPathEntryType) -> r -> m r
fun (Text
x, NixPathEntryType
ty) r
rest =
case Text -> Text -> [Text]
Text.splitOn Text
"=" Text
x of
[Text
p] -> Path -> Maybe Text -> NixPathEntryType -> r -> m r
f (coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall a. ToString a => a -> String
toString Text
p) forall a. Monoid a => a
mempty NixPathEntryType
ty r
rest
[Text
n, Text
p] -> Path -> Maybe Text -> NixPathEntryType -> r -> m r
f (coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall a. ToString a => a -> String
toString Text
p) (forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
n) NixPathEntryType
ty r
rest
[Text]
_ -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"Unexpected entry in NIX_PATH: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Text
x
attrsetGet :: MonadNix e t f m => VarName -> AttrSet (NValue t f m) -> m (NValue t f m)
attrsetGet :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
VarName -> AttrSet (NValue t f m) -> m (NValue t f m)
attrsetGet VarName
k AttrSet (NValue t f m)
s =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ forall a. ToString a => a -> String
toString @Text forall a b. (a -> b) -> a -> b
$ Text
"Attribute '" forall a. Semigroup a => a -> a -> a
<> coerce :: forall a b. Coercible a b => a -> b
coerce VarName
k forall a. Semigroup a => a -> a -> a
<> Text
"' required")
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup VarName
k AttrSet (NValue t f m)
s)
data VersionComponent
= VersionComponentPre
| VersionComponentString !Text
| VersionComponentNumber !Integer
deriving (ReadPrec [VersionComponent]
ReadPrec VersionComponent
Int -> ReadS VersionComponent
ReadS [VersionComponent]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VersionComponent]
$creadListPrec :: ReadPrec [VersionComponent]
readPrec :: ReadPrec VersionComponent
$creadPrec :: ReadPrec VersionComponent
readList :: ReadS [VersionComponent]
$creadList :: ReadS [VersionComponent]
readsPrec :: Int -> ReadS VersionComponent
$creadsPrec :: Int -> ReadS VersionComponent
Read, VersionComponent -> VersionComponent -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VersionComponent -> VersionComponent -> Bool
$c/= :: VersionComponent -> VersionComponent -> Bool
== :: VersionComponent -> VersionComponent -> Bool
$c== :: VersionComponent -> VersionComponent -> Bool
Eq, Eq VersionComponent
VersionComponent -> VersionComponent -> Bool
VersionComponent -> VersionComponent -> Ordering
VersionComponent -> VersionComponent -> VersionComponent
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: VersionComponent -> VersionComponent -> VersionComponent
$cmin :: VersionComponent -> VersionComponent -> VersionComponent
max :: VersionComponent -> VersionComponent -> VersionComponent
$cmax :: VersionComponent -> VersionComponent -> VersionComponent
>= :: VersionComponent -> VersionComponent -> Bool
$c>= :: VersionComponent -> VersionComponent -> Bool
> :: VersionComponent -> VersionComponent -> Bool
$c> :: VersionComponent -> VersionComponent -> Bool
<= :: VersionComponent -> VersionComponent -> Bool
$c<= :: VersionComponent -> VersionComponent -> Bool
< :: VersionComponent -> VersionComponent -> Bool
$c< :: VersionComponent -> VersionComponent -> Bool
compare :: VersionComponent -> VersionComponent -> Ordering
$ccompare :: VersionComponent -> VersionComponent -> Ordering
Ord)
instance Show VersionComponent where
show :: VersionComponent -> String
show =
\case
VersionComponent
VersionComponentPre -> String
"pre"
VersionComponentString Text
s -> forall b a. (Show a, IsString b) => a -> b
show Text
s
VersionComponentNumber Integer
n -> forall b a. (Show a, IsString b) => a -> b
show Integer
n
splitVersion :: Text -> [VersionComponent]
splitVersion :: Text -> [VersionComponent]
splitVersion Text
s =
(\ (Char
x, Text
xs) -> if
| forall a b. Either a b -> Bool
isRight Either String (Integer, Text)
eDigitsPart ->
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
(\ String
e -> forall a t. (HasCallStack, IsText t) => t -> a
error forall a b. (a -> b) -> a -> b
$ Text
"splitVersion: did hit impossible: '" forall a. Semigroup a => a -> a -> a
<> forall a. IsString a => String -> a
fromString String
e forall a. Semigroup a => a -> a -> a
<> Text
"' while parsing '" forall a. Semigroup a => a -> a -> a
<> Text
s forall a. Semigroup a => a -> a -> a
<> Text
"'.")
(\ (Integer, Text)
res ->
forall x. One x => OneItem x -> x
one (Integer -> VersionComponent
VersionComponentNumber forall a b. (a -> b) -> a -> b
$ forall a b. (a, b) -> a
fst (Integer, Text)
res)
forall a. Semigroup a => a -> a -> a
<> Text -> [VersionComponent]
splitVersion (forall a b. (a, b) -> b
snd (Integer, Text)
res)
)
Either String (Integer, Text)
eDigitsPart
| Char
x forall (f :: * -> *) a.
(Foldable f, DisallowElem f, Eq a) =>
a -> f a -> Bool
`elem` String
separators -> Text -> [VersionComponent]
splitVersion Text
xs
| Bool
otherwise -> forall x. One x => OneItem x -> x
one VersionComponent
charsPart forall a. Semigroup a => a -> a -> a
<> Text -> [VersionComponent]
splitVersion Text
rest2
) forall b a. Monoid b => (a -> b) -> Maybe a -> b
`whenJust` Text -> Maybe (Char, Text)
Text.uncons Text
s
where
separators :: String
separators :: String
separators = String
".-"
eDigitsPart :: Either String (Integer, Text)
eDigitsPart :: Either String (Integer, Text)
eDigitsPart = forall a. Integral a => Reader a
decimal @Integer forall a b. (a -> b) -> a -> b
$ Text
s
(Text
charsSpan, Text
rest2) =
(Char -> Bool) -> Text -> (Text, Text)
Text.span
(\Char
c -> Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ Char -> Bool
isDigit Char
c Bool -> Bool -> Bool
|| Char
c forall (f :: * -> *) a.
(Foldable f, DisallowElem f, Eq a) =>
a -> f a -> Bool
`elem` String
separators)
Text
s
charsPart :: VersionComponent
charsPart :: VersionComponent
charsPart =
case Text
charsSpan of
Text
"pre" -> VersionComponent
VersionComponentPre
Text
xs' -> Text -> VersionComponent
VersionComponentString Text
xs'
compareVersions :: Text -> Text -> Ordering
compareVersions :: Text -> Text -> Ordering
compareVersions Text
s1 Text
s2 =
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold forall a b. (a -> b) -> a -> b
$ (forall (f :: * -> *) a b c.
Semialign f =>
(These a b -> c) -> f a -> f b -> f c
alignWith These VersionComponent VersionComponent -> Ordering
cmp forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Text -> [VersionComponent]
splitVersion) Text
s1 Text
s2
where
cmp :: These VersionComponent VersionComponent -> Ordering
cmp :: These VersionComponent VersionComponent -> Ordering
cmp = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall a. Ord a => a -> a -> Ordering
compare forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => m (m a) -> m a
join forall a b. a -> b -> These a b -> (a, b)
fromThese (Text -> VersionComponent
VersionComponentString forall a. Monoid a => a
mempty)
splitDrvName :: Text -> (Text, Text)
splitDrvName :: Text -> (Text, Text)
splitDrvName Text
s =
forall a b. (a -> b) -> (a, a) -> (b, b)
both (Text -> [Text] -> Text
Text.intercalate Text
sep) ([Text]
namePieces, [Text]
versionPieces)
where
sep :: Text
sep = Text
"-"
pieces :: [Text]
pieces :: [Text]
pieces = Text -> Text -> [Text]
Text.splitOn Text
sep Text
s
isFirstVersionPiece :: Text -> Bool
isFirstVersionPiece :: Text -> Bool
isFirstVersionPiece Text
p =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
Bool
False
(Char -> Bool
isDigit forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst)
(Text -> Maybe (Char, Text)
Text.uncons Text
p)
breakAfterFirstItem :: (a -> Bool) -> [a] -> ([a], [a])
breakAfterFirstItem :: forall a. (a -> Bool) -> [a] -> ([a], [a])
breakAfterFirstItem a -> Bool
f =
forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
handlePresence
forall a. Monoid a => a
mempty
(\ (a
h : [a]
t) -> let ([a]
a, [a]
b) = forall a. (a -> Bool) -> [a] -> ([a], [a])
break a -> Bool
f [a]
t in (a
h forall a. a -> [a] -> [a]
: [a]
a, [a]
b))
([Text]
namePieces, [Text]
versionPieces) =
forall a. (a -> Bool) -> [a] -> ([a], [a])
breakAfterFirstItem Text -> Bool
isFirstVersionPiece [Text]
pieces
splitMatches
:: forall e t f m
. MonadNix e t f m
=> Int
-> [[(ByteString, (Int, Int))]]
-> ByteString
-> [NValue t f m]
splitMatches :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Int -> [[(ByteString, (Int, Int))]] -> ByteString -> [NValue t f m]
splitMatches Int
_ [] ByteString
haystack = forall x. One x => OneItem x -> x
one forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
ByteString -> NValue t f m
thunkStr ByteString
haystack
splitMatches Int
_ ([] : [[(ByteString, (Int, Int))]]
_) ByteString
_ =
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Fail in splitMatches: this should never happen!"
splitMatches Int
numDropped (((ByteString
_, (Int
start, Int
len)) : [(ByteString, (Int, Int))]
captures) : [[(ByteString, (Int, Int))]]
mts) ByteString
haystack =
forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
ByteString -> NValue t f m
thunkStr ByteString
before forall a. a -> [a] -> [a]
: NValue t f m
caps forall a. a -> [a] -> [a]
: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Int -> [[(ByteString, (Int, Int))]] -> ByteString -> [NValue t f m]
splitMatches (Int
numDropped forall a. Num a => a -> a -> a
+ Int
relStart forall a. Num a => a -> a -> a
+ Int
len)
[[(ByteString, (Int, Int))]]
mts
(Int -> ByteString -> ByteString
B.drop Int
len ByteString
rest)
where
relStart :: Int
relStart = forall a. Ord a => a -> a -> a
max Int
0 Int
start forall a. Num a => a -> a -> a
- Int
numDropped
(ByteString
before, ByteString
rest) = Int -> ByteString -> (ByteString, ByteString)
B.splitAt Int
relStart ByteString
haystack
caps :: NValue t f m
caps :: NValue t f m
caps = forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList (forall b. (ByteString, (Int, b)) -> NValue t f m
f forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(ByteString, (Int, Int))]
captures)
f :: (ByteString, (Int, b)) -> NValue t f m
f :: forall b. (ByteString, (Int, b)) -> NValue t f m
f (ByteString
a, (Int
s, b
_)) =
forall a. a -> a -> Bool -> a
bool
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Free (NValue' t w m) a
NVNull
(forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
ByteString -> NValue t f m
thunkStr ByteString
a)
(Int
s forall a. Ord a => a -> a -> Bool
>= Int
0)
thunkStr :: NVConstraint f => ByteString -> NValue t f m
thunkStr :: forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
ByteString -> NValue t f m
thunkStr ByteString
s = forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext forall a b. (a -> b) -> a -> b
$ forall a b. ConvertUtf8 a b => b -> a
decodeUtf8 ByteString
s
hasKind
:: forall a e t f m
. (MonadNix e t f m, FromValue a m (NValue t f m))
=> NValue t f m
-> m (NValue t f m)
hasKind :: forall a e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, FromValue a m (NValue t f m)) =>
NValue t f m -> m (NValue t f m)
hasKind =
forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(Maybe a1 -> a2) -> v -> m b
inHaskMay
(forall a. Maybe a -> Bool
isJust @a)
absolutePathFromValue :: MonadNix e t f m => NValue t f m -> m Path
absolutePathFromValue :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m Path
absolutePathFromValue =
\case
NVStr NixString
ns ->
do
let
path :: Path
path = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToString a => a -> String
toString forall a b. (a -> b) -> a -> b
$ NixString -> Text
ignoreContext NixString
ns
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not (Path -> Bool
isAbsolute Path
path)) forall a b. (a -> b) -> a -> b
$ forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"string " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Path
path forall a. Semigroup a => a -> a -> a
<> String
" doesn't represent an absolute path"
pure Path
path
NVPath Path
path -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Path
path
NValue t f m
v -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"expected a path, got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
v
data FileType
= FileTypeRegular
| FileTypeDirectory
| FileTypeSymlink
| FileTypeUnknown
deriving (Int -> FileType -> ShowS
[FileType] -> ShowS
FileType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileType] -> ShowS
$cshowList :: [FileType] -> ShowS
show :: FileType -> String
$cshow :: FileType -> String
showsPrec :: Int -> FileType -> ShowS
$cshowsPrec :: Int -> FileType -> ShowS
Show, ReadPrec [FileType]
ReadPrec FileType
Int -> ReadS FileType
ReadS [FileType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FileType]
$creadListPrec :: ReadPrec [FileType]
readPrec :: ReadPrec FileType
$creadPrec :: ReadPrec FileType
readList :: ReadS [FileType]
$creadList :: ReadS [FileType]
readsPrec :: Int -> ReadS FileType
$creadsPrec :: Int -> ReadS FileType
Read, FileType -> FileType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileType -> FileType -> Bool
$c/= :: FileType -> FileType -> Bool
== :: FileType -> FileType -> Bool
$c== :: FileType -> FileType -> Bool
Eq, Eq FileType
FileType -> FileType -> Bool
FileType -> FileType -> Ordering
FileType -> FileType -> FileType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FileType -> FileType -> FileType
$cmin :: FileType -> FileType -> FileType
max :: FileType -> FileType -> FileType
$cmax :: FileType -> FileType -> FileType
>= :: FileType -> FileType -> Bool
$c>= :: FileType -> FileType -> Bool
> :: FileType -> FileType -> Bool
$c> :: FileType -> FileType -> Bool
<= :: FileType -> FileType -> Bool
$c<= :: FileType -> FileType -> Bool
< :: FileType -> FileType -> Bool
$c< :: FileType -> FileType -> Bool
compare :: FileType -> FileType -> Ordering
$ccompare :: FileType -> FileType -> Ordering
Ord)
instance Convertible e t f m => ToValue FileType m (NValue t f m) where
toValue :: FileType -> m (NValue t f m)
toValue =
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> NixString
mkNixStringWithoutContext forall b c a. (b -> c) -> (a -> b) -> a -> c
.
\case
FileType
FileTypeRegular -> Text
"regular" :: Text
FileType
FileTypeDirectory -> Text
"directory"
FileType
FileTypeSymlink -> Text
"symlink"
FileType
FileTypeUnknown -> Text
"unknown"
derivationNix
:: forall e t f m. (MonadNix e t f m, Scoped (NValue t f m) m)
=> m (NValue t f m)
derivationNix :: forall e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, Scoped (NValue t f m) m) =>
m (NValue t f m)
derivationNix = forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix forall v (m :: * -> *). MonadNixEval v m => NExprF (m v) -> m v
Eval.eval $$(do
let Right expr = parseNixText [text|
drvAttrs @ { outputs ? [ "out" ], ... }:
let
strict = derivationStrict drvAttrs;
commonAttrs = drvAttrs
// (builtins.listToAttrs outputsList)
// { all = map (x: x.value) outputsList;
inherit drvAttrs;
};
outputToAttrListElement = outputName:
{ name = outputName;
value = commonAttrs // {
outPath = builtins.getAttr outputName strict;
drvPath = strict.drvPath;
type = "derivation";
inherit outputName;
};
};
outputsList = map outputToAttrListElement outputs;
in (builtins.head outputsList).value|]
[|| expr ||]
)
nixPathNix :: forall e t f m . MonadNix e t f m => m (NValue t f m)
nixPathNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
nixPathNix =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList
forall a b. (a -> b) -> a -> b
$ forall e t (f :: * -> *) (m :: * -> *) r.
MonadNix e t f m =>
r -> (Path -> Maybe Text -> NixPathEntryType -> r -> m r) -> m r
foldNixPath forall a. Monoid a => a
mempty forall a b. (a -> b) -> a -> b
$
\Path
p Maybe Text
mn NixPathEntryType
ty [Free (NValue' t f m) t]
rest ->
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet
forall a. Monoid a => a
mempty
(forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList
[case NixPathEntryType
ty of
NixPathEntryType
PathEntryPath -> (VarName
"path", forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Path -> Free (NValue' t w m) a
NVPath Path
p)
NixPathEntryType
PathEntryURI -> ( VarName
"uri", forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext forall a b. (a -> b) -> a -> b
$ forall a. IsString a => String -> a
fromString forall a b. (a -> b) -> a -> b
$ coerce :: forall a b. Coercible a b => a -> b
coerce Path
p)
, ( VarName
"prefix", forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext forall a b. (a -> b) -> a -> b
$ forall m. Monoid m => Maybe m -> m
maybeToMonoid Maybe Text
mn)
]
)
)
forall a. Semigroup a => a -> a -> a
<> [Free (NValue' t f m) t]
rest
toStringNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
toStringNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
toStringNix = forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall e t (f :: * -> *) (m :: * -> *).
(Framed e m, MonadStore m, MonadThrow m,
MonadDataErrorContext t f m, MonadValue (NValue t f m) m) =>
(NValue t f m -> NValue t f m -> m (NValue t f m))
-> CopyToStoreMode -> NValue t f m -> m NixString
coerceAnyToNixString forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc CopyToStoreMode
DontCopyToStore
hasAttrNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
hasAttrNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
hasAttrNix NValue t f m
x NValue t f m
y =
do
(coerce :: forall a b. Coercible a b => a -> b
coerce -> VarName
key) <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
x
(AttrSet (NValue t f m)
aset, PositionSet
_) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m), PositionSet) NValue t f m
y
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Bool
M.member VarName
key AttrSet (NValue t f m)
aset
hasContextNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
hasContextNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
hasContextNix = forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(a1 -> a2) -> v -> m b
inHask NixString -> Bool
hasContext
getAttrNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
getAttrNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
getAttrNix NValue t f m
x NValue t f m
y =
do
(coerce :: forall a b. Coercible a b => a -> b
coerce -> VarName
key) <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
x
(AttrSet (NValue t f m)
aset, PositionSet
_) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m), PositionSet) NValue t f m
y
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
VarName -> AttrSet (NValue t f m) -> m (NValue t f m)
attrsetGet VarName
key AttrSet (NValue t f m)
aset
unsafeDiscardOutputDependencyNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> m (NValue t f m)
unsafeDiscardOutputDependencyNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
unsafeDiscardOutputDependencyNix NValue t f m
nv =
do
(HashSet StringContext
nc, Text
ns) <- (NixString -> HashSet StringContext
getStringContext forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& NixString -> Text
ignoreContext) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
nv
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ HashSet StringContext -> Text -> NixString
mkNixString (forall b a.
(Hashable b, Eq b) =>
(a -> b) -> HashSet a -> HashSet b
HS.map StringContext -> StringContext
discard HashSet StringContext
nc) Text
ns
where
discard :: StringContext -> StringContext
discard :: StringContext -> StringContext
discard (StringContext ContextFlavor
AllOutputs VarName
a) = ContextFlavor -> VarName -> StringContext
StringContext ContextFlavor
DirectPath VarName
a
discard StringContext
x = StringContext
x
unsafeGetAttrPosNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
unsafeGetAttrPosNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
unsafeGetAttrPosNix NValue t f m
nvX NValue t f m
nvY =
do
NValue t f m
x <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvX
NValue t f m
y <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvY
case (NValue t f m
x, NValue t f m
y) of
(NVStr NixString
ns, NVSet PositionSet
apos AttrSet (NValue t f m)
_) ->
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(forall (f :: * -> *) a. Applicative f => a -> f a
pure forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Free (NValue' t w m) a
NVNull)
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue
(forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup @VarName (coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ NixString -> Text
ignoreContext NixString
ns) PositionSet
apos)
(NValue t f m, NValue t f m)
_xy -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"Invalid types for builtins.unsafeGetAttrPosNix: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show (NValue t f m, NValue t f m)
_xy
lengthNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
lengthNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
lengthNix = forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(a1 -> a2) -> v -> m b
inHask (forall (t :: * -> *) a. Foldable t => t a -> Int
length :: [NValue t f m] -> Int)
addNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
addNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
addNix NValue t f m
nvX NValue t f m
nvY =
do
NValue t f m
x' <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvX
NValue t f m
y' <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvY
case (NValue t f m
x', NValue t f m
y') of
(NVConstant (NInt Integer
x), NVConstant (NInt Integer
y)) -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue ( Integer
x forall a. Num a => a -> a -> a
+ Integer
y :: Integer )
(NVConstant (NFloat Float
x), NVConstant (NInt Integer
y)) -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Float
x forall a. Num a => a -> a -> a
+ forall a. Num a => Integer -> a
fromInteger Integer
y
(NVConstant (NInt Integer
x), NVConstant (NFloat Float
y)) -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ forall a. Num a => Integer -> a
fromInteger Integer
x forall a. Num a => a -> a -> a
+ Float
y
(NVConstant (NFloat Float
x), NVConstant (NFloat Float
y)) -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Float
x forall a. Num a => a -> a -> a
+ Float
y
(NValue t f m
_x , NValue t f m
_y ) -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall t (f :: * -> *) (m :: * -> *).
NValue t f m -> NValue t f m -> ValueFrame t f m
Addition NValue t f m
_x NValue t f m
_y
mulNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
mulNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
mulNix NValue t f m
nvX NValue t f m
nvY =
do
NValue t f m
x' <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvX
NValue t f m
y' <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvY
case (NValue t f m
x', NValue t f m
y') of
(NVConstant (NInt Integer
x), NVConstant (NInt Integer
y)) -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue (Integer
x forall a. Num a => a -> a -> a
* Integer
y :: Integer )
(NVConstant (NFloat Float
x), NVConstant (NInt Integer
y)) -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue (Float
x forall a. Num a => a -> a -> a
* forall a. Num a => Integer -> a
fromInteger Integer
y)
(NVConstant (NInt Integer
x), NVConstant (NFloat Float
y)) -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue (forall a. Num a => Integer -> a
fromInteger Integer
x forall a. Num a => a -> a -> a
* Float
y)
(NVConstant (NFloat Float
x), NVConstant (NFloat Float
y)) -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue (Float
x forall a. Num a => a -> a -> a
* Float
y )
(NValue t f m
_x , NValue t f m
_y ) -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall t (f :: * -> *) (m :: * -> *).
NValue t f m -> NValue t f m -> ValueFrame t f m
Multiplication NValue t f m
_x NValue t f m
_y
divNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
divNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
divNix NValue t f m
nvX NValue t f m
nvY =
do
NValue t f m
x' <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvX
NValue t f m
y' <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvY
case (NValue t f m
x', NValue t f m
y') of
(NVConstant (NInt Integer
x), NVConstant (NInt Integer
y)) | Integer
y forall a. Eq a => a -> a -> Bool
/= Integer
0 -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue ( forall a b. (RealFrac a, Integral b) => a -> b
floor (forall a. Num a => Integer -> a
fromInteger Integer
x forall a. Fractional a => a -> a -> a
/ forall a. Num a => Integer -> a
fromInteger Integer
y :: Double) :: Integer)
(NVConstant (NFloat Float
x), NVConstant (NInt Integer
y)) | Integer
y forall a. Eq a => a -> a -> Bool
/= Integer
0 -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Float
x forall a. Fractional a => a -> a -> a
/ forall a. Num a => Integer -> a
fromInteger Integer
y
(NVConstant (NInt Integer
x), NVConstant (NFloat Float
y)) | Float
y forall a. Eq a => a -> a -> Bool
/= Float
0 -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ forall a. Num a => Integer -> a
fromInteger Integer
x forall a. Fractional a => a -> a -> a
/ Float
y
(NVConstant (NFloat Float
x), NVConstant (NFloat Float
y)) | Float
y forall a. Eq a => a -> a -> Bool
/= Float
0 -> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Float
x forall a. Fractional a => a -> a -> a
/ Float
y
(NValue t f m
_x , NValue t f m
_y ) -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ forall t (f :: * -> *) (m :: * -> *).
NValue t f m -> NValue t f m -> ValueFrame t f m
Division NValue t f m
_x NValue t f m
_y
anyNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
anyNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
anyNix NValue t f m
f = forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
anyMNix forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
f) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue
where
anyMNix :: Monad m => (a -> m Bool) -> [a] -> m Bool
anyMNix :: forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
anyMNix a -> m Bool
_ [] = forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
anyMNix a -> m Bool
p (a
x : [a]
xs) =
forall a. a -> a -> Bool -> a
bool
(forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
anyMNix a -> m Bool
p [a]
xs)
(forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< a -> m Bool
p a
x
allNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
allNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
allNix NValue t f m
f = forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
allMNix forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
f) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue
where
allMNix :: Monad m => (a -> m Bool) -> [a] -> m Bool
allMNix :: forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
allMNix a -> m Bool
_ [] = forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
allMNix a -> m Bool
p (a
x : [a]
xs) =
forall a. a -> a -> Bool -> a
bool
(forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False)
(forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
allMNix a -> m Bool
p [a]
xs)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< a -> m Bool
p a
x
foldl'Nix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> NValue t f m
-> m (NValue t f m)
foldl'Nix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> NValue t f m -> m (NValue t f m)
foldl'Nix NValue t f m
f NValue t f m
z NValue t f m
xs = forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM NValue t f m -> NValue t f m -> m (NValue t f m)
go NValue t f m
z forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m] NValue t f m
xs
where
go :: NValue t f m -> NValue t f m -> m (NValue t f m)
go NValue t f m
b NValue t f m
a = (forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
`callFunc` NValue t f m
a) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
f NValue t f m
b
headNix :: forall e t f m. MonadNix e t f m => NValue t f m -> m (NValue t f m)
headNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
headNix =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall String
"builtins.head: empty list")
forall (f :: * -> *) a. Applicative f => a -> f a
pure
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (NonEmpty a -> b) -> [a] -> Maybe b
viaNonEmpty forall (f :: * -> *) a. IsNonEmpty f a a "head" => f a -> a
head forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m]
tailNix :: forall e t f m. MonadNix e t f m => NValue t f m -> m (NValue t f m)
tailNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
tailNix =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall String
"builtins.tail: empty list")
(forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (NonEmpty a -> b) -> [a] -> Maybe b
viaNonEmpty forall (f :: * -> *) a. IsNonEmpty f a [a] "tail" => f a -> [a]
tail forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m]
splitVersionNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
splitVersionNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
splitVersionNix NValue t f m
v =
do
Text
version <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
v
pure $
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList forall a b. (a -> b) -> a -> b
$
forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. (Show a, IsString b) => a -> b
show forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
Text -> [VersionComponent]
splitVersion Text
version
compareVersionsNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
compareVersionsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
compareVersionsNix NValue t f m
t1 NValue t f m
t2 =
do
Text
s1 <- NValue t f m -> m Text
mkText NValue t f m
t1
Text
s2 <- NValue t f m -> m Text
mkText NValue t f m
t2
let
cmpVers :: Integer
cmpVers =
case Text -> Text -> Ordering
compareVersions Text
s1 Text
s2 of
Ordering
LT -> -Integer
1
Ordering
EQ -> Integer
0
Ordering
GT -> Integer
1
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
NAtom -> Free (NValue' t w m) a
NVConstant forall a b. (a -> b) -> a -> b
$ Integer -> NAtom
NInt Integer
cmpVers
where
mkText :: NValue t f m -> m Text
mkText = forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue
parseDrvNameNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
parseDrvNameNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
parseDrvNameNix NValue t f m
drvname =
do
Text
s <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
drvname
let
(Text
name :: Text, Text
version :: Text) = Text -> (Text, Text)
splitDrvName Text
s
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue @(AttrSet (NValue t f m)) forall a b. (a -> b) -> a -> b
$
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList
[ ( VarName
"name" :: VarName
, forall {t} {m :: * -> *}. Text -> NValue t f m
mkNVStr Text
name
)
, ( VarName
"version"
, forall {t} {m :: * -> *}. Text -> NValue t f m
mkNVStr Text
version
)
]
where
mkNVStr :: Text -> NValue t f m
mkNVStr = forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext
matchNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
matchNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
matchNix NValue t f m
pat NValue t f m
str =
do
Text
p <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
pat
NixString
ns <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
str
let
s :: Text
s = NixString -> Text
ignoreContext NixString
ns
re :: Regex
re = forall regex compOpt execOpt source.
RegexMaker regex compOpt execOpt source =>
source -> regex
makeRegex Text
p :: Regex
mkMatch :: Text -> f (Free (NValue' t w m) a)
mkMatch Text
t =
forall a. a -> a -> Bool -> a
bool
(forall (f :: * -> *) a. Applicative f => a -> f a
pure forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Free (NValue' t w m) a
NVNull)
(forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Text -> NixString
mkNixStringWithoutContext Text
t)
(Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ Text -> Bool
Text.null Text
t)
case forall regex source.
RegexLike regex source =>
regex -> source -> Maybe (source, MatchText source, source)
matchOnceText Regex
re Text
s of
Just (Text
"", MatchText Text
sarr, Text
"") ->
do
let submatches :: [Text]
submatches = forall a b. (a, b) -> a
fst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i e. Array i e -> [e]
elems MatchText Text
sarr
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
forall {w :: * -> *} {f :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative f, Applicative w,
ToValue NixString f (Free (NValue' t w m) a)) =>
Text -> f (Free (NValue' t w m) a)
mkMatch
(case [Text]
submatches of
[] -> forall a. Monoid a => a
mempty
[Text
a] -> forall x. One x => OneItem x -> x
one Text
a
Text
_:[Text]
xs -> [Text]
xs
)
Maybe (Text, MatchText Text, Text)
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Free (NValue' t w m) a
NVNull
splitNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
splitNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
splitNix NValue t f m
pat NValue t f m
str =
do
Text
p <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
pat
NixString
ns <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
str
let
s :: Text
s = NixString -> Text
ignoreContext NixString
ns
regex :: Regex
regex = forall regex compOpt execOpt source.
RegexMaker regex compOpt execOpt source =>
source -> regex
makeRegex Text
p :: Regex
haystack :: ByteString
haystack = forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 Text
s
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList forall a b. (a -> b) -> a -> b
$ forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Int -> [[(ByteString, (Int, Int))]] -> ByteString -> [NValue t f m]
splitMatches Int
0 (forall i e. Array i e -> [e]
elems forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall regex source.
RegexLike regex source =>
regex -> source -> [MatchText source]
matchAllText Regex
regex ByteString
haystack) ByteString
haystack
substringNix :: forall e t f m. MonadNix e t f m => Int -> Int -> NixString -> Prim m NixString
substringNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Int -> Int -> NixString -> Prim m NixString
substringNix Int
start Int
len NixString
str =
forall (m :: * -> *) a. m a -> Prim m a
Prim forall a b. (a -> b) -> a -> b
$
forall a. a -> a -> Bool -> a
bool
(forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.substring: negative start position: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Int
start)
(forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ (Text -> Text) -> NixString -> NixString
modifyNixContents (Text -> Text
take forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text -> Text
Text.drop Int
start) NixString
str)
(Int
start forall a. Ord a => a -> a -> Bool
>= Int
0)
where
take :: Text -> Text
take =
forall a. a -> a -> Bool -> a
bool
forall a. a -> a
id
(Int -> Text -> Text
Text.take Int
len)
(Int
len forall a. Ord a => a -> a -> Bool
>= Int
0)
attrNamesNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
attrNamesNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
attrNamesNix =
m (Deeper (NValue t f m)) -> m (NValue t f m)
coersion forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(a1 -> a2) -> v -> m b
inHask @(AttrSet (NValue t f m))
(forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text -> NixString
mkNixStringWithoutContext forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> [a]
sort forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k v. HashMap k v -> [k]
M.keys)
where
coersion :: m (Deeper (NValue t f m)) -> m (NValue t f m)
coersion = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (coerce :: forall a b. Coercible a b => a -> b
coerce :: CoerceDeeperToNValue t f m)
attrValuesNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
attrValuesNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
attrValuesNix NValue t f m
nvattrs =
do
AttrSet (NValue t f m)
attrs <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m)) NValue t f m
nvattrs
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$
forall a b. (a, b) -> b
snd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn
(forall a b. (a, b) -> a
fst @VarName @(NValue t f m))
(forall k v. HashMap k v -> [(k, v)]
M.toList AttrSet (NValue t f m)
attrs)
mapNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
mapNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
mapNix NValue t f m
f =
forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(a1 -> m a2) -> v -> m b
inHaskM @[NValue t f m]
(forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
(forall v (m :: * -> *). MonadValue v m => m v -> m v
defer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s e (m :: * -> *) a.
(Framed e m, Exception s) =>
NixLevel -> s -> m a -> m a
withFrame NixLevel
Debug (String -> ErrorCall
ErrorCall String
"While applying f in map:\n")
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
f
)
)
mapAttrsNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
mapAttrsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
mapAttrsNix NValue t f m
f NValue t f m
xs =
do
AttrSet (NValue t f m)
nixAttrset <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m)) NValue t f m
xs
let
keyVals :: [(VarName, NValue t f m)]
keyVals = forall k v. HashMap k v -> [(k, v)]
M.toList AttrSet (NValue t f m)
nixAttrset
keys :: [VarName]
keys = forall a b. (a, b) -> a
fst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(VarName, NValue t f m)]
keyVals
applyFunToKeyVal :: (VarName, NValue t f m) -> m (NValue t f m)
applyFunToKeyVal (VarName
key, NValue t f m
val) =
do
NValue t f m
runFunForKey <- forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
f forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext (coerce :: forall a b. Coercible a b => a -> b
coerce VarName
key)
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
runFunForKey NValue t f m
val
[NValue t f m]
newVals <-
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
(forall v (m :: * -> *). MonadValue v m => m v -> m v
defer @(NValue t f m) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s e (m :: * -> *) a.
(Framed e m, Exception s) =>
NixLevel -> s -> m a -> m a
withFrame NixLevel
Debug (String -> ErrorCall
ErrorCall String
"While applying f in mapAttrs:\n") forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VarName, NValue t f m) -> m (NValue t f m)
applyFunToKeyVal)
[(VarName, NValue t f m)]
keyVals
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList forall a b. (a -> b) -> a -> b
$ forall a b. [a] -> [b] -> [(a, b)]
zip [VarName]
keys [NValue t f m]
newVals
filterNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
filterNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
filterNix NValue t f m
f =
forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(a1 -> m a2) -> v -> m b
inHaskM
(forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM NValue t f m -> m Bool
fh)
where
fh :: NValue t f m -> m Bool
fh :: NValue t f m -> m Bool
fh = forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
f
catAttrsNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
catAttrsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
catAttrsNix NValue t f m
attrName NValue t f m
xs =
do
Text
n <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
attrName
[NValue t f m]
l <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m] NValue t f m
xs
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Maybe a] -> [a]
catMaybes forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
(forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup @VarName forall a b. (a -> b) -> a -> b
$ coerce :: forall a b. Coercible a b => a -> b
coerce Text
n) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall v (m :: * -> *). MonadValue v m => v -> m v
demand)
[NValue t f m]
l
baseNameOfNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
baseNameOfNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
baseNameOfNix NValue t f m
x =
do
NixString
ns <- forall e t (f :: * -> *) (m :: * -> *).
(Framed e m, MonadStore m, MonadThrow m,
MonadDataErrorContext t f m, MonadValue (NValue t f m) m) =>
CopyToStoreMode -> NValue t f m -> m NixString
coerceStringlikeToNixString CopyToStoreMode
DontCopyToStore NValue t f m
x
pure $
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
NixString -> Free (NValue' t w m) a
NVStr forall a b. (a -> b) -> a -> b
$
(Text -> Text) -> NixString -> NixString
modifyNixContents
(forall a. IsString a => String -> a
fromString forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce Path -> Path
takeFileName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToString a => a -> String
toString)
NixString
ns
bitAndNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
bitAndNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
bitAndNix NValue t f m
x NValue t f m
y =
do
Integer
a <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @Integer NValue t f m
x
Integer
b <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @Integer NValue t f m
y
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Integer
a forall a. Bits a => a -> a -> a
.&. Integer
b
bitOrNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
bitOrNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
bitOrNix NValue t f m
x NValue t f m
y =
do
Integer
a <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @Integer NValue t f m
x
Integer
b <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @Integer NValue t f m
y
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Integer
a forall a. Bits a => a -> a -> a
.|. Integer
b
bitXorNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
bitXorNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
bitXorNix NValue t f m
x NValue t f m
y =
do
Integer
a <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @Integer NValue t f m
x
Integer
b <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @Integer NValue t f m
y
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Integer
a forall a. Bits a => a -> a -> a
`xor` Integer
b
builtinsBuiltinNix
:: forall e t f m
. MonadNix e t f m
=> m (NValue t f m)
builtinsBuiltinNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
builtinsBuiltinNix = forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall String
"HNix does not provide builtins.builtins at the moment. Using builtins directly should be preferred"
attrGetOr
:: forall e t f m v a
. (MonadNix e t f m, FromValue v m (NValue t f m))
=> a
-> (v -> m a)
-> VarName
-> AttrSet (NValue t f m)
-> m a
attrGetOr :: forall e t (f :: * -> *) (m :: * -> *) v a.
(MonadNix e t f m, FromValue v m (NValue t f m)) =>
a -> (v -> m a) -> VarName -> AttrSet (NValue t f m) -> m a
attrGetOr a
fallback v -> m a
fun VarName
name AttrSet (NValue t f m)
attrs =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(forall (f :: * -> *) a. Applicative f => a -> f a
pure a
fallback)
(v -> m a
fun forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue)
(forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup VarName
name AttrSet (NValue t f m)
attrs)
pathNix :: forall e t f m. MonadNix e t f m => NValue t f m -> m (NValue t f m)
pathNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
pathNix NValue t f m
arg =
do
AttrSet (NValue t f m)
attrs <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m)) NValue t f m
arg
Path
path <- forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToString a => a -> String
toString) forall a b. (a -> b) -> a -> b
$ forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< NValue t f m -> m NixString
coerceToPath forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
VarName -> AttrSet (NValue t f m) -> m (NValue t f m)
attrsetGet VarName
"path" AttrSet (NValue t f m)
attrs
Text
name <- forall a. ToText a => a -> Text
toText forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e t (f :: * -> *) (m :: * -> *) v a.
(MonadNix e t f m, FromValue v m (NValue t f m)) =>
a -> (v -> m a) -> VarName -> AttrSet (NValue t f m) -> m a
attrGetOr (Path -> Path
takeFileName Path
path) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToString a => a -> String
toString) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext) VarName
"name" AttrSet (NValue t f m)
attrs
Bool
recursive <- forall e t (f :: * -> *) (m :: * -> *) v a.
(MonadNix e t f m, FromValue v m (NValue t f m)) =>
a -> (v -> m a) -> VarName -> AttrSet (NValue t f m) -> m a
attrGetOr Bool
True forall (f :: * -> *) a. Applicative f => a -> f a
pure VarName
"recursive" AttrSet (NValue t f m)
attrs
Right (coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToText a => a -> Text
toText forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce @StorePath @String -> VarName
s) <- forall (m :: * -> *).
MonadStore m =>
Text
-> NarContent -> Bool -> Bool -> m (Either ErrorCall StorePath)
addToStore Text
name (Path -> NarContent
NarFile Path
path) Bool
recursive Bool
False
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
NixString -> Free (NValue' t w m) a
NVStr forall a b. (a -> b) -> a -> b
$ StringContext -> VarName -> NixString
mkNixStringWithSingletonContext (ContextFlavor -> VarName -> StringContext
StringContext ContextFlavor
DirectPath VarName
s) VarName
s
where
coerceToPath :: NValue t f m -> m NixString
coerceToPath = forall e t (f :: * -> *) (m :: * -> *).
(Framed e m, MonadStore m, MonadThrow m,
MonadDataErrorContext t f m, MonadValue (NValue t f m) m) =>
(NValue t f m -> NValue t f m -> m (NValue t f m))
-> CopyToStoreMode -> CoercionLevel -> NValue t f m -> m NixString
coerceToString forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc CopyToStoreMode
DontCopyToStore CoercionLevel
CoerceAny
dirOfNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
dirOfNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
dirOfNix NValue t f m
nvdir =
do
NValue t f m
dir <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvdir
case NValue t f m
dir of
NVStr NixString
ns -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
NixString -> Free (NValue' t w m) a
NVStr forall a b. (a -> b) -> a -> b
$ (Text -> Text) -> NixString -> NixString
modifyNixContents (forall a. IsString a => String -> a
fromString forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce Path -> Path
takeDirectory forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToString a => a -> String
toString) NixString
ns
NVPath Path
path -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Path -> Free (NValue' t w m) a
NVPath forall a b. (a -> b) -> a -> b
$ Path -> Path
takeDirectory Path
path
NValue t f m
v -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"dirOf: expected string or path, got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
v
unsafeDiscardStringContextNix
:: MonadNix e t f m => NValue t f m -> m (NValue t f m)
unsafeDiscardStringContextNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
unsafeDiscardStringContextNix =
forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(a1 -> a2) -> v -> m b
inHask (Text -> NixString
mkNixStringWithoutContext forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixString -> Text
ignoreContext)
seqNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
seqNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
seqNix NValue t f m
a NValue t f m
b = NValue t f m
b forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
a
deepSeqNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
deepSeqNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
deepSeqNix NValue t f m
a NValue t f m
b = NValue t f m
b forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall e (m :: * -> *) t (f :: * -> *).
(Framed e m, MonadThunk t m (NValue t f m),
MonadDataErrorContext t f m, Ord (ThunkId m)) =>
NValue t f m -> m ()
normalForm_ NValue t f m
a
elemNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
elemNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
elemNix NValue t f m
x = forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(a1 -> m a2) -> v -> m b
inHaskM (forall a. Monad m => (a -> m Bool) -> [a] -> m Bool
anyMNix forall a b. (a -> b) -> a -> b
$ forall t (f :: * -> *) (m :: * -> *).
(MonadThunk t m (NValue t f m), NVConstraint f) =>
NValue t f m -> NValue t f m -> m Bool
valueEqM NValue t f m
x)
where
anyMNix :: Monad m => (a -> m Bool) -> [a] -> m Bool
anyMNix :: forall a. Monad m => (a -> m Bool) -> [a] -> m Bool
anyMNix a -> m Bool
p =
forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
handlePresence
(forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False)
(\ (a
x : [a]
xss) ->
forall a. a -> a -> Bool -> a
bool
(forall a. Monad m => (a -> m Bool) -> [a] -> m Bool
anyMNix a -> m Bool
p [a]
xss)
(forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< a -> m Bool
p a
x
)
elemAtNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
elemAtNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
elemAtNix NValue t f m
xs NValue t f m
n =
do
Int
n' <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
n
[NValue t f m]
xs' <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
xs
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.elem: Index " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Int
n' forall a. Semigroup a => a -> a -> a
<> String
" too large for list of length " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show (forall (t :: * -> *) a. Foldable t => t a -> Int
length [NValue t f m]
xs'))
forall (f :: * -> *) a. Applicative f => a -> f a
pure
([NValue t f m]
xs' forall a. [a] -> Int -> Maybe a
!!? Int
n')
genListNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
genListNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
genListNix NValue t f m
f NValue t f m
nixN =
do
Integer
n <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @Integer NValue t f m
nixN
forall a. a -> a -> Bool -> a
bool
(forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.genList: Expected a non-negative number, got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Integer
n)
(forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall v (m :: * -> *). MonadValue v m => m v -> m v
defer forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
f forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue) [Integer
0 .. Integer
n forall a. Num a => a -> a -> a
- Integer
1])
(Integer
n forall a. Ord a => a -> a -> Bool
>= Integer
0)
genericClosureNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
genericClosureNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
genericClosureNix NValue t f m
c =
do
AttrSet (NValue t f m)
s <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m)) NValue t f m
c
case (forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup VarName
"startSet" AttrSet (NValue t f m)
s, forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup VarName
"operator" AttrSet (NValue t f m)
s) of
(Maybe (NValue t f m)
Nothing , Maybe (NValue t f m)
Nothing ) -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall String
"builtins.genericClosure: Attributes 'startSet' and 'operator' required"
(Maybe (NValue t f m)
Nothing , Just NValue t f m
_ ) -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall String
"builtins.genericClosure: Attribute 'startSet' required"
(Just NValue t f m
_ , Maybe (NValue t f m)
Nothing ) -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall String
"builtins.genericClosure: Attribute 'operator' required"
(Just NValue t f m
startSet, Just NValue t f m
operator) ->
do
[NValue t f m]
ss <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m] forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
startSet
NValue t f m
op <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
operator
let
go
:: Set (WValue t f m)
-> [NValue t f m]
-> m (Set (WValue t f m), [NValue t f m])
go :: Set (WValue t f m)
-> [NValue t f m] -> m (Set (WValue t f m), [NValue t f m])
go Set (WValue t f m)
ks [] = forall (f :: * -> *) a. Applicative f => a -> f a
pure (Set (WValue t f m)
ks, forall a. Monoid a => a
mempty)
go Set (WValue t f m)
ks (NValue t f m
t : [NValue t f m]
ts) =
do
NValue t f m
v <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
t
NValue t f m
k <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
VarName -> AttrSet (NValue t f m) -> m (NValue t f m)
attrsetGet VarName
"key" forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m)) NValue t f m
v
forall a. a -> a -> Bool -> a
bool
(do
forall e (m :: * -> *) t (f :: * -> *).
(Framed e m, MonadDataErrorContext t f m) =>
NValue t f m -> NValue t f m -> m ()
checkComparable NValue t f m
k forall a b. (a -> b) -> a -> b
$
forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
handlePresence
NValue t f m
k
(\ (WValue NValue t f m
j:[WValue t f m]
_) -> NValue t f m
j)
(forall a. Set a -> [a]
S.toList Set (WValue t f m)
ks)
forall (f :: * -> *) (g :: * -> *) a b.
(Functor f, Functor g) =>
(a -> b) -> f (g a) -> f (g b)
(<<$>>) (NValue t f m
v forall a. a -> [a] -> [a]
:) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (WValue t f m)
-> [NValue t f m] -> m (Set (WValue t f m), [NValue t f m])
go (forall a. Ord a => a -> Set a -> Set a
S.insert (forall t (f :: * -> *) (m :: * -> *). NValue t f m -> WValue t f m
WValue NValue t f m
k) Set (WValue t f m)
ks) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Semigroup a => a -> a -> a
(<>) [NValue t f m]
ts forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m] forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
op NValue t f m
v
)
(Set (WValue t f m)
-> [NValue t f m] -> m (Set (WValue t f m), [NValue t f m])
go Set (WValue t f m)
ks [NValue t f m]
ts)
(forall a. Ord a => a -> Set a -> Bool
S.member (forall t (f :: * -> *) (m :: * -> *). NValue t f m -> WValue t f m
WValue NValue t f m
k) Set (WValue t f m)
ks)
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue @[NValue t f m] forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a b. (a, b) -> b
snd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set (WValue t f m)
-> [NValue t f m] -> m (Set (WValue t f m), [NValue t f m])
go forall a. Monoid a => a
mempty [NValue t f m]
ss
replaceStringsNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> NValue t f m
-> m (NValue t f m)
replaceStringsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> NValue t f m -> m (NValue t f m)
replaceStringsNix NValue t f m
tfrom NValue t f m
tto NValue t f m
ts =
do
([NixString]
fromKeys :: [NixString]) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue (forall a. a -> Deeper a
Deeper NValue t f m
tfrom)
([NixString]
toVals :: [NixString]) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue (forall a. a -> Deeper a
Deeper NValue t f m
tto)
(NixString
string :: NixString ) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
ts
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => t a -> Int
length [NixString]
fromKeys forall a. Eq a => a -> a -> Bool
/= forall (t :: * -> *) a. Foldable t => t a -> Int
length [NixString]
toVals) forall a b. (a -> b) -> a -> b
$ forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall String
"builtins.replaceStrings: Arguments `from`&`to` construct a key-value map, so the number of their elements must always match."
let
go :: HashSet StringContext -> Text -> Builder -> NixString
go HashSet StringContext
ctx Text
input Builder
output =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
NixString
passOneChar
(Text, NixString, Text) -> NixString
replace
Maybe (Text, NixString, Text)
maybePrefixMatch
where
maybePrefixMatch :: Maybe (Text, NixString, Text)
maybePrefixMatch :: Maybe (Text, NixString, Text)
maybePrefixMatch = (Text, NixString) -> (Text, NixString, Text)
formMatchReplaceTailInfo forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((Text -> Text -> Bool
`Text.isPrefixOf` Text
input) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) [(Text, NixString)]
fromKeysToValsMap
where
formMatchReplaceTailInfo :: (Text, NixString) -> (Text, NixString, Text)
formMatchReplaceTailInfo (Text
m, NixString
r) = (Text
m, NixString
r, Int -> Text -> Text
Text.drop (Text -> Int
Text.length Text
m) Text
input)
fromKeysToValsMap :: [(Text, NixString)]
fromKeysToValsMap = forall a b. [a] -> [b] -> [(a, b)]
zip (NixString -> Text
ignoreContext forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [NixString]
fromKeys) [NixString]
toVals
passOneChar :: NixString
passOneChar =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(HashSet StringContext -> Builder -> NixString
finish HashSet StringContext
ctx Builder
output)
(\(Char
c, Text
i) -> HashSet StringContext -> Text -> Builder -> NixString
go HashSet StringContext
ctx Text
i (Builder
output forall a. Semigroup a => a -> a -> a
<> Char -> Builder
Builder.singleton Char
c))
(Text -> Maybe (Char, Text)
Text.uncons Text
input)
finish :: HashSet StringContext -> Builder -> NixString
finish HashSet StringContext
ctx Builder
output = HashSet StringContext -> Text -> NixString
mkNixString HashSet StringContext
ctx (forall l s. LazyStrict l s => l -> s
toStrict forall a b. (a -> b) -> a -> b
$ Builder -> Text
Builder.toLazyText Builder
output)
replace :: (Text, NixString, Text) -> NixString
replace (Text
key, NixString
replacementNS, Text
unprocessedInput) = Text -> Builder -> NixString
replaceWithNixBug Text
unprocessedInput Builder
updatedOutput
where
replaceWithNixBug :: Text -> Builder -> NixString
replaceWithNixBug =
forall a. a -> a -> Bool -> a
bool
(HashSet StringContext -> Text -> Builder -> NixString
go HashSet StringContext
updatedCtx)
Text -> Builder -> NixString
bugPassOneChar
Bool
isNixBugCase
isNixBugCase :: Bool
isNixBugCase = Text
key forall a. Eq a => a -> a -> Bool
== forall a. Monoid a => a
mempty
updatedOutput :: Builder
updatedOutput = Builder
output forall a. Semigroup a => a -> a -> a
<> Builder
replacement
updatedCtx :: HashSet StringContext
updatedCtx = HashSet StringContext
ctx forall a. Semigroup a => a -> a -> a
<> HashSet StringContext
replacementCtx
replacement :: Builder
replacement = Text -> Builder
Builder.fromText forall a b. (a -> b) -> a -> b
$ NixString -> Text
ignoreContext NixString
replacementNS
replacementCtx :: HashSet StringContext
replacementCtx = NixString -> HashSet StringContext
getStringContext NixString
replacementNS
bugPassOneChar :: Text -> Builder -> NixString
bugPassOneChar Text
input Builder
output =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(HashSet StringContext -> Builder -> NixString
finish HashSet StringContext
updatedCtx Builder
output)
(\(Char
c, Text
i) -> HashSet StringContext -> Text -> Builder -> NixString
go HashSet StringContext
updatedCtx Text
i forall a b. (a -> b) -> a -> b
$ Builder
output forall a. Semigroup a => a -> a -> a
<> Char -> Builder
Builder.singleton Char
c)
(Text -> Maybe (Char, Text)
Text.uncons Text
input)
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ HashSet StringContext -> Text -> Builder -> NixString
go (NixString -> HashSet StringContext
getStringContext NixString
string) (NixString -> Text
ignoreContext NixString
string) forall a. Monoid a => a
mempty
removeAttrsNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
removeAttrsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
removeAttrsNix NValue t f m
set NValue t f m
v =
do
(AttrSet (NValue t f m)
m, PositionSet
p) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m), PositionSet) NValue t f m
set
([NixString]
nsToRemove :: [NixString]) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall a b. (a -> b) -> a -> b
$ forall a. a -> Deeper a
Deeper NValue t f m
v
(coerce :: forall a b. Coercible a b => a -> b
coerce -> [VarName]
toRemove) <- forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext [NixString]
nsToRemove
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue (forall k v. (Eq k, Hashable k) => HashMap k v -> [k] -> HashMap k v
fun AttrSet (NValue t f m)
m [VarName]
toRemove, forall k v. (Eq k, Hashable k) => HashMap k v -> [k] -> HashMap k v
fun PositionSet
p [VarName]
toRemove)
where
fun :: forall k v . (Eq k, Hashable k) => HashMap k v -> [k] -> HashMap k v
fun :: forall k v. (Eq k, Hashable k) => HashMap k v -> [k] -> HashMap k v
fun = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall k v. (Eq k, Hashable k) => k -> HashMap k v -> HashMap k v
M.delete)
intersectAttrsNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
intersectAttrsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
intersectAttrsNix NValue t f m
set1 NValue t f m
set2 =
do
(AttrSet (NValue t f m)
s1, PositionSet
p1) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m), PositionSet) NValue t f m
set1
(AttrSet (NValue t f m)
s2, PositionSet
p2) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m), PositionSet) NValue t f m
set2
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet (PositionSet
p2 forall k v w.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k w -> HashMap k v
`M.intersection` PositionSet
p1) (AttrSet (NValue t f m)
s2 forall k v w.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k w -> HashMap k v
`M.intersection` AttrSet (NValue t f m)
s1)
functionArgsNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
functionArgsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
functionArgsNix NValue t f m
nvfun =
do
NValue t f m
fun <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvfun
case NValue t f m
fun of
NVClosure Params ()
p NValue t f m -> m (NValue t f m)
_ ->
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue @(AttrSet (NValue t f m)) forall a b. (a -> b) -> a -> b
$ forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Bool -> NValue t f m
NVBool forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
case Params ()
p of
Param VarName
name -> forall x. One x => OneItem x -> x
one (VarName
name, Bool
False)
ParamSet Maybe VarName
_ Variadic
_ ParamSet ()
pset -> forall a. Maybe a -> Bool
isJust forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList ParamSet ()
pset
NValue t f m
_v -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.functionArgs: expected function, got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
_v
toFileNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
toFileNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
toFileNix NValue t f m
name NValue t f m
s =
do
Text
name' <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
name
NixString
s' <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
s
StorePath
mres <-
forall e (m :: * -> *).
(Framed e m, MonadStore m) =>
Path -> Text -> m StorePath
toFile_
(coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall a. ToString a => a -> String
toString Text
name')
(NixString -> Text
ignoreContext NixString
s')
let
storepath :: VarName
storepath = coerce :: forall a b. Coercible a b => a -> b
coerce (forall a. IsString a => String -> a
fromString @Text) StorePath
mres
sc :: StringContext
sc = ContextFlavor -> VarName -> StringContext
StringContext ContextFlavor
DirectPath VarName
storepath
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ StringContext -> VarName -> NixString
mkNixStringWithSingletonContext StringContext
sc VarName
storepath
toPathNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
toPathNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
toPathNix = forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(a1 -> a2) -> v -> m b
inHask @Path forall a. a -> a
id
pathExistsNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
pathExistsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
pathExistsNix NValue t f m
nvpath =
do
NValue t f m
path <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvpath
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
case NValue t f m
path of
NVPath Path
p -> forall (m :: * -> *). MonadFile m => Path -> m Bool
doesPathExist Path
p
NVStr NixString
ns -> forall (m :: * -> *). MonadFile m => Path -> m Bool
doesPathExist forall a b. (a -> b) -> a -> b
$ coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall a. ToString a => a -> String
toString forall a b. (a -> b) -> a -> b
$ NixString -> Text
ignoreContext NixString
ns
NValue t f m
_v -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.pathExists: expected path, got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
_v
isPathNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
isPathNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isPathNix = forall a e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, FromValue a m (NValue t f m)) =>
NValue t f m -> m (NValue t f m)
hasKind @Path
isAttrsNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
isAttrsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isAttrsNix = forall a e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, FromValue a m (NValue t f m)) =>
NValue t f m -> m (NValue t f m)
hasKind @(AttrSet (NValue t f m))
isListNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
isListNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isListNix = forall a e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, FromValue a m (NValue t f m)) =>
NValue t f m -> m (NValue t f m)
hasKind @[NValue t f m]
isIntNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
isIntNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isIntNix = forall a e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, FromValue a m (NValue t f m)) =>
NValue t f m -> m (NValue t f m)
hasKind @Int
isFloatNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
isFloatNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isFloatNix = forall a e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, FromValue a m (NValue t f m)) =>
NValue t f m -> m (NValue t f m)
hasKind @Float
isBoolNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
isBoolNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isBoolNix = forall a e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, FromValue a m (NValue t f m)) =>
NValue t f m -> m (NValue t f m)
hasKind @Bool
isNullNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
isNullNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isNullNix = forall a e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, FromValue a m (NValue t f m)) =>
NValue t f m -> m (NValue t f m)
hasKind @()
isStringNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
isStringNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isStringNix NValue t f m
nv =
do
NValue t f m
v <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nv
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$
case NValue t f m
v of
NVStr{} -> Bool
True
NValue t f m
_ -> Bool
False
isFunctionNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
isFunctionNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isFunctionNix NValue t f m
nv =
do
NValue t f m
v <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nv
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$
case NValue t f m
v of
NVClosure{} -> Bool
True
NValue t f m
_ -> Bool
False
throwNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
throwNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
throwNix =
forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ErrorCall
ErrorCall forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToString a => a -> String
toString forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixString -> Text
ignoreContext
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall e t (f :: * -> *) (m :: * -> *).
(Framed e m, MonadStore m, MonadThrow m,
MonadDataErrorContext t f m, MonadValue (NValue t f m) m) =>
CopyToStoreMode -> NValue t f m -> m NixString
coerceStringlikeToNixString CopyToStoreMode
CopyToStore
importNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
importNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
importNix = forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
scopedImportNix forall a b. (a -> b) -> a -> b
$ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty
scopedImportNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
scopedImportNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
scopedImportNix NValue t f m
asetArg NValue t f m
pathArg =
do
(coerce :: forall a b. Coercible a b => a -> b
coerce -> Scope (NValue t f m)
scope) <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m)) NValue t f m
asetArg
Path
p <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
pathArg
Path
path <- forall t (f :: * -> *) (m :: * -> *).
MonadEffects t f m =>
Path -> m Path
pathToDefaultNix @t @f @m Path
p
Path
path' <-
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(do
forall (m :: * -> *). Monad m => String -> m ()
traceM String
"No known current directory"
pure Path
path
)
(\ NValue t f m
res ->
do
Path
p' <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @Path forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
res
forall (m :: * -> *). Monad m => String -> m ()
traceM forall a b. (a -> b) -> a -> b
$ String
"Current file being evaluated is: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Path
p'
pure $ Path -> Path
takeDirectory Path
p' Path -> Path -> Path
</> Path
path
)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *). Scoped a m => VarName -> m (Maybe a)
lookupVar VarName
"__cur_file"
forall a (m :: * -> *) r. Scoped a m => m r -> m r
clearScopes @(NValue t f m)
forall a b. (a -> b) -> a -> b
$ forall e t (f :: * -> *) (m :: * -> *) r.
(MonadNix e t f m, Has e Options) =>
Maybe Path -> m r -> m r
withNixContext (forall (f :: * -> *) a. Applicative f => a -> f a
pure Path
path')
forall a b. (a -> b) -> a -> b
$ forall a (m :: * -> *) r. Scoped a m => Scope a -> m r -> m r
pushScope Scope (NValue t f m)
scope
forall a b. (a -> b) -> a -> b
$ forall t (f :: * -> *) (m :: * -> *).
MonadEffects t f m =>
Path -> m (NValue t f m)
importPath @t @f @m Path
path'
getEnvNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
getEnvNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
getEnvNix NValue t f m
v =
(forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> NixString
mkNixStringWithoutContext forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall m. Monoid m => Maybe m -> m
maybeToMonoid) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). MonadEnv m => Text -> m (Maybe Text)
getEnvVar forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
v
sortNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
sortNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
sortNix NValue t f m
comp =
forall a1 a2 v b (m :: * -> *).
(Monad m, FromValue a1 m v, ToValue a2 m b) =>
(a1 -> m a2) -> v -> m b
inHaskM (forall (m :: * -> *) a.
Monad m =>
(a -> a -> m Ordering) -> [a] -> m [a]
sortByM NValue t f m -> NValue t f m -> m Ordering
cmp)
where
cmp :: NValue t f m -> NValue t f m -> m Ordering
cmp :: NValue t f m -> NValue t f m -> m Ordering
cmp NValue t f m
a NValue t f m
b =
forall a. a -> a -> Bool -> a
bool
(forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
(forall a. a -> a -> Bool -> a
bool Ordering
EQ Ordering
GT)
(NValue t f m -> NValue t f m -> m Bool
compare NValue t f m
b NValue t f m
a)
)
(forall (f :: * -> *) a. Applicative f => a -> f a
pure Ordering
LT)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< NValue t f m -> NValue t f m -> m Bool
compare NValue t f m
a NValue t f m
b
where
compare :: NValue t f m -> NValue t f m -> m Bool
compare :: NValue t f m -> NValue t f m -> m Bool
compare NValue t f m
a2 NValue t f m
a1 = forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
`callFunc` NValue t f m
a1) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
comp NValue t f m
a2
lessThanNix
:: MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
lessThanNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
lessThanNix NValue t f m
ta NValue t f m
tb =
do
NValue t f m
va <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
ta
NValue t f m
vb <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
tb
let
badType :: m Bool
badType = forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.lessThan: expected two numbers or two strings, got '" forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
va forall a. Semigroup a => a -> a -> a
<> String
"' and '" forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
vb forall a. Semigroup a => a -> a -> a
<> String
"'."
forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Bool -> NValue t f m
NVBool forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
case (NValue t f m
va, NValue t f m
vb) of
(NVConstant NAtom
ca, NVConstant NAtom
cb) ->
case (NAtom
ca, NAtom
cb) of
(NInt Integer
a, NInt Integer
b) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Integer
a forall a. Ord a => a -> a -> Bool
< Integer
b
(NInt Integer
a, NFloat Float
b) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. Num a => Integer -> a
fromInteger Integer
a forall a. Ord a => a -> a -> Bool
< Float
b
(NFloat Float
a, NInt Integer
b) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Float
a forall a. Ord a => a -> a -> Bool
< forall a. Num a => Integer -> a
fromInteger Integer
b
(NFloat Float
a, NFloat Float
b) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Float
a forall a. Ord a => a -> a -> Bool
< Float
b
(NAtom, NAtom)
_ -> m Bool
badType
(NVStr NixString
a, NVStr NixString
b) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ NixString -> Text
ignoreContext NixString
a forall a. Ord a => a -> a -> Bool
< NixString -> Text
ignoreContext NixString
b
(NValue t f m, NValue t f m)
_ -> m Bool
badType
concatWith
:: forall e t f m
. MonadNix e t f m
=> (NValue t f m -> m (NValue t f m))
-> NValue t f m
-> m (NValue t f m)
concatWith :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
(NValue t f m -> m (NValue t f m))
-> NValue t f m -> m (NValue t f m)
concatWith NValue t f m -> m (NValue t f m)
f =
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=<
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
(forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m] forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< NValue t f m -> m (NValue t f m)
f)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m]
concatListsNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
concatListsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
concatListsNix = forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
(NValue t f m -> m (NValue t f m))
-> NValue t f m -> m (NValue t f m)
concatWith forall v (m :: * -> *). MonadValue v m => v -> m v
demand
concatMapNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
concatMapNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
concatMapNix NValue t f m
f = forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
(NValue t f m -> m (NValue t f m))
-> NValue t f m -> m (NValue t f m)
concatWith (forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
f)
listToAttrsNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
listToAttrsNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
listToAttrsNix NValue t f m
lst =
do
[NValue t f m]
l <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m] NValue t f m
lst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
(forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet forall a. Monoid a => a
mempty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
reverse)
(forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
(\ NValue t f m
nvattrset ->
do
AttrSet (NValue t f m)
a <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @(AttrSet (NValue t f m)) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvattrset
(coerce :: forall a b. Coercible a b => a -> b
coerce -> VarName
name) <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall v (m :: * -> *). MonadValue v m => v -> m v
demand forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
VarName -> AttrSet (NValue t f m) -> m (NValue t f m)
attrsetGet VarName
"name" AttrSet (NValue t f m)
a
NValue t f m
val <- forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
VarName -> AttrSet (NValue t f m) -> m (NValue t f m)
attrsetGet VarName
"value" AttrSet (NValue t f m)
a
pure (VarName
name, NValue t f m
val)
)
[NValue t f m]
l
)
hashStringNix
:: forall e t f m. MonadNix e t f m => NixString -> NixString -> Prim m NixString
hashStringNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NixString -> NixString -> Prim m NixString
hashStringNix NixString
nsAlgo NixString
ns =
forall (m :: * -> *) a. m a -> Prim m a
Prim forall a b. (a -> b) -> a -> b
$
do
Text
algo <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext NixString
nsAlgo
let
f :: (Text -> Text) -> m NixString
f Text -> Text
g = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ (Text -> Text) -> NixString -> NixString
modifyNixContents Text -> Text
g NixString
ns
case Text
algo of
Text
"md5" -> (Text -> Text) -> m NixString
f (forall b a. (Show a, IsString b) => a -> b
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Show a, HashAlgorithm a) => Text -> a
mkHash @MD5.MD5)
Text
"sha1" -> (Text -> Text) -> m NixString
f (forall b a. (Show a, IsString b) => a -> b
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Show a, HashAlgorithm a) => Text -> a
mkHash @SHA1.SHA1)
Text
"sha256" -> (Text -> Text) -> m NixString
f (forall b a. (Show a, IsString b) => a -> b
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Show a, HashAlgorithm a) => Text -> a
mkHash @SHA256.SHA256)
Text
"sha512" -> (Text -> Text) -> m NixString
f (forall b a. (Show a, IsString b) => a -> b
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Show a, HashAlgorithm a) => Text -> a
mkHash @SHA512.SHA512)
Text
_ -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.hashString: expected \"md5\", \"sha1\", \"sha256\", or \"sha512\", got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Text
algo
where
mkHash :: (Show a, HashAlgorithm a) => Text -> a
mkHash :: forall a. (Show a, HashAlgorithm a) => Text -> a
mkHash Text
s = forall a. HashAlgorithm a => ByteString -> a
hash forall a b. (a -> b) -> a -> b
$ forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 Text
s
hashFileNix
:: forall e t f m . MonadNix e t f m => NixString -> Path -> Prim m NixString
hashFileNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NixString -> Path -> Prim m NixString
hashFileNix NixString
nsAlgo Path
nvfilepath = forall (m :: * -> *) a. m a -> Prim m a
Prim forall a b. (a -> b) -> a -> b
$ NixString -> m NixString
hash forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< m NixString
fileContent
where
hash :: NixString -> m NixString
hash = forall {m :: * -> *} {a}. Prim m a -> m a
outPrim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NixString -> NixString -> Prim m NixString
hashStringNix NixString
nsAlgo
outPrim :: Prim m a -> m a
outPrim (Prim m a
x) = m a
x
fileContent :: m NixString
fileContent :: m NixString
fileContent = Text -> NixString
mkNixStringWithoutContext forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadFile m => Path -> m Text
Nix.Render.readFile Path
nvfilepath
groupByNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
groupByNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
groupByNix NValue t f m
nvfun NValue t f m
nvlist = do
NValue t f m
list <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvlist
NValue t f m
fun <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvfun
(NValue t f m -> m (NValue t f m)
f, [NValue t f m]
l) <- forall {w :: * -> *} {w :: * -> *} {f :: * -> *} {e} {a} {a} {t}
{m :: * -> *} {t} {m :: * -> *}.
(Comonad w, Comonad w, Applicative w, Applicative w,
MonadReader e f, Has e Frames, MonadThrow f, Show a, Show a) =>
(Free (NValue' t w m) a, Free (NValue' t w m) a)
-> f (NValue t w m -> m (Free (NValue' t w m) a),
[Free (NValue' t w m) a])
extractP (NValue t f m
fun, NValue t f m
list)
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet forall a. Monoid a => a
mempty
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
reverse)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> [(k, v)] -> HashMap k v
M.fromListWith forall a. Semigroup a => a -> a -> a
(<>)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall {f :: * -> *} {a} {b}.
(Monad f, FromValue Text f a, One b) =>
(OneItem b -> f a) -> OneItem b -> f (VarName, b)
app NValue t f m -> m (NValue t f m)
f) [NValue t f m]
l
where
app :: (OneItem b -> f a) -> OneItem b -> f (VarName, b)
app OneItem b -> f a
f OneItem b
x = do
Text
name <- forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @Text forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< OneItem b -> f a
f OneItem b
x
pure (Text -> VarName
VarName Text
name, forall x. One x => OneItem x -> x
one OneItem b
x)
extractP :: (Free (NValue' t w m) a, Free (NValue' t w m) a)
-> f (NValue t w m -> m (Free (NValue' t w m) a),
[Free (NValue' t w m) a])
extractP (NVBuiltin VarName
_ NValue t w m -> m (Free (NValue' t w m) a)
f, NVList [Free (NValue' t w m) a]
l) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (NValue t w m -> m (Free (NValue' t w m) a)
f, [Free (NValue' t w m) a]
l)
extractP (NVClosure Params ()
_ NValue t w m -> m (Free (NValue' t w m) a)
f, NVList [Free (NValue' t w m) a]
l) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (NValue t w m -> m (Free (NValue' t w m) a)
f, [Free (NValue' t w m) a]
l)
extractP (Free (NValue' t w m) a, Free (NValue' t w m) a)
_v =
forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError
forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall
forall a b. (a -> b) -> a -> b
$ String
"builtins.groupBy: expected function and list, got "
forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show (Free (NValue' t w m) a, Free (NValue' t w m) a)
_v
placeHolderNix :: forall t f m e . MonadNix e t f m => NValue t f m -> m (NValue t f m)
placeHolderNix :: forall t (f :: * -> *) (m :: * -> *) e.
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
placeHolderNix NValue t f m
p =
do
Text
t <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
p
NixString
h <-
coerce :: forall a b. Coercible a b => a -> b
coerce @(Prim m NixString) @(m NixString) forall a b. (a -> b) -> a -> b
$
(forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NixString -> NixString -> Prim m NixString
hashStringNix forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Text -> NixString
mkNixStringWithoutContext)
Text
"sha256"
(Text
"nix-output:" forall a. Semigroup a => a -> a -> a
<> Text
t)
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue
forall a b. (a -> b) -> a -> b
$ Text -> NixString
mkNixStringWithoutContext
forall a b. (a -> b) -> a -> b
$ Char -> Text -> Text
Text.cons Char
'/'
forall a b. (a -> b) -> a -> b
$ ByteString -> Text
Base32.encode
forall a b. (a -> b) -> a -> b
$ case ByteString -> Either String ByteString
Base16.decode (NixString -> ByteString
bytes NixString
h) of
#if MIN_VERSION_base16_bytestring(1,0,0)
Left String
e -> forall a t. (HasCallStack, IsText t) => t -> a
error forall a b. (a -> b) -> a -> b
$ Text
"Couldn't Base16 decode the text: '" forall a. Semigroup a => a -> a -> a
<> NixString -> Text
body NixString
h forall a. Semigroup a => a -> a -> a
<> Text
"'.\nThe Left fail content: '" forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show String
e forall a. Semigroup a => a -> a -> a
<> Text
"'."
Right ByteString
d -> ByteString
d
#else
(d, "") -> d
(_, e) -> error $ "Couldn't Base16 decode the text: '" <> body h <> "'.\nUndecodable remainder: '" <> show e <> "'."
#endif
where
bytes :: NixString -> ByteString
bytes :: NixString -> ByteString
bytes = forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixString -> Text
body
body :: NixString -> Text
body = NixString -> Text
ignoreContext
readFileNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
readFileNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
readFileNix = forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall (m :: * -> *). MonadFile m => Path -> m Text
Nix.Render.readFile forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m Path
absolutePathFromValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall v (m :: * -> *). MonadValue v m => v -> m v
demand
findFileNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
findFileNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
findFileNix NValue t f m
nvaset NValue t f m
nvfilepath =
do
NValue t f m
aset <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvaset
NValue t f m
filePath <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvfilepath
case (NValue t f m
aset, NValue t f m
filePath) of
(NVList [NValue t f m]
x, NVStr NixString
ns) ->
do
Path
mres <- forall t (f :: * -> *) (m :: * -> *).
MonadEffects t f m =>
[NValue t f m] -> Path -> m Path
findPath @t @f @m [NValue t f m]
x forall a b. (a -> b) -> a -> b
$ coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$ forall a. ToString a => a -> String
toString forall a b. (a -> b) -> a -> b
$ NixString -> Text
ignoreContext NixString
ns
pure $ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Path -> Free (NValue' t w m) a
NVPath Path
mres
(NVList [NValue t f m]
_, NValue t f m
_y ) -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"expected a string, got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
_y
(NValue t f m
_x , NVStr NixString
_) -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"expected a list, got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
_x
(NValue t f m
_x , NValue t f m
_y ) -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"Invalid types for builtins.findFile: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show (NValue t f m
_x, NValue t f m
_y)
readDirNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
readDirNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
readDirNix NValue t f m
nvpath =
do
Path
path <- forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m Path
absolutePathFromValue forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvpath
[Path]
items <- forall (m :: * -> *). MonadFile m => Path -> m [Path]
listDirectory Path
path
let
detectFileTypes :: Path -> m (VarName, FileType)
detectFileTypes :: Path -> m (VarName, FileType)
detectFileTypes Path
item =
do
FileStatus
s <- forall (m :: * -> *). MonadFile m => Path -> m FileStatus
getSymbolicLinkStatus forall a b. (a -> b) -> a -> b
$ Path
path Path -> Path -> Path
</> Path
item
let
t :: FileType
t =
if
| FileStatus -> Bool
isRegularFile FileStatus
s -> FileType
FileTypeRegular
| FileStatus -> Bool
isDirectory FileStatus
s -> FileType
FileTypeDirectory
| FileStatus -> Bool
isSymbolicLink FileStatus
s -> FileType
FileTypeSymlink
| Bool
otherwise -> FileType
FileTypeUnknown
forall (f :: * -> *) a. Applicative f => a -> f a
pure (coerce :: forall a b. Coercible a b => a -> b
coerce @(String -> Text) forall a. IsString a => String -> a
fromString Path
item, FileType
t)
[(VarName, FileType)]
itemsWithTypes <-
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
Path -> m (VarName, FileType)
detectFileTypes
[Path]
items
(coerce :: forall a b. Coercible a b => a -> b
coerce :: CoerceDeeperToNValue t f m) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue (forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(VarName, FileType)]
itemsWithTypes)
fromJSONNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
fromJSONNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
fromJSONNix NValue t f m
nvjson =
do
NValue t f m
j <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvjson
Text
jText <- forall e (m :: * -> *). Framed e m => NixString -> m Text
fromStringNoContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
j
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
(\ String
jsonError -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.fromJSON: " forall a. Semigroup a => a -> a -> a
<> String
jsonError)
Value -> m (NValue t f m)
jsonToNValue
(forall a. FromJSON a => ByteString -> Either String a
A.eitherDecodeStrict' @A.Value forall a b. (a -> b) -> a -> b
$ forall a b. ConvertUtf8 a b => a -> b
encodeUtf8 Text
jText)
where
jsonToNValue :: (A.Value -> m (NValue t f m))
jsonToNValue :: Value -> m (NValue t f m)
jsonToNValue =
\case
A.Object Object
m ->
forall (t0 :: * -> *) b.
Traversable t0 =>
(t0 (NValue t f m) -> b) -> t0 Value -> m b
traverseToNValue
(forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet forall a. Monoid a => a
mempty)
#if MIN_VERSION_aeson(2,0,0)
(forall k2 k1 v.
(Eq k2, Hashable k2) =>
(k1 -> k2) -> HashMap k1 v -> HashMap k2 v
M.mapKeys (coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. Key -> Text
AKM.toText) forall a b. (a -> b) -> a -> b
$ forall v. KeyMap v -> HashMap Key v
AKM.toHashMap Object
m)
#else
(M.mapKeys coerce m)
#endif
A.Array Array
l -> forall (t0 :: * -> *) b.
Traversable t0 =>
(t0 (NValue t f m) -> b) -> t0 Value -> m b
traverseToNValue forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList (forall a. Vector a -> [a]
V.toList Array
l)
A.String Text
s -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext Text
s
A.Number Scientific
n ->
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
NAtom -> Free (NValue' t w m) a
NVConstant forall a b. (a -> b) -> a -> b
$
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
Float -> NAtom
NFloat
Integer -> NAtom
NInt
(forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
n)
A.Bool Bool
b -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Bool -> NValue t f m
NVBool Bool
b
Value
A.Null -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Free (NValue' t w m) a
NVNull
where
traverseToNValue :: Traversable t0 => (t0 (NValue t f m) -> b) -> t0 A.Value -> m b
traverseToNValue :: forall (t0 :: * -> *) b.
Traversable t0 =>
(t0 (NValue t f m) -> b) -> t0 Value -> m b
traverseToNValue t0 (NValue t f m) -> b
f t0 Value
v = t0 (NValue t f m) -> b
f forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Value -> m (NValue t f m)
jsonToNValue t0 Value
v
toJSONNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
toJSONNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
toJSONNix = (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
NixString -> Free (NValue' t w m) a
NVStr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m NixString
toJSONNixString) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall v (m :: * -> *). MonadValue v m => v -> m v
demand
toXMLNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
toXMLNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
toXMLNix = (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
NixString -> Free (NValue' t w m) a
NVStr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (f :: * -> *) (m :: * -> *).
MonadDataContext f m =>
NValue t f m -> NixString
toXML) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall v (m :: * -> *). MonadValue v m => v -> m v
demand
typeOfNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
typeOfNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
typeOfNix NValue t f m
nvv =
do
NValue t f m
v <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
nvv
let
detectType :: Text
detectType =
case NValue t f m
v of
NVConstant NAtom
a ->
case NAtom
a of
NURI Text
_ -> Text
"string"
NInt Integer
_ -> Text
"int"
NFloat Float
_ -> Text
"float"
NBool Bool
_ -> Text
"bool"
NAtom
NNull -> Text
"null"
NVStr NixString
_ -> Text
"string"
NVList [NValue t f m]
_ -> Text
"list"
NVSet PositionSet
_ AttrSet (NValue t f m)
_ -> Text
"set"
NVClosure{} -> Text
"lambda"
NVPath Path
_ -> Text
"path"
NVBuiltin VarName
_ NValue t f m -> m (NValue t f m)
_ -> Text
"lambda"
NValue t f m
_ -> forall a t. (HasCallStack, IsText t) => t -> a
error Text
"Pattern synonyms obscure complete patterns"
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Text -> NixString
mkNixStringWithoutContext Text
detectType
tryEvalNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
tryEvalNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
tryEvalNix NValue t f m
e = (forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. SomeException -> NValue t f m
onError))
(forall {w :: * -> *} {a} {m :: * -> *} {e}.
(Comonad w, Scoped (NValue a w m) m, MonadReader e m, Has e Frames,
Has e SrcSpan, Has e Options, MonadFix m, MonadCatch m,
Alternative m, MonadEffects a w m, MonadThunk a m (NValue a w m),
Traversable w, HasCitations m (NValue a w m) a,
HasCitations1 m (NValue a w m) w, MonadValue (NValue a w m) m,
Applicative w, Show a, Typeable m, Typeable w, Typeable a) =>
NValue a w m -> NValue a w m
onSuccess forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
e)
where
onSuccess :: NValue a w m -> NValue a w m
onSuccess NValue a w m
v =
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet
forall a. Monoid a => a
mempty
forall a b. (a -> b) -> a -> b
$ forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList
[ (VarName
"success", forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Bool -> NValue t f m
NVBool Bool
True)
, (VarName
"value" , NValue a w m
v )
]
onError :: SomeException -> NValue t f m
onError :: SomeException -> NValue t f m
onError SomeException
_ =
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet
forall a. Monoid a => a
mempty
forall a b. (a -> b) -> a -> b
$ forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList
forall a b. (a -> b) -> a -> b
$ (, forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Bool -> NValue t f m
NVBool Bool
False) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
[ VarName
"success"
, VarName
"value"
]
traceNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
traceNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
traceNix NValue t f m
msg NValue t f m
action =
do
forall t (f :: * -> *) (m :: * -> *).
MonadEffects t f m =>
String -> m ()
traceEffect @t @f @m forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToString a => a -> String
toString forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixString -> Text
ignoreContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue NValue t f m
msg
pure NValue t f m
action
addErrorContextNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
addErrorContextNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
addErrorContextNix NValue t f m
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure
execNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
execNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
execNix NValue t f m
xs =
(forall e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, MonadInstantiate m) =>
[Text] -> m (NValue t f m)
exec forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NixString -> Text
ignoreContext) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall e t (f :: * -> *) (m :: * -> *).
(Framed e m, MonadStore m, MonadThrow m,
MonadDataErrorContext t f m, MonadValue (NValue t f m) m) =>
CopyToStoreMode -> NValue t f m -> m NixString
coerceStringlikeToNixString CopyToStoreMode
DontCopyToStore) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m] NValue t f m
xs
fetchurlNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
fetchurlNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
fetchurlNix =
(\case
NVSet PositionSet
_ AttrSet (NValue t f m)
s -> Maybe (NValue t f m) -> NValue t f m -> m (NValue t f m)
fetch (forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup VarName
"sha256" AttrSet (NValue t f m)
s) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall v (m :: * -> *). MonadValue v m => v -> m v
demand forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
VarName -> AttrSet (NValue t f m) -> m (NValue t f m)
attrsetGet VarName
"url" AttrSet (NValue t f m)
s
v :: NValue t f m
v@NVStr{} -> Maybe (NValue t f m) -> NValue t f m -> m (NValue t f m)
fetch forall a. Maybe a
Nothing NValue t f m
v
NValue t f m
v -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.fetchurl: Expected URI or set, got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
v
) forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall v (m :: * -> *). MonadValue v m => v -> m v
demand
where
fetch :: Maybe (NValue t f m) -> NValue t f m -> m (NValue t f m)
fetch :: Maybe (NValue t f m) -> NValue t f m -> m (NValue t f m)
fetch Maybe (NValue t f m)
_msha =
\case
NVStr NixString
ns ->
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either
forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *).
MonadHttp m =>
Text -> m (Either ErrorCall StorePath)
getURL
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall String
"builtins.fetchurl: unsupported arguments to url")
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(NixString -> Maybe Text
getStringNoContext NixString
ns)
NValue t f m
v -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"builtins.fetchurl: Expected URI or string, got " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
v
partitionNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
partitionNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
partitionNix NValue t f m
f NValue t f m
nvlst =
do
let
match :: NValue t f m -> m (Bool, NValue t f m)
match NValue t f m
t = (, NValue t f m
t) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
callFunc NValue t f m
f NValue t f m
t)
[(Bool, NValue t f m)]
selection <- forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse NValue t f m -> m (Bool, NValue t f m)
match forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue @[NValue t f m] NValue t f m
nvlst
let
([(Bool, NValue t f m)]
right, [(Bool, NValue t f m)]
wrong) = forall a. (a -> Bool) -> [a] -> ([a], [a])
partition forall a b. (a, b) -> a
fst [(Bool, NValue t f m)]
selection
makeSide :: [(a, Free (NValue' t f m) a)] -> Free (NValue' t f m) a
makeSide = forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue @(AttrSet (NValue t f m))
forall a b. (a -> b) -> a -> b
$ forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList
[ (VarName
"right", forall {a} {t} {m :: * -> *} {a}.
[(a, Free (NValue' t f m) a)] -> Free (NValue' t f m) a
makeSide [(Bool, NValue t f m)]
right)
, (VarName
"wrong", forall {a} {t} {m :: * -> *} {a}.
[(a, Free (NValue' t f m) a)] -> Free (NValue' t f m) a
makeSide [(Bool, NValue t f m)]
wrong)
]
currentSystemNix :: MonadNix e t f m => m (NValue t f m)
currentSystemNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
currentSystemNix =
do
Text
os <- forall (m :: * -> *). MonadEnv m => m Text
getCurrentSystemOS
Text
arch <- forall (m :: * -> *). MonadEnv m => m Text
getCurrentSystemArch
pure $ forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext forall a b. (a -> b) -> a -> b
$ Text
arch forall a. Semigroup a => a -> a -> a
<> Text
"-" forall a. Semigroup a => a -> a -> a
<> Text
os
currentTimeNix :: MonadNix e t f m => m (NValue t f m)
currentTimeNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
currentTimeNix =
do
Options
opts <- forall e (m :: * -> *).
(MonadReader e m, Has e Options) =>
m Options
askOptions
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue @Integer forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round forall a b. (a -> b) -> a -> b
$ UTCTime -> POSIXTime
Time.utcTimeToPOSIXSeconds forall a b. (a -> b) -> a -> b
$ Options -> UTCTime
getTime Options
opts
derivationStrictNix :: MonadNix e t f m => NValue t f m -> m (NValue t f m)
derivationStrictNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
derivationStrictNix = forall t (f :: * -> *) (m :: * -> *).
MonadEffects t f m =>
NValue t f m -> m (NValue t f m)
derivationStrict
getRecursiveSizeNix :: (MonadIntrospect m, NVConstraint f) => a -> m (NValue t f m)
getRecursiveSizeNix :: forall (m :: * -> *) (f :: * -> *) a t.
(MonadIntrospect m, NVConstraint f) =>
a -> m (NValue t f m)
getRecursiveSizeNix = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
NAtom -> Free (NValue' t w m) a
NVConstant forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> NAtom
NInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadIntrospect m => a -> m Word
recursiveSize
getContextNix
:: forall e t f m . MonadNix e t f m => NValue t f m -> m (NValue t f m)
getContextNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
getContextNix =
\case
(NVStr NixString
ns) ->
forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet forall a. Monoid a => a
mempty forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f, ToValue a f b) =>
t a -> f (t b)
traverseToValue (NixLikeContext -> AttrSet NixLikeContextValue
getNixLikeContext forall a b. (a -> b) -> a -> b
$ HashSet StringContext -> NixLikeContext
toNixLikeContext forall a b. (a -> b) -> a -> b
$ NixString -> HashSet StringContext
getStringContext NixString
ns)
Free (NValue' t f m) t
x -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"Invalid type for builtins.getContext: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Free (NValue' t f m) t
x
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall v (m :: * -> *). MonadValue v m => v -> m v
demand
appendContextNix
:: forall e t f m
. MonadNix e t f m
=> NValue t f m
-> NValue t f m
-> m (NValue t f m)
appendContextNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
appendContextNix NValue t f m
tx NValue t f m
ty =
do
NValue t f m
x <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
tx
NValue t f m
y <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
ty
case (NValue t f m
x, NValue t f m
y) of
(NVStr NixString
ns, NVSet PositionSet
_ AttrSet (NValue t f m)
attrs) ->
do
let
getPathNOuts :: NValue t f m -> m NixLikeContextValue
getPathNOuts :: NValue t f m -> m NixLikeContextValue
getPathNOuts NValue t f m
tx =
do
NValue t f m
x <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
tx
case NValue t f m
x of
NVSet PositionSet
_ AttrSet (NValue t f m)
atts ->
do
let
getK :: VarName -> m Bool
getK :: VarName -> m Bool
getK VarName
k =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False)
(forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall v (m :: * -> *). MonadValue v m => v -> m v
demand)
forall a b. (a -> b) -> a -> b
$ forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup VarName
k AttrSet (NValue t f m)
atts
getOutputs :: m [Text]
getOutputs :: m [Text]
getOutputs =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
forall (f :: * -> *) a. (Applicative f, Monoid a) => f a
stub
(\ NValue t f m
touts ->
do
NValue t f m
outs <- forall v (m :: * -> *). MonadValue v m => v -> m v
demand NValue t f m
touts
case NValue t f m
outs of
NVList [NValue t f m]
vs -> forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NixString -> Text
ignoreContext forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a (m :: * -> *) v. FromValue a m v => v -> m a
fromValue) [NValue t f m]
vs
NValue t f m
_x -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"Invalid types for context value outputs in builtins.appendContext: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
_x
)
(forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup VarName
"outputs" AttrSet (NValue t f m)
atts)
Bool
path <- VarName -> m Bool
getK VarName
"path"
Bool
allOutputs <- VarName -> m Bool
getK VarName
"allOutputs"
Bool -> Bool -> [Text] -> NixLikeContextValue
NixLikeContextValue Bool
path Bool
allOutputs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m [Text]
getOutputs
NValue t f m
_x -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"Invalid types for context value in builtins.appendContext: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show NValue t f m
_x
addContext :: HashMap VarName NixLikeContextValue -> NixString
addContext :: AttrSet NixLikeContextValue -> NixString
addContext AttrSet NixLikeContextValue
newContextValues =
HashSet StringContext -> Text -> NixString
mkNixString
(NixLikeContext -> HashSet StringContext
fromNixLikeContext forall a b. (a -> b) -> a -> b
$
AttrSet NixLikeContextValue -> NixLikeContext
NixLikeContext forall a b. (a -> b) -> a -> b
$
forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> HashMap k v -> HashMap k v -> HashMap k v
M.unionWith
forall a. Semigroup a => a -> a -> a
(<>)
AttrSet NixLikeContextValue
newContextValues
forall a b. (a -> b) -> a -> b
$ NixLikeContext -> AttrSet NixLikeContextValue
getNixLikeContext forall a b. (a -> b) -> a -> b
$
HashSet StringContext -> NixLikeContext
toNixLikeContext forall a b. (a -> b) -> a -> b
$
NixString -> HashSet StringContext
getStringContext NixString
ns
)
forall a b. (a -> b) -> a -> b
$ NixString -> Text
ignoreContext NixString
ns
forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. AttrSet NixLikeContextValue -> NixString
addContext forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse NValue t f m -> m NixLikeContextValue
getPathNOuts AttrSet (NValue t f m)
attrs
(NValue t f m, NValue t f m)
_xy -> forall s e (m :: * -> *) a.
(Framed e m, Exception s, MonadThrow m) =>
s -> m a
throwError forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"Invalid types for builtins.appendContext: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show (NValue t f m, NValue t f m)
_xy
nixVersionNix :: MonadNix e t f m => m (NValue t f m)
nixVersionNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
nixVersionNix = forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue forall a b. (a -> b) -> a -> b
$ Text -> NixString
mkNixStringWithoutContext Text
"2.3"
langVersionNix :: MonadNix e t f m => m (NValue t f m)
langVersionNix :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
langVersionNix = forall a (m :: * -> *) v. ToValue a m v => a -> m v
toValue (Int
5 :: Int)
builtinsList :: forall e t f m . MonadNix e t f m => m [Builtin (NValue t f m)]
builtinsList :: forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m [Builtin (NValue t f m)]
builtinsList =
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA
[ BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
TopLevel VarName
"abort" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
throwNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
TopLevel VarName
"baseNameOf" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
baseNameOfNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
TopLevel VarName
"derivation" forall e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, Scoped (NValue t f m) m) =>
m (NValue t f m)
derivationNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
TopLevel VarName
"derivationStrict" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
derivationStrictNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
TopLevel VarName
"dirOf" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
dirOfNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
TopLevel VarName
"import" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
importNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
TopLevel VarName
"isNull" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isNullNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
TopLevel VarName
"map" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
mapNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
TopLevel VarName
"mapAttrs" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
mapAttrsNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
TopLevel VarName
"placeholder" forall t (f :: * -> *) (m :: * -> *) e.
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
placeHolderNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
TopLevel VarName
"removeAttrs" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
removeAttrsNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
TopLevel VarName
"scopedImport" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
scopedImportNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
TopLevel VarName
"throw" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
throwNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
TopLevel VarName
"toString" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
toStringNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
TopLevel VarName
"trace" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
traceNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"nixVersion" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
nixVersionNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"langVersion" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
langVersionNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"add" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
addNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"addErrorContext" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
addErrorContextNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"all" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
allNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"any" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
anyNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"appendContext" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
appendContextNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"attrNames" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
attrNamesNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"attrValues" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
attrValuesNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"bitAnd" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
bitAndNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"bitOr" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
bitOrNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"bitXor" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
bitXorNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"builtins" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
builtinsBuiltinNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"catAttrs" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
catAttrsNix
, forall a.
ToBuiltin t f m a =>
BuiltinType -> VarName -> a -> m (Builtin (NValue t f m))
add' BuiltinType
Normal VarName
"ceil" (forall a b. (a -> b) -> a -> Prim m b
arity1 (forall a b. (RealFrac a, Integral b) => a -> b
ceiling @Float @Integer))
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"compareVersions" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
compareVersionsNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"concatLists" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
concatListsNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"concatMap" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
concatMapNix
, forall a.
ToBuiltin t f m a =>
BuiltinType -> VarName -> a -> m (Builtin (NValue t f m))
add' BuiltinType
Normal VarName
"concatStringsSep" (forall a b c. (a -> b -> c) -> a -> b -> Prim m c
arity2 NixString -> [NixString] -> NixString
intercalateNixString)
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"currentSystem" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
currentSystemNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"currentTime" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
currentTimeNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"deepSeq" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
deepSeqNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"div" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
divNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"elem" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
elemNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"elemAt" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
elemAtNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"exec" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
execNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"false" (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Bool -> NValue t f m
NVBool Bool
False)
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"fetchTarball" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
fetchTarball
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"fetchurl" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
fetchurlNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"filter" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
filterNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"findFile" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
findFileNix
, forall a.
ToBuiltin t f m a =>
BuiltinType -> VarName -> a -> m (Builtin (NValue t f m))
add' BuiltinType
Normal VarName
"floor" (forall a b. (a -> b) -> a -> Prim m b
arity1 (forall a b. (RealFrac a, Integral b) => a -> b
floor @Float @Integer))
, BuiltinType
-> VarName
-> (NValue t f m
-> NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add3 BuiltinType
Normal VarName
"foldl'" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> NValue t f m -> m (NValue t f m)
foldl'Nix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"fromJSON" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
fromJSONNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"functionArgs" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
functionArgsNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"genericClosure" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
genericClosureNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"genList" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
genListNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"getAttr" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
getAttrNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"getContext" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
getContextNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"getEnv" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
getEnvNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"groupBy" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
groupByNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"hasAttr" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
hasAttrNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"hasContext" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
hasContextNix
, forall a.
ToBuiltin t f m a =>
BuiltinType -> VarName -> a -> m (Builtin (NValue t f m))
add' BuiltinType
Normal VarName
"hashString" (forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NixString -> NixString -> Prim m NixString
hashStringNix @e @t @f @m)
, forall a.
ToBuiltin t f m a =>
BuiltinType -> VarName -> a -> m (Builtin (NValue t f m))
add' BuiltinType
Normal VarName
"hashFile" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NixString -> Path -> Prim m NixString
hashFileNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"head" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
headNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"intersectAttrs" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
intersectAttrsNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"isAttrs" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isAttrsNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"isBool" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isBoolNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"isFloat" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isFloatNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"isFunction" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isFunctionNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"isInt" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isIntNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"isList" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isListNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"isString" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isStringNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"isPath" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
isPathNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"length" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
lengthNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"lessThan" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
lessThanNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"listToAttrs" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
listToAttrsNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"match" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
matchNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"mul" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
mulNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"nixPath" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m (NValue t f m)
nixPathNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"null" (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Free (NValue' t w m) a
NVNull)
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"parseDrvName" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
parseDrvNameNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"partition" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
partitionNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"path" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
pathNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"pathExists" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
pathExistsNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"readDir" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
readDirNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"readFile" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
readFileNix
, BuiltinType
-> VarName
-> (NValue t f m
-> NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add3 BuiltinType
Normal VarName
"replaceStrings" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> NValue t f m -> m (NValue t f m)
replaceStringsNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"seq" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
seqNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"sort" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
sortNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"split" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
splitNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"splitVersion" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
splitVersionNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"storeDir" (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext Text
"/nix/store")
, forall a.
ToBuiltin t f m a =>
BuiltinType -> VarName -> a -> m (Builtin (NValue t f m))
add' BuiltinType
Normal VarName
"stringLength" (forall a b. (a -> b) -> a -> Prim m b
arity1 forall a b. (a -> b) -> a -> b
$ Text -> Int
Text.length forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixString -> Text
ignoreContext)
, forall a.
ToBuiltin t f m a =>
BuiltinType -> VarName -> a -> m (Builtin (NValue t f m))
add' BuiltinType
Normal VarName
"sub" (forall a b c. (a -> b -> c) -> a -> b -> Prim m c
arity2 ((-) @Integer))
, forall a.
ToBuiltin t f m a =>
BuiltinType -> VarName -> a -> m (Builtin (NValue t f m))
add' BuiltinType
Normal VarName
"substring" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Int -> Int -> NixString -> Prim m NixString
substringNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"tail" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
tailNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"toFile" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
toFileNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"toJSON" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
toJSONNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"toPath" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
toPathNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"toXML" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
toXMLNix
, BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 BuiltinType
Normal VarName
"true" (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
Bool -> NValue t f m
NVBool Bool
True)
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"tryEval" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
tryEvalNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"typeOf" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
typeOfNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"unsafeDiscardOutputDependency" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
unsafeDiscardOutputDependencyNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"unsafeDiscardStringContext" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> m (NValue t f m)
unsafeDiscardStringContextNix
, BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 BuiltinType
Normal VarName
"unsafeGetAttrPos" forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
NValue t f m -> NValue t f m -> m (NValue t f m)
unsafeGetAttrPosNix
, BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add BuiltinType
Normal VarName
"valueSize" forall (m :: * -> *) (f :: * -> *) a t.
(MonadIntrospect m, NVConstraint f) =>
a -> m (NValue t f m)
getRecursiveSizeNix
]
where
arity0 :: a -> Prim m a
arity0 :: forall a. a -> Prim m a
arity0 = forall (m :: * -> *) a. m a -> Prim m a
Prim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure
arity1 :: (a -> b) -> (a -> Prim m b)
arity1 :: forall a b. (a -> b) -> a -> Prim m b
arity1 a -> b
g = forall a. a -> Prim m a
arity0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
g
arity2 :: (a -> b -> c) -> (a -> b -> Prim m c)
arity2 :: forall a b c. (a -> b -> c) -> a -> b -> Prim m c
arity2 a -> b -> c
f = forall a b. (a -> b) -> a -> Prim m b
arity1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b -> c
f
mkBuiltin :: BuiltinType -> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
mkBuiltin :: BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
mkBuiltin BuiltinType
t VarName
n m (NValue t f m)
v = forall v. BuiltinType -> VarName -> v -> Builtin v
wrap BuiltinType
t VarName
n forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VarName -> m (NValue t f m) -> m (NValue t f m)
mkThunk VarName
n m (NValue t f m)
v
where
wrap :: BuiltinType -> VarName -> v -> Builtin v
wrap :: forall v. BuiltinType -> VarName -> v -> Builtin v
wrap BuiltinType
t VarName
n v
f = forall v. BuiltinType -> (VarName, v) -> Builtin v
Builtin BuiltinType
t (VarName
n, v
f)
mkThunk :: VarName -> m (NValue t f m) -> m (NValue t f m)
mkThunk :: VarName -> m (NValue t f m) -> m (NValue t f m)
mkThunk VarName
n = forall v (m :: * -> *). MonadValue v m => m v -> m v
defer forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s e (m :: * -> *) a.
(Framed e m, Exception s) =>
NixLevel -> s -> m a -> m a
withFrame NixLevel
Info (String -> ErrorCall
ErrorCall forall a b. (a -> b) -> a -> b
$ String
"While calling builtin " forall a. Semigroup a => a -> a -> a
<> forall a. ToString a => a -> String
toString VarName
n forall a. Semigroup a => a -> a -> a
<> String
"\n")
hAdd
:: ( VarName
-> fun
-> m (NValue t f m)
)
-> BuiltinType
-> VarName
-> fun
-> m (Builtin (NValue t f m))
hAdd :: forall fun.
(VarName -> fun -> m (NValue t f m))
-> BuiltinType -> VarName -> fun -> m (Builtin (NValue t f m))
hAdd VarName -> fun -> m (NValue t f m)
f BuiltinType
t VarName
n fun
v = BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
mkBuiltin BuiltinType
t VarName
n forall a b. (a -> b) -> a -> b
$ VarName -> fun -> m (NValue t f m)
f VarName
n fun
v
add0
:: BuiltinType
-> VarName
-> m (NValue t f m)
-> m (Builtin (NValue t f m))
add0 :: BuiltinType
-> VarName -> m (NValue t f m) -> m (Builtin (NValue t f m))
add0 = forall fun.
(VarName -> fun -> m (NValue t f m))
-> BuiltinType -> VarName -> fun -> m (Builtin (NValue t f m))
hAdd (\ VarName
_ m (NValue t f m)
x -> m (NValue t f m)
x)
add
:: BuiltinType
-> VarName
-> ( NValue t f m
-> m (NValue t f m)
)
-> m (Builtin (NValue t f m))
add :: BuiltinType
-> VarName
-> (NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add = forall fun.
(VarName -> fun -> m (NValue t f m))
-> BuiltinType -> VarName -> fun -> m (Builtin (NValue t f m))
hAdd forall (m :: * -> *) (f :: * -> *) t.
(MonadThunk t m (NValue t f m), MonadDataContext f m) =>
VarName -> (NValue t f m -> m (NValue t f m)) -> m (NValue t f m)
builtin
add2
:: BuiltinType
-> VarName
-> ( NValue t f m
-> NValue t f m
-> m (NValue t f m)
)
-> m (Builtin (NValue t f m))
add2 :: BuiltinType
-> VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add2 = forall fun.
(VarName -> fun -> m (NValue t f m))
-> BuiltinType -> VarName -> fun -> m (Builtin (NValue t f m))
hAdd forall t (m :: * -> *) (f :: * -> *).
(MonadThunk t m (NValue t f m), MonadDataContext f m) =>
VarName
-> (NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (NValue t f m)
builtin2
add3
:: BuiltinType
-> VarName
-> ( NValue t f m
-> NValue t f m
-> NValue t f m
-> m (NValue t f m)
)
-> m (Builtin (NValue t f m))
add3 :: BuiltinType
-> VarName
-> (NValue t f m
-> NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (Builtin (NValue t f m))
add3 = forall fun.
(VarName -> fun -> m (NValue t f m))
-> BuiltinType -> VarName -> fun -> m (Builtin (NValue t f m))
hAdd forall t (m :: * -> *) (f :: * -> *).
(MonadThunk t m (NValue t f m), MonadDataContext f m) =>
VarName
-> (NValue t f m
-> NValue t f m -> NValue t f m -> m (NValue t f m))
-> m (NValue t f m)
builtin3
add'
:: ToBuiltin t f m a
=> BuiltinType
-> VarName
-> a
-> m (Builtin (NValue t f m))
add' :: forall a.
ToBuiltin t f m a =>
BuiltinType -> VarName -> a -> m (Builtin (NValue t f m))
add' = forall fun.
(VarName -> fun -> m (NValue t f m))
-> BuiltinType -> VarName -> fun -> m (Builtin (NValue t f m))
hAdd (forall t (f :: * -> *) (m :: * -> *) a.
ToBuiltin t f m a =>
Text -> a -> m (NValue t f m)
toBuiltin forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce)
withNixContext
:: forall e t f m r
. (MonadNix e t f m, Has e Options)
=> Maybe Path
-> m r
-> m r
withNixContext :: 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 r
action =
do
Scopes m (NValue t f m)
base <- forall e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, Scoped (NValue t f m) m) =>
m (Scopes m (NValue t f m))
builtins
Options
opts <- forall e (m :: * -> *).
(MonadReader e m, Has e Options) =>
m Options
askOptions
forall a (m :: * -> *) r. Scoped a m => Scope a -> m r -> m r
pushScope
(forall x. One x => OneItem x -> x
one (VarName
"__includes", forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
[Free (NValue' t w m) a] -> Free (NValue' t w m) a
NVList forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) t (m :: * -> *).
NVConstraint f =>
Text -> NValue t f m
mkNVStrWithoutContext forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IsString a => String -> a
fromString forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Options -> [Path]
getInclude Options
opts))
(forall a (m :: * -> *) r. Scoped a m => Scopes m a -> m r -> m r
pushScopes
Scopes m (NValue t f m)
base forall a b. (a -> b) -> a -> b
$
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
forall a. a -> a
id
(\ Path
path m r
act ->
do
forall (m :: * -> *). Monad m => String -> m ()
traceM forall a b. (a -> b) -> a -> b
$ String
"Setting __cur_file = " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Path
path
forall a (m :: * -> *) r. Scoped a m => Scope a -> m r -> m r
pushScope (forall x. One x => OneItem x -> x
one (VarName
"__cur_file", forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
Path -> Free (NValue' t w m) a
NVPath Path
path)) m r
act
)
Maybe Path
mpath
m r
action
)
builtins
:: forall e t f m
. ( MonadNix e t f m
, Scoped (NValue t f m) m
)
=> m (Scopes m (NValue t f m))
builtins :: forall e t (f :: * -> *) (m :: * -> *).
(MonadNix e t f m, Scoped (NValue t f m) m) =>
m (Scopes m (NValue t f m))
builtins =
do
NValue t f m
ref <- forall v (m :: * -> *). MonadValue v m => m v -> m v
defer forall a b. (a -> b) -> a -> b
$ forall {w :: * -> *} {t} {m :: * -> *} {a}.
(Comonad w, Applicative w) =>
PositionSet
-> AttrSet (Free (NValue' t w m) a) -> Free (NValue' t w m) a
NVSet forall a. Monoid a => a
mempty forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (HashMap VarName (NValue t f m))
buildMap
(forall a (m :: * -> *) r. Scoped a m => Scope a -> m r -> m r
`pushScope` forall a (m :: * -> *). Scoped a m => m (Scopes m a)
askScopes) forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall x. One x => OneItem x -> x
one (VarName
"builtins", NValue t f m
ref) forall a. Semigroup a => a -> a -> a
<>) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< m [(VarName, NValue t f m)]
topLevelBuiltins
where
buildMap :: m (HashMap VarName (NValue t f m))
buildMap :: m (HashMap VarName (NValue t f m))
buildMap = forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall v. Builtin v -> (VarName, v)
mapping forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m [Builtin (NValue t f m)]
builtinsList
topLevelBuiltins :: m [(VarName, NValue t f m)]
topLevelBuiltins :: m [(VarName, NValue t f m)]
topLevelBuiltins = forall v. Builtin v -> (VarName, v)
mapping forall (f :: * -> *) (g :: * -> *) a b.
(Functor f, Functor g) =>
(a -> b) -> f (g a) -> f (g b)
<<$>> m [Builtin (NValue t f m)]
fullBuiltinsList
fullBuiltinsList :: m [Builtin (NValue t f m)]
fullBuiltinsList :: m [Builtin (NValue t f m)]
fullBuiltinsList = forall v. Builtin v -> Builtin v
nameBuiltins forall (f :: * -> *) (g :: * -> *) a b.
(Functor f, Functor g) =>
(a -> b) -> f (g a) -> f (g b)
<<$>> forall e t (f :: * -> *) (m :: * -> *).
MonadNix e t f m =>
m [Builtin (NValue t f m)]
builtinsList
where
nameBuiltins :: Builtin v -> Builtin v
nameBuiltins :: forall v. Builtin v -> Builtin v
nameBuiltins b :: Builtin v
b@(Builtin BuiltinType
TopLevel (VarName, v)
_) = Builtin v
b
nameBuiltins (Builtin BuiltinType
Normal (VarName, v)
nB) =
forall v. BuiltinType -> (VarName, v) -> Builtin v
Builtin BuiltinType
TopLevel forall a b. (a -> b) -> a -> b
$ forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (coerce :: forall a b. Coercible a b => a -> b
coerce @(Text -> Text) (Text
"__" forall a. Semigroup a => a -> a -> a
<>)) (VarName, v)
nB