{-# 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 #-} -- 2021-07-05: Due to hashing Haskell IT system situation, in HNix we currently ended-up with 2 hash package dependencies @{hashing, cryptonite}@

{-# options_ghc -fno-warn-name-shadowing #-}


-- | Code that implements Nix builtins. Lists the functions that are built into the Nix expression evaluator. Some built-ins (aka `derivation`), are always in the scope, so they can be accessed by the name. To keap the namespace clean, most built-ins are inside the `builtins` scope - a set that contains all what is a built-in.
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
                                                )

-- This is a big module. There is recursive reuse:
-- @builtins -> builtinsList -> scopedImport -> withNixContext -> builtins@,
-- since @builtins@ is self-recursive: aka we ship @builtins.builtins.builtins...@.

-- * Internal

-- ** Nix Builtins Haskell type level

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@ and its instances

-- | Types that support conversion to nix in a particular monad
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

-- *** @WValue@ closure wrapper to have @Ord@

-- We wrap values solely to provide an Ord instance for genericClosure
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

-- ** Helpers

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)

-- | @NIX_PATH@ is colon-separated, but can also contain URLs, which have a colon
-- (i.e. @https://...@)
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 -- ^ The string "pre"
  | VersionComponentString !Text -- ^ A string other than "pre"
  | VersionComponentNumber !Integer -- ^ A number
  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
  -- | Based on https://github.com/NixOS/nix/blob/4ee4fda521137fed6af0446948b3877e0c5db803/src/libexpr/names.cc#L44
  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)
  -- Like 'break', but always puts the first item into the first result
  -- list
  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"

-- ** Builtin functions

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
    -- This is compiled in so that we only parse it once at compile-time.
    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

-- This function is a bit special in that it doesn't care about the contents
-- of the list.
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

    -- NOTE: 2018-11-19: Currently prim_match in nix/src/libexpr/primops.cc
    -- ignores the context of its second argument. This is probably a bug but we're
    -- going to preserve the behavior here until it is fixed upstream.
    -- Relevant issue: https://github.com/NixOS/nix/issues/2547
    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 -- return only the matched groups, drop the full string
              )
      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
        -- NOTE: Currently prim_split in nix/src/libexpr/primops.cc ignores the
        -- context of its second argument. This is probably a bug but we're
        -- going to preserve the behavior here until it is fixed upstream.
        -- Relevant issue: https://github.com/NixOS/nix/issues/2547
    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  --NOTE: negative values of 'len' are OK, and mean "take everything"
      (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"

-- a safer version of `attrsetGet`
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)


--  NOTE: It is a part of the implementation taken from:
--  https://github.com/haskell-nix/hnix/pull/755
--  look there for `sha256` and/or `filterSource`
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

    -- TODO: Fail on extra args
    -- XXX: This is a very common pattern, we could factor it out
    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
    -- TODO: Ensure that s matches sha256 when not empty
    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

-- jww (2018-04-28): This should only be a string argument, and not coerced?
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)

-- | Evaluate `a` to WHNF to collect its topmost effect.
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

-- | Evaluate 'a' to NF to collect all of its effects, therefore data cycles are ignored.
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

-- | Takes:
-- 1. List of strings to match.
-- 2. List of strings to replace corresponding match occurance. (arg 1 & 2 lists matched by index)
-- 3. String to process
-- -> returns the string with requested replacements.
--
-- Example:
-- builtins.replaceStrings ["ll" "e"] [" " "i"] "Hello world" == "Hi o world".
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
    -- NixStrings have context - remember
    ([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
      --  2021-02-18: NOTE: if there is no match - the process does not changes the context, simply slides along the string.
      --  So it isbe more effective to pass the context as the first argument.
      --  And moreover, the `passOneCharNgo` passively passes the context, to context can be removed from it and inherited directly.
      --  Then the solution would've been elegant, but the Nix bug prevents elegant implementation.
      go :: HashSet StringContext -> Text -> Builder -> NixString
go HashSet StringContext
ctx Text
input Builder
output =
        forall b a. b -> (a -> b) -> Maybe a -> b
maybe
            -- Passively pass the chars
          NixString
passOneChar
          (Text, NixString, Text) -> NixString
replace
          Maybe (Text, NixString, Text)
maybePrefixMatch

       where
        -- When prefix matched something - returns (match, replacement, remainder)
        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

        -- Not passing args => It is constant that gets embedded into `go` => It is simple `go` tail recursion
        passOneChar :: NixString
passOneChar =
          forall b a. b -> (a -> b) -> Maybe a -> b
maybe
            (HashSet StringContext -> Builder -> NixString
finish HashSet StringContext
ctx Builder
output)  -- The base case - there is no chars left to process -> finish
            (\(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)) -- If there are chars - pass one char & continue
            (Text -> Maybe (Char, Text)
Text.uncons Text
input)  -- chip first char

        --  2021-02-18: NOTE: rly?: toStrict . toLazyText
        --  Maybe `text-builder`, `text-show`?
        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)  -- tail recursion
              -- Allowing match on "" is a inherited bug of Nix,
              -- when "" is checked - it always matches. And so - when it checks - it always insers a replacement, and then process simply passesthrough the char that was under match.
              --
              -- repl> builtins.replaceStrings ["" "e"] [" " "i"] "Hello world"
              -- " H e l l o   w o r l d "
              -- repl> builtins.replaceStrings ["ll" ""] [" " "i"] "Hello world"
              -- "iHie ioi iwioirilidi"
              --  2021-02-18: NOTE: There is no tests for this
              Text -> Builder -> NixString
bugPassOneChar  -- augmented recursion
              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

          -- The bug modifies the content => bug demands `pass` to be a real function =>
          -- `go` calls `pass` function && `pass` calls `go` function
          -- => mutual recusion case, so placed separately.
          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)  -- The base case - there is no chars left to process -> finish
              (\(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) -- If there are chars - pass one char & continue
              (Text -> Maybe (Char, Text)
Text.uncons Text
input)  -- chip first char

    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 @()

-- isString cannot use `hasKind` because it coerces derivationNixs to strings.
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

-- | Implementation of Nix @import@ clause.
--
-- Because Nix @import@s work strictly
-- (import gets fully evaluated befor bringing it into the scope it was called from)
-- - that property raises a requirement for execution phase of the interpreter go into evaluation phase
-- & then also go into parsing phase on the imports.
-- So it is not possible (more precise - not practical) to do a full parse Nix code phase fully & then go into evaluation phase.
-- As it is not possible to "import them lazily", as import is strict & it is not possible to establish
-- what imports whould be needed up until where it would be determined & they import strictly
--
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

-- | @scopedImport scope path@
-- An undocumented secret powerful function.
--
-- At the same time it is strongly forbidden to be used, as prolonged use of it would bring devastating consequences.
-- As it is essentially allows rewriting(redefinition) paradigm.
--
-- Allows to import the environment into the scope of a file expression that gets imported.
-- It is as if the contents at @path@ were given to @import@ wrapped as: @with scope; path@
-- meaning:
--
-- > -- Nix pseudocode:
-- > import (with scope; path)
--
-- For example, it allows to use itself as:
-- > bar = scopedImport pkgs ./bar.nix;
-- > -- & declare @./bar.nix@ without a header, so as:
-- > stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
--
-- But that breaks the evaluation/execution sharing of the @import@s.
--
-- Function also allows to redefine or extend the builtins.
--
-- For instance, to trace all calls to function ‘map’:
--
-- >  let
-- >    overrides = {
-- >      map = f: xs: builtins.trace "call of map!" (map f xs);
--
-- >      # Propagate override by calls to import&scopedImport.
-- >      import = fn: scopedImport overrides fn;
-- >      scopedImport = attrs: fn: scopedImport (overrides // attrs) fn;
--
-- >      # Update ‘builtins’.
-- >      builtins = builtins // overrides;
-- >    };
-- >  in scopedImport overrides ./bla.nix
--
-- In the related matter the function can be added and passed around as builtin.
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

-- | Helper function, generalization of @concat@ operations.
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]

-- | Nix function of Haskell:
-- > concat :: [[a]] -> [a]
--
-- Concatenate a list of lists into a single list.
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

-- | Nix function of Haskell:
-- > concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
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
      )

-- prim_hashString from nix/src/libexpr/primops.cc
-- fail if context in the algo arg
-- propagate context from the s arg
-- | The result coming out of hashString is base16 encoded
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
        --  2021-03-04: Pattern can not be taken-out because hashes represented as different types
        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
        -- This intermidiary `a` is only needed because of the type application
        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
-- use hashStringNix to hash file content
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
-- Groups elements of list together by the string returned from the function f called on 
-- each element. It returns an attribute set where each attribute value contains the 
-- elements of list that are mapped to the same corresponding attribute name returned by f.
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
      -- Please, stop Text -> Bytestring here after migration to Text
      forall a b. (a -> b) -> a -> b
$ case ByteString -> Either String ByteString
Base16.decode (NixString -> ByteString
bytes NixString
h) of -- The result coming out of hashString is base16 encoded
#if MIN_VERSION_base16_bytestring(1,0,0)
        -- Please, stop Text -> String here after migration to Text
        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
      -- | Function indeed binds filepaths as keys ('VarNames') in Nix attrset.
      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
      -- do we really need to marshall Text -> ByteString -> Aeson.Value (that is a Text)
      (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

-- Please, can function remember fail context
addErrorContextNix
  :: forall e t f m
   . MonadNix e t f m
  => NValue t f m
  -> NValue t f m  -- action
  -> 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 =
  -- 2018-11-19: NOTE: Still need to do something with the context here
  -- See prim_exec in nix/src/libexpr/primops.cc
  -- Requires the implementation of EvalState::realiseContext
  (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
  --  2022-01-21: NOTE: Needs to check the hash match.
  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 -- msha
          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
                      -- TODO: Fail for unexpected keys.

                      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@

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 -- for now
    , 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)
    --, add  Normal   "fetchGit"         fetchGit
    --, add  Normal   "fetchMercurial"   fetchMercurial
    , 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
    --, add  Normal   "filterSource"     filterSource
    , 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
    --, add  Normal   "fromTOML"         fromTOML
    , 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")
    --, add  Normal   "storePath"        storePath
    , 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 -- Deprecated in Nix: https://github.com/NixOS/nix/pull/2524
    , 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)


-- * Exported

-- | Evaluate expression in the default context.
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