{-# language ConstraintKinds #-}
{-# language CPP #-}
{-# language DeriveAnyClass #-}
{-# language FunctionalDependencies #-}
{-# language RankNTypes #-}
{-# language TemplateHaskell #-}
{-# language TypeFamilies #-}

{-# options_ghc -Wno-orphans #-}
{-# options_ghc -Wno-name-shadowing #-}
{-# options_ghc -Wno-missing-signatures #-}

-- | The Nix expression type and supporting types.
--
-- [Brief introduction of the Nix expression language.](https://nixos.org/nix/manual/#ch-expression-language)
--
-- This module is a beginning of a deep embedding (term) of a Nix language into Haskell.
-- [Brief on shallow & deep embedding.](https://web.archive.org/web/20201112031804/https://alessandrovermeulen.me/2013/07/13/the-difference-between-shallow-and-deep-embedding/)
--
-- (additiona info for dev): Big use of TemplateHaskell in the module requires proper (top-down) organization of declarations.
module Nix.Expr.Types
  ( module Nix.Expr.Types
  , SourcePos(..)
  , unPos
  , mkPos
  )
where

import           Nix.Prelude
import qualified Codec.Serialise               as Serialise
import           Codec.Serialise                ( Serialise )
import           Control.DeepSeq                ( NFData1(..) )
import           Data.Aeson
import qualified Data.Binary                   as Binary
import           Data.Binary                    ( Binary )
import           Data.Data
import           Data.Fix                       ( Fix(..) )
import           Data.Functor.Classes
import           Data.Hashable.Lifted
import qualified Data.HashMap.Lazy             as MapL
import qualified Data.Set                      as Set
import qualified Data.List.NonEmpty            as NE
import qualified Text.Show
import           Data.Traversable               ( fmapDefault, foldMapDefault )
import           GHC.Generics
import qualified Language.Haskell.TH.Syntax    as TH
import           Lens.Family2
import           Lens.Family2.TH
import           Text.Megaparsec.Pos            ( Pos
                                                , mkPos
                                                , unPos
                                                , SourcePos(SourcePos)
                                                )
import           Text.Show.Deriving             ( deriveShow1, deriveShow2 )
import           Text.Read.Deriving             ( deriveRead1, deriveRead2 )
import           Data.Eq.Deriving               ( deriveEq1  , deriveEq2   )
import           Data.Ord.Deriving              ( deriveOrd1 , deriveOrd2  )
import           Data.Aeson.TH                  ( deriveJSON2 )
import qualified Type.Reflection               as Reflection
import           Nix.Atoms
#if !MIN_VERSION_text(1,2,4)
-- NOTE: Remove package @th-lift-instances@ removing this
import           Instances.TH.Lift              ()  -- importing Lift Text for GHC 8.6
#endif


-- * utils

newtype NPos = NPos Pos
 deriving
   ( NPos -> NPos -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NPos -> NPos -> Bool
$c/= :: NPos -> NPos -> Bool
== :: NPos -> NPos -> Bool
$c== :: NPos -> NPos -> Bool
Eq, Eq NPos
NPos -> NPos -> Bool
NPos -> NPos -> Ordering
NPos -> NPos -> NPos
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 :: NPos -> NPos -> NPos
$cmin :: NPos -> NPos -> NPos
max :: NPos -> NPos -> NPos
$cmax :: NPos -> NPos -> NPos
>= :: NPos -> NPos -> Bool
$c>= :: NPos -> NPos -> Bool
> :: NPos -> NPos -> Bool
$c> :: NPos -> NPos -> Bool
<= :: NPos -> NPos -> Bool
$c<= :: NPos -> NPos -> Bool
< :: NPos -> NPos -> Bool
$c< :: NPos -> NPos -> Bool
compare :: NPos -> NPos -> Ordering
$ccompare :: NPos -> NPos -> Ordering
Ord
   , ReadPrec [NPos]
ReadPrec NPos
Int -> ReadS NPos
ReadS [NPos]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NPos]
$creadListPrec :: ReadPrec [NPos]
readPrec :: ReadPrec NPos
$creadPrec :: ReadPrec NPos
readList :: ReadS [NPos]
$creadList :: ReadS [NPos]
readsPrec :: Int -> ReadS NPos
$creadsPrec :: Int -> ReadS NPos
Read, Int -> NPos -> ShowS
[NPos] -> ShowS
NPos -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [NPos] -> ShowS
$cshowList :: [NPos] -> ShowS
show :: NPos -> FilePath
$cshow :: NPos -> FilePath
showsPrec :: Int -> NPos -> ShowS
$cshowsPrec :: Int -> NPos -> ShowS
Show
   , Typeable NPos
NPos -> DataType
NPos -> Constr
(forall b. Data b => b -> b) -> NPos -> NPos
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NPos -> u
forall u. (forall d. Data d => d -> u) -> NPos -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NPos -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NPos -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NPos -> m NPos
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NPos -> m NPos
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NPos
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NPos -> c NPos
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NPos)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NPos)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NPos -> m NPos
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NPos -> m NPos
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NPos -> m NPos
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NPos -> m NPos
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NPos -> m NPos
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NPos -> m NPos
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NPos -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NPos -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NPos -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NPos -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NPos -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NPos -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NPos -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NPos -> r
gmapT :: (forall b. Data b => b -> b) -> NPos -> NPos
$cgmapT :: (forall b. Data b => b -> b) -> NPos -> NPos
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NPos)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NPos)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NPos)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NPos)
dataTypeOf :: NPos -> DataType
$cdataTypeOf :: NPos -> DataType
toConstr :: NPos -> Constr
$ctoConstr :: NPos -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NPos
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NPos
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NPos -> c NPos
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NPos -> c NPos
Data, NPos -> ()
forall a. (a -> ()) -> NFData a
rnf :: NPos -> ()
$crnf :: NPos -> ()
NFData
   , forall x. Rep NPos x -> NPos
forall x. NPos -> Rep NPos x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NPos x -> NPos
$cfrom :: forall x. NPos -> Rep NPos x
Generic
   )

instance Semigroup NPos where
  (NPos Pos
x) <> :: NPos -> NPos -> NPos
<> (NPos Pos
y) = Pos -> NPos
NPos (Pos
x forall a. Semigroup a => a -> a -> a
<> Pos
y)

-- | Represents source positions.
-- Source line & column positions change intensively during parsing,
-- so they are declared strict to avoid memory leaks.
--
-- The data type is a reimplementation of 'Text.Megaparsec.Pos' 'SourcePos'.
data NSourcePos =
  NSourcePos
  { -- | Name of source file
    NSourcePos -> Path
getSourceName :: Path,
    -- | Line number
    NSourcePos -> NPos
getSourceLine :: !NPos,
    -- | Column number
    NSourcePos -> NPos
getSourceColumn :: !NPos
  }
 deriving
   ( NSourcePos -> NSourcePos -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NSourcePos -> NSourcePos -> Bool
$c/= :: NSourcePos -> NSourcePos -> Bool
== :: NSourcePos -> NSourcePos -> Bool
$c== :: NSourcePos -> NSourcePos -> Bool
Eq, Eq NSourcePos
NSourcePos -> NSourcePos -> Bool
NSourcePos -> NSourcePos -> Ordering
NSourcePos -> NSourcePos -> NSourcePos
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 :: NSourcePos -> NSourcePos -> NSourcePos
$cmin :: NSourcePos -> NSourcePos -> NSourcePos
max :: NSourcePos -> NSourcePos -> NSourcePos
$cmax :: NSourcePos -> NSourcePos -> NSourcePos
>= :: NSourcePos -> NSourcePos -> Bool
$c>= :: NSourcePos -> NSourcePos -> Bool
> :: NSourcePos -> NSourcePos -> Bool
$c> :: NSourcePos -> NSourcePos -> Bool
<= :: NSourcePos -> NSourcePos -> Bool
$c<= :: NSourcePos -> NSourcePos -> Bool
< :: NSourcePos -> NSourcePos -> Bool
$c< :: NSourcePos -> NSourcePos -> Bool
compare :: NSourcePos -> NSourcePos -> Ordering
$ccompare :: NSourcePos -> NSourcePos -> Ordering
Ord
   , ReadPrec [NSourcePos]
ReadPrec NSourcePos
Int -> ReadS NSourcePos
ReadS [NSourcePos]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NSourcePos]
$creadListPrec :: ReadPrec [NSourcePos]
readPrec :: ReadPrec NSourcePos
$creadPrec :: ReadPrec NSourcePos
readList :: ReadS [NSourcePos]
$creadList :: ReadS [NSourcePos]
readsPrec :: Int -> ReadS NSourcePos
$creadsPrec :: Int -> ReadS NSourcePos
Read, Int -> NSourcePos -> ShowS
[NSourcePos] -> ShowS
NSourcePos -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [NSourcePos] -> ShowS
$cshowList :: [NSourcePos] -> ShowS
show :: NSourcePos -> FilePath
$cshow :: NSourcePos -> FilePath
showsPrec :: Int -> NSourcePos -> ShowS
$cshowsPrec :: Int -> NSourcePos -> ShowS
Show
   , Typeable NSourcePos
NSourcePos -> DataType
NSourcePos -> Constr
(forall b. Data b => b -> b) -> NSourcePos -> NSourcePos
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NSourcePos -> u
forall u. (forall d. Data d => d -> u) -> NSourcePos -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NSourcePos -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NSourcePos -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NSourcePos -> m NSourcePos
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSourcePos -> m NSourcePos
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NSourcePos
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NSourcePos -> c NSourcePos
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NSourcePos)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NSourcePos)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSourcePos -> m NSourcePos
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSourcePos -> m NSourcePos
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSourcePos -> m NSourcePos
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSourcePos -> m NSourcePos
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NSourcePos -> m NSourcePos
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NSourcePos -> m NSourcePos
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NSourcePos -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NSourcePos -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NSourcePos -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NSourcePos -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NSourcePos -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NSourcePos -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NSourcePos -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NSourcePos -> r
gmapT :: (forall b. Data b => b -> b) -> NSourcePos -> NSourcePos
$cgmapT :: (forall b. Data b => b -> b) -> NSourcePos -> NSourcePos
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NSourcePos)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NSourcePos)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NSourcePos)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NSourcePos)
dataTypeOf :: NSourcePos -> DataType
$cdataTypeOf :: NSourcePos -> DataType
toConstr :: NSourcePos -> Constr
$ctoConstr :: NSourcePos -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NSourcePos
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NSourcePos
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NSourcePos -> c NSourcePos
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NSourcePos -> c NSourcePos
Data, NSourcePos -> ()
forall a. (a -> ()) -> NFData a
rnf :: NSourcePos -> ()
$crnf :: NSourcePos -> ()
NFData
   , forall x. Rep NSourcePos x -> NSourcePos
forall x. NSourcePos -> Rep NSourcePos x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NSourcePos x -> NSourcePos
$cfrom :: forall x. NSourcePos -> Rep NSourcePos x
Generic
   )

-- | Helper for 'SourcePos' -> 'NSourcePos' coersion.
toNSourcePos :: SourcePos -> NSourcePos
toNSourcePos :: SourcePos -> NSourcePos
toNSourcePos (SourcePos FilePath
f Pos
l Pos
c) =
  Path -> NPos -> NPos -> NSourcePos
NSourcePos (coerce :: forall a b. Coercible a b => a -> b
coerce FilePath
f) (coerce :: forall a b. Coercible a b => a -> b
coerce Pos
l) (coerce :: forall a b. Coercible a b => a -> b
coerce Pos
c)

-- | Helper for 'NSourcePos' -> 'SourcePos' coersion.
toSourcePos :: NSourcePos -> SourcePos
toSourcePos :: NSourcePos -> SourcePos
toSourcePos (NSourcePos Path
f NPos
l NPos
c) =
  FilePath -> Pos -> Pos -> SourcePos
SourcePos (coerce :: forall a b. Coercible a b => a -> b
coerce Path
f) (coerce :: forall a b. Coercible a b => a -> b
coerce NPos
l) (coerce :: forall a b. Coercible a b => a -> b
coerce NPos
c)

--  2021-07-16: NOTE: Should replace @ParamSet@ List
-- | > Hashmap VarName -- type synonym
type AttrSet = HashMap VarName

-- | Holds file positionng information for abstrations.
-- A type synonym for @HashMap VarName NSourcePos@.
type PositionSet = AttrSet NSourcePos

-- ** Additional N{,Source}Pos instances

-- Placed here because TH inference depends on declaration sequence.

instance Serialise NPos where
  encode :: NPos -> Encoding
encode = forall a. Serialise a => a -> Encoding
Serialise.encode forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pos -> Int
unPos forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce
  decode :: forall s. Decoder s NPos
decode = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Pos
mkPos forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a s. Serialise a => Decoder s a
Serialise.decode

instance Serialise NSourcePos where
  encode :: NSourcePos -> Encoding
encode (NSourcePos Path
f NPos
l NPos
c) =
    coerce :: forall a b. Coercible a b => a -> b
coerce forall a b. (a -> b) -> a -> b
$
    forall a. Serialise a => a -> Encoding
Serialise.encode Path
f forall a. Semigroup a => a -> a -> a
<>
    forall a. Serialise a => a -> Encoding
Serialise.encode NPos
l forall a. Semigroup a => a -> a -> a
<>
    forall a. Serialise a => a -> Encoding
Serialise.encode NPos
c
  decode :: forall s. Decoder s NSourcePos
decode =
    forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 Path -> NPos -> NPos -> NSourcePos
NSourcePos
      forall a s. Serialise a => Decoder s a
Serialise.decode
      forall a s. Serialise a => Decoder s a
Serialise.decode
      forall a s. Serialise a => Decoder s a
Serialise.decode

instance Hashable NPos where
  hashWithSalt :: Int -> NPos -> Int
hashWithSalt Int
salt = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
salt forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pos -> Int
unPos forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce

instance Hashable NSourcePos where
  hashWithSalt :: Int -> NSourcePos -> Int
hashWithSalt Int
salt (NSourcePos Path
f NPos
l NPos
c) =
    Int
salt
      forall a. Hashable a => Int -> a -> Int
`hashWithSalt` Path
f
      forall a. Hashable a => Int -> a -> Int
`hashWithSalt` NPos
l
      forall a. Hashable a => Int -> a -> Int
`hashWithSalt` NPos
c

instance Binary NPos where
  put :: NPos -> Put
put = (forall t. Binary t => t -> Put
Binary.put @Int) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pos -> Int
unPos forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce
  get :: Get NPos
get = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Pos
mkPos forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall t. Binary t => Get t
Binary.get
instance Binary NSourcePos

instance ToJSON NPos where
  toJSON :: NPos -> Value
toJSON = forall a. ToJSON a => a -> Value
toJSON forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pos -> Int
unPos forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce
instance ToJSON NSourcePos

instance FromJSON NPos where
  parseJSON :: Value -> Parser NPos
parseJSON = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Pos
mkPos forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. FromJSON a => Value -> Parser a
parseJSON
instance FromJSON NSourcePos

-- * Components of Nix expressions

-- NExpr is a composition of
--   * direct reuse of the Haskell types (list, Path, Text)
--   * NAtom
--   * Types in this section
--   * Fixpoint nature

-- ** newtype VarName

newtype VarName = VarName Text
  deriving
    ( VarName -> VarName -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VarName -> VarName -> Bool
$c/= :: VarName -> VarName -> Bool
== :: VarName -> VarName -> Bool
$c== :: VarName -> VarName -> Bool
Eq, Eq VarName
VarName -> VarName -> Bool
VarName -> VarName -> Ordering
VarName -> VarName -> VarName
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 :: VarName -> VarName -> VarName
$cmin :: VarName -> VarName -> VarName
max :: VarName -> VarName -> VarName
$cmax :: VarName -> VarName -> VarName
>= :: VarName -> VarName -> Bool
$c>= :: VarName -> VarName -> Bool
> :: VarName -> VarName -> Bool
$c> :: VarName -> VarName -> Bool
<= :: VarName -> VarName -> Bool
$c<= :: VarName -> VarName -> Bool
< :: VarName -> VarName -> Bool
$c< :: VarName -> VarName -> Bool
compare :: VarName -> VarName -> Ordering
$ccompare :: VarName -> VarName -> Ordering
Ord, forall x. Rep VarName x -> VarName
forall x. VarName -> Rep VarName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VarName x -> VarName
$cfrom :: forall x. VarName -> Rep VarName x
Generic
    , Typeable, Typeable VarName
VarName -> DataType
VarName -> Constr
(forall b. Data b => b -> b) -> VarName -> VarName
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> VarName -> u
forall u. (forall d. Data d => d -> u) -> VarName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarName -> c VarName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarName)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarName -> m VarName
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarName -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> VarName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VarName -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarName -> r
gmapT :: (forall b. Data b => b -> b) -> VarName -> VarName
$cgmapT :: (forall b. Data b => b -> b) -> VarName -> VarName
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarName)
dataTypeOf :: VarName -> DataType
$cdataTypeOf :: VarName -> DataType
toConstr :: VarName -> Constr
$ctoConstr :: VarName -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarName -> c VarName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarName -> c VarName
Data, VarName -> ()
forall a. (a -> ()) -> NFData a
rnf :: VarName -> ()
$crnf :: VarName -> ()
NFData, [VarName] -> Encoding
VarName -> Encoding
forall s. Decoder s [VarName]
forall s. Decoder s VarName
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [VarName]
$cdecodeList :: forall s. Decoder s [VarName]
encodeList :: [VarName] -> Encoding
$cencodeList :: [VarName] -> Encoding
decode :: forall s. Decoder s VarName
$cdecode :: forall s. Decoder s VarName
encode :: VarName -> Encoding
$cencode :: VarName -> Encoding
Serialise, Get VarName
[VarName] -> Put
VarName -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [VarName] -> Put
$cputList :: [VarName] -> Put
get :: Get VarName
$cget :: Get VarName
put :: VarName -> Put
$cput :: VarName -> Put
Binary, [VarName] -> Encoding
[VarName] -> Value
VarName -> Encoding
VarName -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [VarName] -> Encoding
$ctoEncodingList :: [VarName] -> Encoding
toJSONList :: [VarName] -> Value
$ctoJSONList :: [VarName] -> Value
toEncoding :: VarName -> Encoding
$ctoEncoding :: VarName -> Encoding
toJSON :: VarName -> Value
$ctoJSON :: VarName -> Value
ToJSON, Value -> Parser [VarName]
Value -> Parser VarName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [VarName]
$cparseJSONList :: Value -> Parser [VarName]
parseJSON :: Value -> Parser VarName
$cparseJSON :: Value -> Parser VarName
FromJSON
    , Int -> VarName -> ShowS
[VarName] -> ShowS
VarName -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [VarName] -> ShowS
$cshowList :: [VarName] -> ShowS
show :: VarName -> FilePath
$cshow :: VarName -> FilePath
showsPrec :: Int -> VarName -> ShowS
$cshowsPrec :: Int -> VarName -> ShowS
Show, ReadPrec [VarName]
ReadPrec VarName
Int -> ReadS VarName
ReadS [VarName]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VarName]
$creadListPrec :: ReadPrec [VarName]
readPrec :: ReadPrec VarName
$creadPrec :: ReadPrec VarName
readList :: ReadS [VarName]
$creadList :: ReadS [VarName]
readsPrec :: Int -> ReadS VarName
$creadsPrec :: Int -> ReadS VarName
Read, Eq VarName
Int -> VarName -> Int
VarName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: VarName -> Int
$chash :: VarName -> Int
hashWithSalt :: Int -> VarName -> Int
$chashWithSalt :: Int -> VarName -> Int
Hashable
    )

instance IsString VarName where
  fromString :: FilePath -> VarName
fromString = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IsString a => FilePath -> a
fromString @Text

instance ToString VarName where
  toString :: VarName -> FilePath
toString = forall a. ToString a => a -> FilePath
toString @Text forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce

-- ** data Params

-- *** utils

-- This uses an association list because nix XML serialization preserves the
-- order of the param set.
type ParamSet r = [(VarName, Maybe r)]

data Variadic = Closed | Variadic
  deriving
    ( Variadic -> Variadic -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Variadic -> Variadic -> Bool
$c/= :: Variadic -> Variadic -> Bool
== :: Variadic -> Variadic -> Bool
$c== :: Variadic -> Variadic -> Bool
Eq, Eq Variadic
Variadic -> Variadic -> Bool
Variadic -> Variadic -> Ordering
Variadic -> Variadic -> Variadic
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 :: Variadic -> Variadic -> Variadic
$cmin :: Variadic -> Variadic -> Variadic
max :: Variadic -> Variadic -> Variadic
$cmax :: Variadic -> Variadic -> Variadic
>= :: Variadic -> Variadic -> Bool
$c>= :: Variadic -> Variadic -> Bool
> :: Variadic -> Variadic -> Bool
$c> :: Variadic -> Variadic -> Bool
<= :: Variadic -> Variadic -> Bool
$c<= :: Variadic -> Variadic -> Bool
< :: Variadic -> Variadic -> Bool
$c< :: Variadic -> Variadic -> Bool
compare :: Variadic -> Variadic -> Ordering
$ccompare :: Variadic -> Variadic -> Ordering
Ord, forall x. Rep Variadic x -> Variadic
forall x. Variadic -> Rep Variadic x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Variadic x -> Variadic
$cfrom :: forall x. Variadic -> Rep Variadic x
Generic
    , Typeable, Typeable Variadic
Variadic -> DataType
Variadic -> Constr
(forall b. Data b => b -> b) -> Variadic -> Variadic
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Variadic -> u
forall u. (forall d. Data d => d -> u) -> Variadic -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Variadic -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Variadic -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Variadic -> m Variadic
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Variadic -> m Variadic
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Variadic
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Variadic -> c Variadic
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Variadic)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Variadic)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Variadic -> m Variadic
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Variadic -> m Variadic
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Variadic -> m Variadic
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Variadic -> m Variadic
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Variadic -> m Variadic
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Variadic -> m Variadic
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Variadic -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Variadic -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Variadic -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Variadic -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Variadic -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Variadic -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Variadic -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Variadic -> r
gmapT :: (forall b. Data b => b -> b) -> Variadic -> Variadic
$cgmapT :: (forall b. Data b => b -> b) -> Variadic -> Variadic
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Variadic)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Variadic)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Variadic)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Variadic)
dataTypeOf :: Variadic -> DataType
$cdataTypeOf :: Variadic -> DataType
toConstr :: Variadic -> Constr
$ctoConstr :: Variadic -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Variadic
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Variadic
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Variadic -> c Variadic
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Variadic -> c Variadic
Data, Variadic -> ()
forall a. (a -> ()) -> NFData a
rnf :: Variadic -> ()
$crnf :: Variadic -> ()
NFData, [Variadic] -> Encoding
Variadic -> Encoding
forall s. Decoder s [Variadic]
forall s. Decoder s Variadic
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [Variadic]
$cdecodeList :: forall s. Decoder s [Variadic]
encodeList :: [Variadic] -> Encoding
$cencodeList :: [Variadic] -> Encoding
decode :: forall s. Decoder s Variadic
$cdecode :: forall s. Decoder s Variadic
encode :: Variadic -> Encoding
$cencode :: Variadic -> Encoding
Serialise, Get Variadic
[Variadic] -> Put
Variadic -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [Variadic] -> Put
$cputList :: [Variadic] -> Put
get :: Get Variadic
$cget :: Get Variadic
put :: Variadic -> Put
$cput :: Variadic -> Put
Binary, [Variadic] -> Encoding
[Variadic] -> Value
Variadic -> Encoding
Variadic -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Variadic] -> Encoding
$ctoEncodingList :: [Variadic] -> Encoding
toJSONList :: [Variadic] -> Value
$ctoJSONList :: [Variadic] -> Value
toEncoding :: Variadic -> Encoding
$ctoEncoding :: Variadic -> Encoding
toJSON :: Variadic -> Value
$ctoJSON :: Variadic -> Value
ToJSON, Value -> Parser [Variadic]
Value -> Parser Variadic
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Variadic]
$cparseJSONList :: Value -> Parser [Variadic]
parseJSON :: Value -> Parser Variadic
$cparseJSON :: Value -> Parser Variadic
FromJSON
    , Int -> Variadic -> ShowS
[Variadic] -> ShowS
Variadic -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Variadic] -> ShowS
$cshowList :: [Variadic] -> ShowS
show :: Variadic -> FilePath
$cshow :: Variadic -> FilePath
showsPrec :: Int -> Variadic -> ShowS
$cshowsPrec :: Int -> Variadic -> ShowS
Show, ReadPrec [Variadic]
ReadPrec Variadic
Int -> ReadS Variadic
ReadS [Variadic]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Variadic]
$creadListPrec :: ReadPrec [Variadic]
readPrec :: ReadPrec Variadic
$creadPrec :: ReadPrec Variadic
readList :: ReadS [Variadic]
$creadList :: ReadS [Variadic]
readsPrec :: Int -> ReadS Variadic
$creadsPrec :: Int -> ReadS Variadic
Read, Eq Variadic
Int -> Variadic -> Int
Variadic -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Variadic -> Int
$chash :: Variadic -> Int
hashWithSalt :: Int -> Variadic -> Int
$chashWithSalt :: Int -> Variadic -> Int
Hashable
    )

instance Semigroup Variadic where
  <> :: Variadic -> Variadic -> Variadic
(<>) Variadic
Closed Variadic
Closed = Variadic
Closed
  (<>) Variadic
_      Variadic
_      = Variadic
Variadic

instance Monoid Variadic where
  mempty :: Variadic
mempty = Variadic
Closed

-- *** data Params

-- | @Params@ represents all the ways the formal parameters to a
-- function can be represented.
data Params r
  = Param !VarName
  -- ^ For functions with a single named argument, such as @x: x + 1@.
  --
  -- > Param "x"                                  ~  x
  | ParamSet !(Maybe VarName) !Variadic !(ParamSet r)
  -- ^ Explicit parameters (argument must be a set). Might specify a name to
  -- bind to the set in the function body. The bool indicates whether it is
  -- variadic or not.
  --
  -- > ParamSet  Nothing   False [("x",Nothing)]  ~  { x }
  -- > ParamSet (pure "s") True  [("x", pure y)]  ~  s@{ x ? y, ... }
  deriving
    ( Params r -> Params r -> Bool
forall r. Eq r => Params r -> Params r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Params r -> Params r -> Bool
$c/= :: forall r. Eq r => Params r -> Params r -> Bool
== :: Params r -> Params r -> Bool
$c== :: forall r. Eq r => Params r -> Params r -> Bool
Eq, Params r -> Params r -> Bool
Params r -> Params r -> Ordering
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
forall {r}. Ord r => Eq (Params r)
forall r. Ord r => Params r -> Params r -> Bool
forall r. Ord r => Params r -> Params r -> Ordering
forall r. Ord r => Params r -> Params r -> Params r
min :: Params r -> Params r -> Params r
$cmin :: forall r. Ord r => Params r -> Params r -> Params r
max :: Params r -> Params r -> Params r
$cmax :: forall r. Ord r => Params r -> Params r -> Params r
>= :: Params r -> Params r -> Bool
$c>= :: forall r. Ord r => Params r -> Params r -> Bool
> :: Params r -> Params r -> Bool
$c> :: forall r. Ord r => Params r -> Params r -> Bool
<= :: Params r -> Params r -> Bool
$c<= :: forall r. Ord r => Params r -> Params r -> Bool
< :: Params r -> Params r -> Bool
$c< :: forall r. Ord r => Params r -> Params r -> Bool
compare :: Params r -> Params r -> Ordering
$ccompare :: forall r. Ord r => Params r -> Params r -> Ordering
Ord, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (Params r) x -> Params r
forall r x. Params r -> Rep (Params r) x
$cto :: forall r x. Rep (Params r) x -> Params r
$cfrom :: forall r x. Params r -> Rep (Params r) x
Generic, forall a. Rep1 Params a -> Params a
forall a. Params a -> Rep1 Params a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall a. Rep1 Params a -> Params a
$cfrom1 :: forall a. Params a -> Rep1 Params a
Generic1
    , Typeable, Params r -> DataType
Params r -> Constr
forall {r}. Data r => Typeable (Params r)
forall r. Data r => Params r -> DataType
forall r. Data r => Params r -> Constr
forall r.
Data r =>
(forall b. Data b => b -> b) -> Params r -> Params r
forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> Params r -> u
forall r u.
Data r =>
(forall d. Data d => d -> u) -> Params r -> [u]
forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Params r -> r
forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Params r -> r
forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Params r)
forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Params r -> c (Params r)
forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Params r))
forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Params r))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Params r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Params r -> c (Params r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Params r))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
$cgmapMo :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
$cgmapMp :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
$cgmapM :: forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Params r -> u
$cgmapQi :: forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> Params r -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Params r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> Params r -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Params r -> r
$cgmapQr :: forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Params r -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Params r -> r
$cgmapQl :: forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Params r -> r
gmapT :: (forall b. Data b => b -> b) -> Params r -> Params r
$cgmapT :: forall r.
Data r =>
(forall b. Data b => b -> b) -> Params r -> Params r
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Params r))
$cdataCast2 :: forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Params r))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Params r))
$cdataCast1 :: forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Params r))
dataTypeOf :: Params r -> DataType
$cdataTypeOf :: forall r. Data r => Params r -> DataType
toConstr :: Params r -> Constr
$ctoConstr :: forall r. Data r => Params r -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Params r)
$cgunfold :: forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Params r)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Params r -> c (Params r)
$cgfoldl :: forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Params r -> c (Params r)
Data, forall r. NFData r => Params r -> ()
forall a. (a -> ()) -> NFData a
rnf :: Params r -> ()
$crnf :: forall r. NFData r => Params r -> ()
NFData, forall a. (a -> ()) -> Params a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: forall a. (a -> ()) -> Params a -> ()
$cliftRnf :: forall a. (a -> ()) -> Params a -> ()
NFData1, forall r. Serialise r => [Params r] -> Encoding
forall r. Serialise r => Params r -> Encoding
forall r s. Serialise r => Decoder s [Params r]
forall r s. Serialise r => Decoder s (Params r)
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [Params r]
$cdecodeList :: forall r s. Serialise r => Decoder s [Params r]
encodeList :: [Params r] -> Encoding
$cencodeList :: forall r. Serialise r => [Params r] -> Encoding
decode :: forall s. Decoder s (Params r)
$cdecode :: forall r s. Serialise r => Decoder s (Params r)
encode :: Params r -> Encoding
$cencode :: forall r. Serialise r => Params r -> Encoding
Serialise, forall r. Binary r => Get (Params r)
forall r. Binary r => [Params r] -> Put
forall r. Binary r => Params r -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [Params r] -> Put
$cputList :: forall r. Binary r => [Params r] -> Put
get :: Get (Params r)
$cget :: forall r. Binary r => Get (Params r)
put :: Params r -> Put
$cput :: forall r. Binary r => Params r -> Put
Binary, forall r. ToJSON r => [Params r] -> Encoding
forall r. ToJSON r => [Params r] -> Value
forall r. ToJSON r => Params r -> Encoding
forall r. ToJSON r => Params r -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Params r] -> Encoding
$ctoEncodingList :: forall r. ToJSON r => [Params r] -> Encoding
toJSONList :: [Params r] -> Value
$ctoJSONList :: forall r. ToJSON r => [Params r] -> Value
toEncoding :: Params r -> Encoding
$ctoEncoding :: forall r. ToJSON r => Params r -> Encoding
toJSON :: Params r -> Value
$ctoJSON :: forall r. ToJSON r => Params r -> Value
ToJSON, forall a.
(a -> Encoding) -> ([a] -> Encoding) -> [Params a] -> Encoding
forall a.
(a -> Encoding) -> ([a] -> Encoding) -> Params a -> Encoding
forall a. (a -> Value) -> ([a] -> Value) -> [Params a] -> Value
forall a. (a -> Value) -> ([a] -> Value) -> Params a -> Value
forall (f :: * -> *).
(forall a. (a -> Value) -> ([a] -> Value) -> f a -> Value)
-> (forall a. (a -> Value) -> ([a] -> Value) -> [f a] -> Value)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding)
-> ToJSON1 f
liftToEncodingList :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> [Params a] -> Encoding
$cliftToEncodingList :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> [Params a] -> Encoding
liftToEncoding :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> Params a -> Encoding
$cliftToEncoding :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> Params a -> Encoding
liftToJSONList :: forall a. (a -> Value) -> ([a] -> Value) -> [Params a] -> Value
$cliftToJSONList :: forall a. (a -> Value) -> ([a] -> Value) -> [Params a] -> Value
liftToJSON :: forall a. (a -> Value) -> ([a] -> Value) -> Params a -> Value
$cliftToJSON :: forall a. (a -> Value) -> ([a] -> Value) -> Params a -> Value
ToJSON1, forall r. FromJSON r => Value -> Parser [Params r]
forall r. FromJSON r => Value -> Parser (Params r)
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Params r]
$cparseJSONList :: forall r. FromJSON r => Value -> Parser [Params r]
parseJSON :: Value -> Parser (Params r)
$cparseJSON :: forall r. FromJSON r => Value -> Parser (Params r)
FromJSON, forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [Params a]
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (Params a)
forall (f :: * -> *).
(forall a.
 (Value -> Parser a)
 -> (Value -> Parser [a]) -> Value -> Parser (f a))
-> (forall a.
    (Value -> Parser a)
    -> (Value -> Parser [a]) -> Value -> Parser [f a])
-> FromJSON1 f
liftParseJSONList :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [Params a]
$cliftParseJSONList :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [Params a]
liftParseJSON :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (Params a)
$cliftParseJSON :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (Params a)
FromJSON1
    , forall a b. a -> Params b -> Params a
forall a b. (a -> b) -> Params a -> Params b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Params b -> Params a
$c<$ :: forall a b. a -> Params b -> Params a
fmap :: forall a b. (a -> b) -> Params a -> Params b
$cfmap :: forall a b. (a -> b) -> Params a -> Params b
Functor, forall a. Eq a => a -> Params a -> Bool
forall a. Num a => Params a -> a
forall a. Ord a => Params a -> a
forall m. Monoid m => Params m -> m
forall a. Params a -> Bool
forall a. Params a -> Int
forall a. Params a -> [a]
forall a. (a -> a -> a) -> Params a -> a
forall m a. Monoid m => (a -> m) -> Params a -> m
forall b a. (b -> a -> b) -> b -> Params a -> b
forall a b. (a -> b -> b) -> b -> Params a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Params a -> a
$cproduct :: forall a. Num a => Params a -> a
sum :: forall a. Num a => Params a -> a
$csum :: forall a. Num a => Params a -> a
minimum :: forall a. Ord a => Params a -> a
$cminimum :: forall a. Ord a => Params a -> a
maximum :: forall a. Ord a => Params a -> a
$cmaximum :: forall a. Ord a => Params a -> a
elem :: forall a. Eq a => a -> Params a -> Bool
$celem :: forall a. Eq a => a -> Params a -> Bool
length :: forall a. Params a -> Int
$clength :: forall a. Params a -> Int
null :: forall a. Params a -> Bool
$cnull :: forall a. Params a -> Bool
toList :: forall a. Params a -> [a]
$ctoList :: forall a. Params a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Params a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Params a -> a
foldr1 :: forall a. (a -> a -> a) -> Params a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Params a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Params a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Params a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Params a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Params a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Params a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Params a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Params a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Params a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Params a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Params a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Params a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Params a -> m
fold :: forall m. Monoid m => Params m -> m
$cfold :: forall m. Monoid m => Params m -> m
Foldable, Functor Params
Foldable Params
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Params (m a) -> m (Params a)
forall (f :: * -> *) a.
Applicative f =>
Params (f a) -> f (Params a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Params a -> m (Params b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Params a -> f (Params b)
sequence :: forall (m :: * -> *) a. Monad m => Params (m a) -> m (Params a)
$csequence :: forall (m :: * -> *) a. Monad m => Params (m a) -> m (Params a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Params a -> m (Params b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Params a -> m (Params b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Params (f a) -> f (Params a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Params (f a) -> f (Params a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Params a -> f (Params b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Params a -> f (Params b)
Traversable
    , Int -> Params r -> ShowS
forall r. Show r => Int -> Params r -> ShowS
forall r. Show r => [Params r] -> ShowS
forall r. Show r => Params r -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Params r] -> ShowS
$cshowList :: forall r. Show r => [Params r] -> ShowS
show :: Params r -> FilePath
$cshow :: forall r. Show r => Params r -> FilePath
showsPrec :: Int -> Params r -> ShowS
$cshowsPrec :: forall r. Show r => Int -> Params r -> ShowS
Show, ReadPrec [Params r]
ReadPrec (Params r)
ReadS [Params r]
forall r. Read r => ReadPrec [Params r]
forall r. Read r => ReadPrec (Params r)
forall r. Read r => Int -> ReadS (Params r)
forall r. Read r => ReadS [Params r]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Params r]
$creadListPrec :: forall r. Read r => ReadPrec [Params r]
readPrec :: ReadPrec (Params r)
$creadPrec :: forall r. Read r => ReadPrec (Params r)
readList :: ReadS [Params r]
$creadList :: forall r. Read r => ReadS [Params r]
readsPrec :: Int -> ReadS (Params r)
$creadsPrec :: forall r. Read r => Int -> ReadS (Params r)
Read, forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall {r}. Hashable r => Eq (Params r)
forall r. Hashable r => Int -> Params r -> Int
forall r. Hashable r => Params r -> Int
hash :: Params r -> Int
$chash :: forall r. Hashable r => Params r -> Int
hashWithSalt :: Int -> Params r -> Int
$chashWithSalt :: forall r. Hashable r => Int -> Params r -> Int
Hashable
    )

instance IsString (Params r) where
  fromString :: FilePath -> Params r
fromString = forall r. VarName -> Params r
Param forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IsString a => FilePath -> a
fromString

$(deriveShow1 ''Params)
$(deriveRead1 ''Params)
$(deriveEq1   ''Params)
$(deriveOrd1  ''Params)

deriving instance Hashable1 Params

-- *** lens traversals

$(makeTraversals ''Params)


-- ** data Antiquoted

-- | 'Antiquoted' represents an expression that is either
-- antiquoted (surrounded by ${...}) or plain (not antiquoted).
data Antiquoted (v :: Type) (r :: Type)
  = Plain !v
  | EscapedNewline
  -- ^ 'EscapedNewline' corresponds to the special newline form
  --
  -- > ''\n
  --
  -- in an indented string. It is equivalent to a single newline character:
  --
  -- > ''''\n''  ≡  "\n"
  | Antiquoted !r
  deriving
    ( Antiquoted v r -> Antiquoted v r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall v r.
(Eq v, Eq r) =>
Antiquoted v r -> Antiquoted v r -> Bool
/= :: Antiquoted v r -> Antiquoted v r -> Bool
$c/= :: forall v r.
(Eq v, Eq r) =>
Antiquoted v r -> Antiquoted v r -> Bool
== :: Antiquoted v r -> Antiquoted v r -> Bool
$c== :: forall v r.
(Eq v, Eq r) =>
Antiquoted v r -> Antiquoted v r -> Bool
Eq, Antiquoted v r -> Antiquoted v r -> Bool
Antiquoted v r -> Antiquoted v r -> Ordering
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
forall {v} {r}. (Ord v, Ord r) => Eq (Antiquoted v r)
forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Bool
forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Ordering
forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Antiquoted v r
min :: Antiquoted v r -> Antiquoted v r -> Antiquoted v r
$cmin :: forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Antiquoted v r
max :: Antiquoted v r -> Antiquoted v r -> Antiquoted v r
$cmax :: forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Antiquoted v r
>= :: Antiquoted v r -> Antiquoted v r -> Bool
$c>= :: forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Bool
> :: Antiquoted v r -> Antiquoted v r -> Bool
$c> :: forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Bool
<= :: Antiquoted v r -> Antiquoted v r -> Bool
$c<= :: forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Bool
< :: Antiquoted v r -> Antiquoted v r -> Bool
$c< :: forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Bool
compare :: Antiquoted v r -> Antiquoted v r -> Ordering
$ccompare :: forall v r.
(Ord v, Ord r) =>
Antiquoted v r -> Antiquoted v r -> Ordering
Ord, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v r x. Rep (Antiquoted v r) x -> Antiquoted v r
forall v r x. Antiquoted v r -> Rep (Antiquoted v r) x
$cto :: forall v r x. Rep (Antiquoted v r) x -> Antiquoted v r
$cfrom :: forall v r x. Antiquoted v r -> Rep (Antiquoted v r) x
Generic, forall v a. Rep1 (Antiquoted v) a -> Antiquoted v a
forall v a. Antiquoted v a -> Rep1 (Antiquoted v) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall v a. Rep1 (Antiquoted v) a -> Antiquoted v a
$cfrom1 :: forall v a. Antiquoted v a -> Rep1 (Antiquoted v) a
Generic1
    , Typeable, Antiquoted v r -> DataType
Antiquoted v r -> Constr
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall {v} {r}. (Data v, Data r) => Typeable (Antiquoted v r)
forall v r. (Data v, Data r) => Antiquoted v r -> DataType
forall v r. (Data v, Data r) => Antiquoted v r -> Constr
forall v r.
(Data v, Data r) =>
(forall b. Data b => b -> b) -> Antiquoted v r -> Antiquoted v r
forall v r u.
(Data v, Data r) =>
Int -> (forall d. Data d => d -> u) -> Antiquoted v r -> u
forall v r u.
(Data v, Data r) =>
(forall d. Data d => d -> u) -> Antiquoted v r -> [u]
forall v r r r'.
(Data v, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r
forall v r r r'.
(Data v, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r
forall v r (m :: * -> *).
(Data v, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (Antiquoted v r)
forall v r (m :: * -> *).
(Data v, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (Antiquoted v r)
forall v r (c :: * -> *).
(Data v, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Antiquoted v r)
forall v r (c :: * -> *).
(Data v, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Antiquoted v r -> c (Antiquoted v r)
forall v r (t :: * -> *) (c :: * -> *).
(Data v, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Antiquoted v r))
forall v r (t :: * -> * -> *) (c :: * -> *).
(Data v, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Antiquoted v r))
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Antiquoted v r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Antiquoted v r -> c (Antiquoted v r)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Antiquoted v r))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (Antiquoted v r)
$cgmapMo :: forall v r (m :: * -> *).
(Data v, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (Antiquoted v r)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (Antiquoted v r)
$cgmapMp :: forall v r (m :: * -> *).
(Data v, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (Antiquoted v r)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (Antiquoted v r)
$cgmapM :: forall v r (m :: * -> *).
(Data v, Data r, Monad m) =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (Antiquoted v r)
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Antiquoted v r -> u
$cgmapQi :: forall v r u.
(Data v, Data r) =>
Int -> (forall d. Data d => d -> u) -> Antiquoted v r -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Antiquoted v r -> [u]
$cgmapQ :: forall v r u.
(Data v, Data r) =>
(forall d. Data d => d -> u) -> Antiquoted v r -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r
$cgmapQr :: forall v r r r'.
(Data v, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r
$cgmapQl :: forall v r r r'.
(Data v, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r
gmapT :: (forall b. Data b => b -> b) -> Antiquoted v r -> Antiquoted v r
$cgmapT :: forall v r.
(Data v, Data r) =>
(forall b. Data b => b -> b) -> Antiquoted v r -> Antiquoted v r
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Antiquoted v r))
$cdataCast2 :: forall v r (t :: * -> * -> *) (c :: * -> *).
(Data v, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Antiquoted v r))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Antiquoted v r))
$cdataCast1 :: forall v r (t :: * -> *) (c :: * -> *).
(Data v, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Antiquoted v r))
dataTypeOf :: Antiquoted v r -> DataType
$cdataTypeOf :: forall v r. (Data v, Data r) => Antiquoted v r -> DataType
toConstr :: Antiquoted v r -> Constr
$ctoConstr :: forall v r. (Data v, Data r) => Antiquoted v r -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Antiquoted v r)
$cgunfold :: forall v r (c :: * -> *).
(Data v, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Antiquoted v r)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Antiquoted v r -> c (Antiquoted v r)
$cgfoldl :: forall v r (c :: * -> *).
(Data v, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Antiquoted v r -> c (Antiquoted v r)
Data, forall a. (a -> ()) -> NFData a
forall v r. (NFData v, NFData r) => Antiquoted v r -> ()
rnf :: Antiquoted v r -> ()
$crnf :: forall v r. (NFData v, NFData r) => Antiquoted v r -> ()
NFData, forall v a. NFData v => (a -> ()) -> Antiquoted v a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: forall a. (a -> ()) -> Antiquoted v a -> ()
$cliftRnf :: forall v a. NFData v => (a -> ()) -> Antiquoted v a -> ()
NFData1, forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
forall v r.
(Serialise v, Serialise r) =>
[Antiquoted v r] -> Encoding
forall v r.
(Serialise v, Serialise r) =>
Antiquoted v r -> Encoding
forall v r s.
(Serialise v, Serialise r) =>
Decoder s [Antiquoted v r]
forall v r s.
(Serialise v, Serialise r) =>
Decoder s (Antiquoted v r)
decodeList :: forall s. Decoder s [Antiquoted v r]
$cdecodeList :: forall v r s.
(Serialise v, Serialise r) =>
Decoder s [Antiquoted v r]
encodeList :: [Antiquoted v r] -> Encoding
$cencodeList :: forall v r.
(Serialise v, Serialise r) =>
[Antiquoted v r] -> Encoding
decode :: forall s. Decoder s (Antiquoted v r)
$cdecode :: forall v r s.
(Serialise v, Serialise r) =>
Decoder s (Antiquoted v r)
encode :: Antiquoted v r -> Encoding
$cencode :: forall v r.
(Serialise v, Serialise r) =>
Antiquoted v r -> Encoding
Serialise, forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
forall v r. (Binary v, Binary r) => Get (Antiquoted v r)
forall v r. (Binary v, Binary r) => [Antiquoted v r] -> Put
forall v r. (Binary v, Binary r) => Antiquoted v r -> Put
putList :: [Antiquoted v r] -> Put
$cputList :: forall v r. (Binary v, Binary r) => [Antiquoted v r] -> Put
get :: Get (Antiquoted v r)
$cget :: forall v r. (Binary v, Binary r) => Get (Antiquoted v r)
put :: Antiquoted v r -> Put
$cput :: forall v r. (Binary v, Binary r) => Antiquoted v r -> Put
Binary
    , forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
forall v r. (ToJSON r, ToJSON v) => [Antiquoted v r] -> Encoding
forall v r. (ToJSON r, ToJSON v) => [Antiquoted v r] -> Value
forall v r. (ToJSON r, ToJSON v) => Antiquoted v r -> Encoding
forall v r. (ToJSON r, ToJSON v) => Antiquoted v r -> Value
toEncodingList :: [Antiquoted v r] -> Encoding
$ctoEncodingList :: forall v r. (ToJSON r, ToJSON v) => [Antiquoted v r] -> Encoding
toJSONList :: [Antiquoted v r] -> Value
$ctoJSONList :: forall v r. (ToJSON r, ToJSON v) => [Antiquoted v r] -> Value
toEncoding :: Antiquoted v r -> Encoding
$ctoEncoding :: forall v r. (ToJSON r, ToJSON v) => Antiquoted v r -> Encoding
toJSON :: Antiquoted v r -> Value
$ctoJSON :: forall v r. (ToJSON r, ToJSON v) => Antiquoted v r -> Value
ToJSON, forall v a.
ToJSON v =>
(a -> Encoding)
-> ([a] -> Encoding) -> [Antiquoted v a] -> Encoding
forall v a.
ToJSON v =>
(a -> Encoding) -> ([a] -> Encoding) -> Antiquoted v a -> Encoding
forall v a.
ToJSON v =>
(a -> Value) -> ([a] -> Value) -> [Antiquoted v a] -> Value
forall v a.
ToJSON v =>
(a -> Value) -> ([a] -> Value) -> Antiquoted v a -> Value
forall (f :: * -> *).
(forall a. (a -> Value) -> ([a] -> Value) -> f a -> Value)
-> (forall a. (a -> Value) -> ([a] -> Value) -> [f a] -> Value)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding)
-> ToJSON1 f
liftToEncodingList :: forall a.
(a -> Encoding)
-> ([a] -> Encoding) -> [Antiquoted v a] -> Encoding
$cliftToEncodingList :: forall v a.
ToJSON v =>
(a -> Encoding)
-> ([a] -> Encoding) -> [Antiquoted v a] -> Encoding
liftToEncoding :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> Antiquoted v a -> Encoding
$cliftToEncoding :: forall v a.
ToJSON v =>
(a -> Encoding) -> ([a] -> Encoding) -> Antiquoted v a -> Encoding
liftToJSONList :: forall a.
(a -> Value) -> ([a] -> Value) -> [Antiquoted v a] -> Value
$cliftToJSONList :: forall v a.
ToJSON v =>
(a -> Value) -> ([a] -> Value) -> [Antiquoted v a] -> Value
liftToJSON :: forall a. (a -> Value) -> ([a] -> Value) -> Antiquoted v a -> Value
$cliftToJSON :: forall v a.
ToJSON v =>
(a -> Value) -> ([a] -> Value) -> Antiquoted v a -> Value
ToJSON1, forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
forall v r.
(FromJSON r, FromJSON v) =>
Value -> Parser [Antiquoted v r]
forall v r.
(FromJSON r, FromJSON v) =>
Value -> Parser (Antiquoted v r)
parseJSONList :: Value -> Parser [Antiquoted v r]
$cparseJSONList :: forall v r.
(FromJSON r, FromJSON v) =>
Value -> Parser [Antiquoted v r]
parseJSON :: Value -> Parser (Antiquoted v r)
$cparseJSON :: forall v r.
(FromJSON r, FromJSON v) =>
Value -> Parser (Antiquoted v r)
FromJSON, forall v a.
FromJSON v =>
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [Antiquoted v a]
forall v a.
FromJSON v =>
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (Antiquoted v a)
forall (f :: * -> *).
(forall a.
 (Value -> Parser a)
 -> (Value -> Parser [a]) -> Value -> Parser (f a))
-> (forall a.
    (Value -> Parser a)
    -> (Value -> Parser [a]) -> Value -> Parser [f a])
-> FromJSON1 f
liftParseJSONList :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [Antiquoted v a]
$cliftParseJSONList :: forall v a.
FromJSON v =>
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [Antiquoted v a]
liftParseJSON :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (Antiquoted v a)
$cliftParseJSON :: forall v a.
FromJSON v =>
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (Antiquoted v a)
FromJSON1
    , forall a b. a -> Antiquoted v b -> Antiquoted v a
forall a b. (a -> b) -> Antiquoted v a -> Antiquoted v b
forall v a b. a -> Antiquoted v b -> Antiquoted v a
forall v a b. (a -> b) -> Antiquoted v a -> Antiquoted v b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Antiquoted v b -> Antiquoted v a
$c<$ :: forall v a b. a -> Antiquoted v b -> Antiquoted v a
fmap :: forall a b. (a -> b) -> Antiquoted v a -> Antiquoted v b
$cfmap :: forall v a b. (a -> b) -> Antiquoted v a -> Antiquoted v b
Functor, forall a. Antiquoted v a -> Bool
forall v a. Eq a => a -> Antiquoted v a -> Bool
forall v a. Num a => Antiquoted v a -> a
forall v a. Ord a => Antiquoted v a -> a
forall m a. Monoid m => (a -> m) -> Antiquoted v a -> m
forall v m. Monoid m => Antiquoted v m -> m
forall v a. Antiquoted v a -> Bool
forall v a. Antiquoted v a -> Int
forall v a. Antiquoted v a -> [a]
forall a b. (a -> b -> b) -> b -> Antiquoted v a -> b
forall v a. (a -> a -> a) -> Antiquoted v a -> a
forall v m a. Monoid m => (a -> m) -> Antiquoted v a -> m
forall v b a. (b -> a -> b) -> b -> Antiquoted v a -> b
forall v a b. (a -> b -> b) -> b -> Antiquoted v a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Antiquoted v a -> a
$cproduct :: forall v a. Num a => Antiquoted v a -> a
sum :: forall a. Num a => Antiquoted v a -> a
$csum :: forall v a. Num a => Antiquoted v a -> a
minimum :: forall a. Ord a => Antiquoted v a -> a
$cminimum :: forall v a. Ord a => Antiquoted v a -> a
maximum :: forall a. Ord a => Antiquoted v a -> a
$cmaximum :: forall v a. Ord a => Antiquoted v a -> a
elem :: forall a. Eq a => a -> Antiquoted v a -> Bool
$celem :: forall v a. Eq a => a -> Antiquoted v a -> Bool
length :: forall a. Antiquoted v a -> Int
$clength :: forall v a. Antiquoted v a -> Int
null :: forall a. Antiquoted v a -> Bool
$cnull :: forall v a. Antiquoted v a -> Bool
toList :: forall a. Antiquoted v a -> [a]
$ctoList :: forall v a. Antiquoted v a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Antiquoted v a -> a
$cfoldl1 :: forall v a. (a -> a -> a) -> Antiquoted v a -> a
foldr1 :: forall a. (a -> a -> a) -> Antiquoted v a -> a
$cfoldr1 :: forall v a. (a -> a -> a) -> Antiquoted v a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Antiquoted v a -> b
$cfoldl' :: forall v b a. (b -> a -> b) -> b -> Antiquoted v a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Antiquoted v a -> b
$cfoldl :: forall v b a. (b -> a -> b) -> b -> Antiquoted v a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Antiquoted v a -> b
$cfoldr' :: forall v a b. (a -> b -> b) -> b -> Antiquoted v a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Antiquoted v a -> b
$cfoldr :: forall v a b. (a -> b -> b) -> b -> Antiquoted v a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Antiquoted v a -> m
$cfoldMap' :: forall v m a. Monoid m => (a -> m) -> Antiquoted v a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Antiquoted v a -> m
$cfoldMap :: forall v m a. Monoid m => (a -> m) -> Antiquoted v a -> m
fold :: forall m. Monoid m => Antiquoted v m -> m
$cfold :: forall v m. Monoid m => Antiquoted v m -> m
Foldable, forall v. Functor (Antiquoted v)
forall v. Foldable (Antiquoted v)
forall v (m :: * -> *) a.
Monad m =>
Antiquoted v (m a) -> m (Antiquoted v a)
forall v (f :: * -> *) a.
Applicative f =>
Antiquoted v (f a) -> f (Antiquoted v a)
forall v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Antiquoted v a -> m (Antiquoted v b)
forall v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Antiquoted v a -> f (Antiquoted v b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Antiquoted v a -> f (Antiquoted v b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Antiquoted v (m a) -> m (Antiquoted v a)
$csequence :: forall v (m :: * -> *) a.
Monad m =>
Antiquoted v (m a) -> m (Antiquoted v a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Antiquoted v a -> m (Antiquoted v b)
$cmapM :: forall v (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Antiquoted v a -> m (Antiquoted v b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Antiquoted v (f a) -> f (Antiquoted v a)
$csequenceA :: forall v (f :: * -> *) a.
Applicative f =>
Antiquoted v (f a) -> f (Antiquoted v a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Antiquoted v a -> f (Antiquoted v b)
$ctraverse :: forall v (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Antiquoted v a -> f (Antiquoted v b)
Traversable
    , Int -> Antiquoted v r -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
forall v r. (Show v, Show r) => Int -> Antiquoted v r -> ShowS
forall v r. (Show v, Show r) => [Antiquoted v r] -> ShowS
forall v r. (Show v, Show r) => Antiquoted v r -> FilePath
showList :: [Antiquoted v r] -> ShowS
$cshowList :: forall v r. (Show v, Show r) => [Antiquoted v r] -> ShowS
show :: Antiquoted v r -> FilePath
$cshow :: forall v r. (Show v, Show r) => Antiquoted v r -> FilePath
showsPrec :: Int -> Antiquoted v r -> ShowS
$cshowsPrec :: forall v r. (Show v, Show r) => Int -> Antiquoted v r -> ShowS
Show, ReadPrec [Antiquoted v r]
ReadPrec (Antiquoted v r)
ReadS [Antiquoted v r]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall v r. (Read v, Read r) => ReadPrec [Antiquoted v r]
forall v r. (Read v, Read r) => ReadPrec (Antiquoted v r)
forall v r. (Read v, Read r) => Int -> ReadS (Antiquoted v r)
forall v r. (Read v, Read r) => ReadS [Antiquoted v r]
readListPrec :: ReadPrec [Antiquoted v r]
$creadListPrec :: forall v r. (Read v, Read r) => ReadPrec [Antiquoted v r]
readPrec :: ReadPrec (Antiquoted v r)
$creadPrec :: forall v r. (Read v, Read r) => ReadPrec (Antiquoted v r)
readList :: ReadS [Antiquoted v r]
$creadList :: forall v r. (Read v, Read r) => ReadS [Antiquoted v r]
readsPrec :: Int -> ReadS (Antiquoted v r)
$creadsPrec :: forall v r. (Read v, Read r) => Int -> ReadS (Antiquoted v r)
Read, forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall {v} {r}. (Hashable v, Hashable r) => Eq (Antiquoted v r)
forall v r.
(Hashable v, Hashable r) =>
Int -> Antiquoted v r -> Int
forall v r. (Hashable v, Hashable r) => Antiquoted v r -> Int
hash :: Antiquoted v r -> Int
$chash :: forall v r. (Hashable v, Hashable r) => Antiquoted v r -> Int
hashWithSalt :: Int -> Antiquoted v r -> Int
$chashWithSalt :: forall v r.
(Hashable v, Hashable r) =>
Int -> Antiquoted v r -> Int
Hashable
    )

$(deriveShow1 ''Antiquoted)
$(deriveShow2 ''Antiquoted)
$(deriveRead1 ''Antiquoted)
$(deriveRead2 ''Antiquoted)
$(deriveEq1   ''Antiquoted)
$(deriveEq2   ''Antiquoted)
$(deriveOrd1  ''Antiquoted)
$(deriveOrd2  ''Antiquoted)
$(deriveJSON2 defaultOptions ''Antiquoted)

instance Hashable2 Antiquoted where
  liftHashWithSalt2 :: forall a b.
(Int -> a -> Int)
-> (Int -> b -> Int) -> Int -> Antiquoted a b -> Int
liftHashWithSalt2 Int -> a -> Int
ha Int -> b -> Int
_  Int
salt (Plain a
a)      = Int -> a -> Int
ha (Int
salt forall a. Hashable a => Int -> a -> Int
`hashWithSalt` (Int
0 :: Int)) a
a
  liftHashWithSalt2 Int -> a -> Int
_  Int -> b -> Int
_  Int
salt Antiquoted a b
EscapedNewline =     Int
salt forall a. Hashable a => Int -> a -> Int
`hashWithSalt` (Int
1 :: Int)
  liftHashWithSalt2 Int -> a -> Int
_  Int -> b -> Int
hb Int
salt (Antiquoted b
b) = Int -> b -> Int
hb (Int
salt forall a. Hashable a => Int -> a -> Int
`hashWithSalt` (Int
2 :: Int)) b
b

deriving instance (Hashable v) => Hashable1 (Antiquoted (v :: Type))

-- *** lens traversals

$(makeTraversals ''Antiquoted)


-- ** data NString

-- | An 'NString' is a list of things that are either a plain string
-- or an antiquoted expression. After the antiquotes have been evaluated,
-- the final string is constructed by concatenating all the parts.
data NString r
  = DoubleQuoted ![Antiquoted Text r]
  -- ^ Strings wrapped with double-quotes (__@"@__) can contain literal newline
  -- characters, but the newlines are preserved and no indentation is stripped.
  --
  -- > DoubleQuoted [Plain "x",Antiquoted y]   ~  "x${y}"
  | Indented !Int ![Antiquoted Text r]
  -- ^ Strings wrapped with two single quotes (__@''@__) can contain newlines, and
  --   their indentation will be stripped, but the amount stripped is
  --   remembered.
  --
  -- > Indented 1 [Plain "x"]                  ~  '' x''
  -- >
  -- > Indented 0 [EscapedNewline]             ~  ''''\n''
  -- >
  -- > Indented 0 [Plain "x\n ",Antiquoted y]  ~  ''
  -- >                                            x
  -- >                                             ${y}''
  deriving
    ( NString r -> NString r -> Bool
forall r. Eq r => NString r -> NString r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NString r -> NString r -> Bool
$c/= :: forall r. Eq r => NString r -> NString r -> Bool
== :: NString r -> NString r -> Bool
$c== :: forall r. Eq r => NString r -> NString r -> Bool
Eq, NString r -> NString r -> Bool
NString r -> NString r -> Ordering
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
forall {r}. Ord r => Eq (NString r)
forall r. Ord r => NString r -> NString r -> Bool
forall r. Ord r => NString r -> NString r -> Ordering
forall r. Ord r => NString r -> NString r -> NString r
min :: NString r -> NString r -> NString r
$cmin :: forall r. Ord r => NString r -> NString r -> NString r
max :: NString r -> NString r -> NString r
$cmax :: forall r. Ord r => NString r -> NString r -> NString r
>= :: NString r -> NString r -> Bool
$c>= :: forall r. Ord r => NString r -> NString r -> Bool
> :: NString r -> NString r -> Bool
$c> :: forall r. Ord r => NString r -> NString r -> Bool
<= :: NString r -> NString r -> Bool
$c<= :: forall r. Ord r => NString r -> NString r -> Bool
< :: NString r -> NString r -> Bool
$c< :: forall r. Ord r => NString r -> NString r -> Bool
compare :: NString r -> NString r -> Ordering
$ccompare :: forall r. Ord r => NString r -> NString r -> Ordering
Ord, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (NString r) x -> NString r
forall r x. NString r -> Rep (NString r) x
$cto :: forall r x. Rep (NString r) x -> NString r
$cfrom :: forall r x. NString r -> Rep (NString r) x
Generic, forall a. Rep1 NString a -> NString a
forall a. NString a -> Rep1 NString a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall a. Rep1 NString a -> NString a
$cfrom1 :: forall a. NString a -> Rep1 NString a
Generic1
    , Typeable, NString r -> DataType
NString r -> Constr
forall {r}. Data r => Typeable (NString r)
forall r. Data r => NString r -> DataType
forall r. Data r => NString r -> Constr
forall r.
Data r =>
(forall b. Data b => b -> b) -> NString r -> NString r
forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> NString r -> u
forall r u.
Data r =>
(forall d. Data d => d -> u) -> NString r -> [u]
forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NString r -> r
forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NString r -> r
forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NString r)
forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NString r -> c (NString r)
forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NString r))
forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NString r))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NString r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NString r -> c (NString r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NString r))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
$cgmapMo :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
$cgmapMp :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
$cgmapM :: forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NString r -> u
$cgmapQi :: forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> NString r -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NString r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> NString r -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NString r -> r
$cgmapQr :: forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NString r -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NString r -> r
$cgmapQl :: forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NString r -> r
gmapT :: (forall b. Data b => b -> b) -> NString r -> NString r
$cgmapT :: forall r.
Data r =>
(forall b. Data b => b -> b) -> NString r -> NString r
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NString r))
$cdataCast2 :: forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NString r))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NString r))
$cdataCast1 :: forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NString r))
dataTypeOf :: NString r -> DataType
$cdataTypeOf :: forall r. Data r => NString r -> DataType
toConstr :: NString r -> Constr
$ctoConstr :: forall r. Data r => NString r -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NString r)
$cgunfold :: forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NString r)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NString r -> c (NString r)
$cgfoldl :: forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NString r -> c (NString r)
Data, forall r. NFData r => NString r -> ()
forall a. (a -> ()) -> NFData a
rnf :: NString r -> ()
$crnf :: forall r. NFData r => NString r -> ()
NFData, forall a. (a -> ()) -> NString a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: forall a. (a -> ()) -> NString a -> ()
$cliftRnf :: forall a. (a -> ()) -> NString a -> ()
NFData1, forall r. Serialise r => [NString r] -> Encoding
forall r. Serialise r => NString r -> Encoding
forall r s. Serialise r => Decoder s [NString r]
forall r s. Serialise r => Decoder s (NString r)
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [NString r]
$cdecodeList :: forall r s. Serialise r => Decoder s [NString r]
encodeList :: [NString r] -> Encoding
$cencodeList :: forall r. Serialise r => [NString r] -> Encoding
decode :: forall s. Decoder s (NString r)
$cdecode :: forall r s. Serialise r => Decoder s (NString r)
encode :: NString r -> Encoding
$cencode :: forall r. Serialise r => NString r -> Encoding
Serialise, forall r. Binary r => Get (NString r)
forall r. Binary r => [NString r] -> Put
forall r. Binary r => NString r -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [NString r] -> Put
$cputList :: forall r. Binary r => [NString r] -> Put
get :: Get (NString r)
$cget :: forall r. Binary r => Get (NString r)
put :: NString r -> Put
$cput :: forall r. Binary r => NString r -> Put
Binary, forall r. ToJSON r => [NString r] -> Encoding
forall r. ToJSON r => [NString r] -> Value
forall r. ToJSON r => NString r -> Encoding
forall r. ToJSON r => NString r -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [NString r] -> Encoding
$ctoEncodingList :: forall r. ToJSON r => [NString r] -> Encoding
toJSONList :: [NString r] -> Value
$ctoJSONList :: forall r. ToJSON r => [NString r] -> Value
toEncoding :: NString r -> Encoding
$ctoEncoding :: forall r. ToJSON r => NString r -> Encoding
toJSON :: NString r -> Value
$ctoJSON :: forall r. ToJSON r => NString r -> Value
ToJSON, forall a.
(a -> Encoding) -> ([a] -> Encoding) -> [NString a] -> Encoding
forall a.
(a -> Encoding) -> ([a] -> Encoding) -> NString a -> Encoding
forall a. (a -> Value) -> ([a] -> Value) -> [NString a] -> Value
forall a. (a -> Value) -> ([a] -> Value) -> NString a -> Value
forall (f :: * -> *).
(forall a. (a -> Value) -> ([a] -> Value) -> f a -> Value)
-> (forall a. (a -> Value) -> ([a] -> Value) -> [f a] -> Value)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> f a -> Encoding)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> [f a] -> Encoding)
-> ToJSON1 f
liftToEncodingList :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> [NString a] -> Encoding
$cliftToEncodingList :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> [NString a] -> Encoding
liftToEncoding :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> NString a -> Encoding
$cliftToEncoding :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> NString a -> Encoding
liftToJSONList :: forall a. (a -> Value) -> ([a] -> Value) -> [NString a] -> Value
$cliftToJSONList :: forall a. (a -> Value) -> ([a] -> Value) -> [NString a] -> Value
liftToJSON :: forall a. (a -> Value) -> ([a] -> Value) -> NString a -> Value
$cliftToJSON :: forall a. (a -> Value) -> ([a] -> Value) -> NString a -> Value
ToJSON1, forall r. FromJSON r => Value -> Parser [NString r]
forall r. FromJSON r => Value -> Parser (NString r)
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NString r]
$cparseJSONList :: forall r. FromJSON r => Value -> Parser [NString r]
parseJSON :: Value -> Parser (NString r)
$cparseJSON :: forall r. FromJSON r => Value -> Parser (NString r)
FromJSON, forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [NString a]
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (NString a)
forall (f :: * -> *).
(forall a.
 (Value -> Parser a)
 -> (Value -> Parser [a]) -> Value -> Parser (f a))
-> (forall a.
    (Value -> Parser a)
    -> (Value -> Parser [a]) -> Value -> Parser [f a])
-> FromJSON1 f
liftParseJSONList :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [NString a]
$cliftParseJSONList :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [NString a]
liftParseJSON :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (NString a)
$cliftParseJSON :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (NString a)
FromJSON1
    , forall a b. a -> NString b -> NString a
forall a b. (a -> b) -> NString a -> NString b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> NString b -> NString a
$c<$ :: forall a b. a -> NString b -> NString a
fmap :: forall a b. (a -> b) -> NString a -> NString b
$cfmap :: forall a b. (a -> b) -> NString a -> NString b
Functor, forall a. Eq a => a -> NString a -> Bool
forall a. Num a => NString a -> a
forall a. Ord a => NString a -> a
forall m. Monoid m => NString m -> m
forall a. NString a -> Bool
forall a. NString a -> Int
forall a. NString a -> [a]
forall a. (a -> a -> a) -> NString a -> a
forall m a. Monoid m => (a -> m) -> NString a -> m
forall b a. (b -> a -> b) -> b -> NString a -> b
forall a b. (a -> b -> b) -> b -> NString a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => NString a -> a
$cproduct :: forall a. Num a => NString a -> a
sum :: forall a. Num a => NString a -> a
$csum :: forall a. Num a => NString a -> a
minimum :: forall a. Ord a => NString a -> a
$cminimum :: forall a. Ord a => NString a -> a
maximum :: forall a. Ord a => NString a -> a
$cmaximum :: forall a. Ord a => NString a -> a
elem :: forall a. Eq a => a -> NString a -> Bool
$celem :: forall a. Eq a => a -> NString a -> Bool
length :: forall a. NString a -> Int
$clength :: forall a. NString a -> Int
null :: forall a. NString a -> Bool
$cnull :: forall a. NString a -> Bool
toList :: forall a. NString a -> [a]
$ctoList :: forall a. NString a -> [a]
foldl1 :: forall a. (a -> a -> a) -> NString a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NString a -> a
foldr1 :: forall a. (a -> a -> a) -> NString a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> NString a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> NString a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NString a -> b
foldl :: forall b a. (b -> a -> b) -> b -> NString a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NString a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> NString a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NString a -> b
foldr :: forall a b. (a -> b -> b) -> b -> NString a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> NString a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> NString a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NString a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> NString a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NString a -> m
fold :: forall m. Monoid m => NString m -> m
$cfold :: forall m. Monoid m => NString m -> m
Foldable, Functor NString
Foldable NString
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => NString (m a) -> m (NString a)
forall (f :: * -> *) a.
Applicative f =>
NString (f a) -> f (NString a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NString a -> m (NString b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NString a -> f (NString b)
sequence :: forall (m :: * -> *) a. Monad m => NString (m a) -> m (NString a)
$csequence :: forall (m :: * -> *) a. Monad m => NString (m a) -> m (NString a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NString a -> m (NString b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NString a -> m (NString b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
NString (f a) -> f (NString a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
NString (f a) -> f (NString a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NString a -> f (NString b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NString a -> f (NString b)
Traversable
    , Int -> NString r -> ShowS
forall r. Show r => Int -> NString r -> ShowS
forall r. Show r => [NString r] -> ShowS
forall r. Show r => NString r -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [NString r] -> ShowS
$cshowList :: forall r. Show r => [NString r] -> ShowS
show :: NString r -> FilePath
$cshow :: forall r. Show r => NString r -> FilePath
showsPrec :: Int -> NString r -> ShowS
$cshowsPrec :: forall r. Show r => Int -> NString r -> ShowS
Show, ReadPrec [NString r]
ReadPrec (NString r)
ReadS [NString r]
forall r. Read r => ReadPrec [NString r]
forall r. Read r => ReadPrec (NString r)
forall r. Read r => Int -> ReadS (NString r)
forall r. Read r => ReadS [NString r]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NString r]
$creadListPrec :: forall r. Read r => ReadPrec [NString r]
readPrec :: ReadPrec (NString r)
$creadPrec :: forall r. Read r => ReadPrec (NString r)
readList :: ReadS [NString r]
$creadList :: forall r. Read r => ReadS [NString r]
readsPrec :: Int -> ReadS (NString r)
$creadsPrec :: forall r. Read r => Int -> ReadS (NString r)
Read, forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall {r}. Hashable r => Eq (NString r)
forall r. Hashable r => Int -> NString r -> Int
forall r. Hashable r => NString r -> Int
hash :: NString r -> Int
$chash :: forall r. Hashable r => NString r -> Int
hashWithSalt :: Int -> NString r -> Int
$chashWithSalt :: forall r. Hashable r => Int -> NString r -> Int
Hashable
    )

-- | For the the 'IsString' instance, we use a plain doublequoted string.
instance IsString (NString r) where
  fromString :: FilePath -> NString r
fromString FilePath
""     = forall r. [Antiquoted Text r] -> NString r
DoubleQuoted forall a. Monoid a => a
mempty
  fromString FilePath
string = forall r. [Antiquoted Text r] -> NString r
DoubleQuoted forall a b. (a -> b) -> a -> b
$ forall x. One x => OneItem x -> x
one forall a b. (a -> b) -> a -> b
$ forall v r. v -> Antiquoted v r
Plain forall a b. (a -> b) -> a -> b
$ forall a. IsString a => FilePath -> a
fromString FilePath
string

$(deriveShow1 ''NString)
$(deriveRead1 ''NString)
$(deriveEq1   ''NString)
$(deriveOrd1  ''NString)

deriving instance Hashable1 NString

-- *** lens traversals

$(makeTraversals ''NString)


-- ** data NKeyName

-- | A 'KeyName' is something that can appear on the left side of an
-- equals sign. For example, @a@ is a 'KeyName' in @{ a = 3; }@, @let a = 3;
-- in ...@, @{}.a@ or @{} ? a@.
--
-- Nix supports both static keynames (just an identifier) and dynamic
-- identifiers. Dynamic identifiers can be either a string (e.g.:
-- @{ "a" = 3; }@) or an antiquotation (e.g.: @let a = "example";
-- in { ${a} = 3; }.example@).
--
-- Note: There are some places where a dynamic keyname is not allowed.
-- In particular, those include:
--
--   * The RHS of a @binding@ inside @let@: @let ${"a"} = 3; in ...@
--     produces a syntax fail.
--   * The attribute names of an 'inherit': @inherit ${"a"};@ is forbidden.
--
-- Note: In Nix, a simple string without antiquotes such as @"foo"@ is
-- allowed even if the context requires a static keyname, but the
-- parser still considers it a 'DynamicKey' for simplicity.
data NKeyName r
  = DynamicKey !(Antiquoted (NString r) r)
  -- ^
  -- > DynamicKey (Plain (DoubleQuoted [Plain "x"]))     ~  "x"
  -- > DynamicKey (Antiquoted x)                         ~  ${x}
  -- > DynamicKey (Plain (DoubleQuoted [Antiquoted x]))  ~  "${x}"
  | StaticKey !VarName
  -- ^
  -- > StaticKey "x"                                     ~  x
  deriving
    ( NKeyName r -> NKeyName r -> Bool
forall r. Eq r => NKeyName r -> NKeyName r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NKeyName r -> NKeyName r -> Bool
$c/= :: forall r. Eq r => NKeyName r -> NKeyName r -> Bool
== :: NKeyName r -> NKeyName r -> Bool
$c== :: forall r. Eq r => NKeyName r -> NKeyName r -> Bool
Eq, NKeyName r -> NKeyName r -> Bool
NKeyName r -> NKeyName r -> Ordering
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
forall {r}. Ord r => Eq (NKeyName r)
forall r. Ord r => NKeyName r -> NKeyName r -> Bool
forall r. Ord r => NKeyName r -> NKeyName r -> Ordering
forall r. Ord r => NKeyName r -> NKeyName r -> NKeyName r
min :: NKeyName r -> NKeyName r -> NKeyName r
$cmin :: forall r. Ord r => NKeyName r -> NKeyName r -> NKeyName r
max :: NKeyName r -> NKeyName r -> NKeyName r
$cmax :: forall r. Ord r => NKeyName r -> NKeyName r -> NKeyName r
>= :: NKeyName r -> NKeyName r -> Bool
$c>= :: forall r. Ord r => NKeyName r -> NKeyName r -> Bool
> :: NKeyName r -> NKeyName r -> Bool
$c> :: forall r. Ord r => NKeyName r -> NKeyName r -> Bool
<= :: NKeyName r -> NKeyName r -> Bool
$c<= :: forall r. Ord r => NKeyName r -> NKeyName r -> Bool
< :: NKeyName r -> NKeyName r -> Bool
$c< :: forall r. Ord r => NKeyName r -> NKeyName r -> Bool
compare :: NKeyName r -> NKeyName r -> Ordering
$ccompare :: forall r. Ord r => NKeyName r -> NKeyName r -> Ordering
Ord, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (NKeyName r) x -> NKeyName r
forall r x. NKeyName r -> Rep (NKeyName r) x
$cto :: forall r x. Rep (NKeyName r) x -> NKeyName r
$cfrom :: forall r x. NKeyName r -> Rep (NKeyName r) x
Generic
    , Typeable, NKeyName r -> DataType
NKeyName r -> Constr
forall {r}. Data r => Typeable (NKeyName r)
forall r. Data r => NKeyName r -> DataType
forall r. Data r => NKeyName r -> Constr
forall r.
Data r =>
(forall b. Data b => b -> b) -> NKeyName r -> NKeyName r
forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> NKeyName r -> u
forall r u.
Data r =>
(forall d. Data d => d -> u) -> NKeyName r -> [u]
forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NKeyName r -> r
forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NKeyName r -> r
forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NKeyName r)
forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NKeyName r -> c (NKeyName r)
forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NKeyName r))
forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NKeyName r))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NKeyName r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NKeyName r -> c (NKeyName r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NKeyName r))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
$cgmapMo :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
$cgmapMp :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
$cgmapM :: forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NKeyName r -> u
$cgmapQi :: forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> NKeyName r -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NKeyName r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> NKeyName r -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NKeyName r -> r
$cgmapQr :: forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NKeyName r -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NKeyName r -> r
$cgmapQl :: forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NKeyName r -> r
gmapT :: (forall b. Data b => b -> b) -> NKeyName r -> NKeyName r
$cgmapT :: forall r.
Data r =>
(forall b. Data b => b -> b) -> NKeyName r -> NKeyName r
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NKeyName r))
$cdataCast2 :: forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NKeyName r))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NKeyName r))
$cdataCast1 :: forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NKeyName r))
dataTypeOf :: NKeyName r -> DataType
$cdataTypeOf :: forall r. Data r => NKeyName r -> DataType
toConstr :: NKeyName r -> Constr
$ctoConstr :: forall r. Data r => NKeyName r -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NKeyName r)
$cgunfold :: forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NKeyName r)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NKeyName r -> c (NKeyName r)
$cgfoldl :: forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NKeyName r -> c (NKeyName r)
Data, forall r. NFData r => NKeyName r -> ()
forall a. (a -> ()) -> NFData a
rnf :: NKeyName r -> ()
$crnf :: forall r. NFData r => NKeyName r -> ()
NFData, forall r. Serialise r => [NKeyName r] -> Encoding
forall r. Serialise r => NKeyName r -> Encoding
forall r s. Serialise r => Decoder s [NKeyName r]
forall r s. Serialise r => Decoder s (NKeyName r)
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [NKeyName r]
$cdecodeList :: forall r s. Serialise r => Decoder s [NKeyName r]
encodeList :: [NKeyName r] -> Encoding
$cencodeList :: forall r. Serialise r => [NKeyName r] -> Encoding
decode :: forall s. Decoder s (NKeyName r)
$cdecode :: forall r s. Serialise r => Decoder s (NKeyName r)
encode :: NKeyName r -> Encoding
$cencode :: forall r. Serialise r => NKeyName r -> Encoding
Serialise, forall r. Binary r => Get (NKeyName r)
forall r. Binary r => [NKeyName r] -> Put
forall r. Binary r => NKeyName r -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [NKeyName r] -> Put
$cputList :: forall r. Binary r => [NKeyName r] -> Put
get :: Get (NKeyName r)
$cget :: forall r. Binary r => Get (NKeyName r)
put :: NKeyName r -> Put
$cput :: forall r. Binary r => NKeyName r -> Put
Binary, forall r. ToJSON r => [NKeyName r] -> Encoding
forall r. ToJSON r => [NKeyName r] -> Value
forall r. ToJSON r => NKeyName r -> Encoding
forall r. ToJSON r => NKeyName r -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [NKeyName r] -> Encoding
$ctoEncodingList :: forall r. ToJSON r => [NKeyName r] -> Encoding
toJSONList :: [NKeyName r] -> Value
$ctoJSONList :: forall r. ToJSON r => [NKeyName r] -> Value
toEncoding :: NKeyName r -> Encoding
$ctoEncoding :: forall r. ToJSON r => NKeyName r -> Encoding
toJSON :: NKeyName r -> Value
$ctoJSON :: forall r. ToJSON r => NKeyName r -> Value
ToJSON, forall r. FromJSON r => Value -> Parser [NKeyName r]
forall r. FromJSON r => Value -> Parser (NKeyName r)
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NKeyName r]
$cparseJSONList :: forall r. FromJSON r => Value -> Parser [NKeyName r]
parseJSON :: Value -> Parser (NKeyName r)
$cparseJSON :: forall r. FromJSON r => Value -> Parser (NKeyName r)
FromJSON
    , Int -> NKeyName r -> ShowS
forall r. Show r => Int -> NKeyName r -> ShowS
forall r. Show r => [NKeyName r] -> ShowS
forall r. Show r => NKeyName r -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [NKeyName r] -> ShowS
$cshowList :: forall r. Show r => [NKeyName r] -> ShowS
show :: NKeyName r -> FilePath
$cshow :: forall r. Show r => NKeyName r -> FilePath
showsPrec :: Int -> NKeyName r -> ShowS
$cshowsPrec :: forall r. Show r => Int -> NKeyName r -> ShowS
Show, ReadPrec [NKeyName r]
ReadPrec (NKeyName r)
ReadS [NKeyName r]
forall r. Read r => ReadPrec [NKeyName r]
forall r. Read r => ReadPrec (NKeyName r)
forall r. Read r => Int -> ReadS (NKeyName r)
forall r. Read r => ReadS [NKeyName r]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NKeyName r]
$creadListPrec :: forall r. Read r => ReadPrec [NKeyName r]
readPrec :: ReadPrec (NKeyName r)
$creadPrec :: forall r. Read r => ReadPrec (NKeyName r)
readList :: ReadS [NKeyName r]
$creadList :: forall r. Read r => ReadS [NKeyName r]
readsPrec :: Int -> ReadS (NKeyName r)
$creadsPrec :: forall r. Read r => Int -> ReadS (NKeyName r)
Read, forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall {r}. Hashable r => Eq (NKeyName r)
forall r. Hashable r => Int -> NKeyName r -> Int
forall r. Hashable r => NKeyName r -> Int
hash :: NKeyName r -> Int
$chash :: forall r. Hashable r => NKeyName r -> Int
hashWithSalt :: Int -> NKeyName r -> Int
$chashWithSalt :: forall r. Hashable r => Int -> NKeyName r -> Int
Hashable
    )

instance NFData1 NKeyName where
  liftRnf :: forall a. (a -> ()) -> NKeyName a -> ()
liftRnf a -> ()
_ (StaticKey  !VarName
_            ) = forall a. Monoid a => a
mempty
  liftRnf a -> ()
_ (DynamicKey (Plain !NString a
_)    ) = forall a. Monoid a => a
mempty
  liftRnf a -> ()
_ (DynamicKey Antiquoted (NString a) a
EscapedNewline) = forall a. Monoid a => a
mempty
  liftRnf a -> ()
k (DynamicKey (Antiquoted a
r)) = a -> ()
k a
r

-- | Most key names are just static text, so this instance is convenient.
instance IsString (NKeyName r) where
  fromString :: FilePath -> NKeyName r
fromString = forall r. VarName -> NKeyName r
StaticKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IsString a => FilePath -> a
fromString

instance Eq1 NKeyName where
  liftEq :: forall a b. (a -> b -> Bool) -> NKeyName a -> NKeyName b -> Bool
liftEq a -> b -> Bool
eq (DynamicKey Antiquoted (NString a) a
a) (DynamicKey Antiquoted (NString b) b
b) = forall (f :: * -> * -> *) a b c d.
Eq2 f =>
(a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
liftEq2 (forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> f a -> f b -> Bool
liftEq a -> b -> Bool
eq) a -> b -> Bool
eq Antiquoted (NString a) a
a Antiquoted (NString b) b
b
  liftEq a -> b -> Bool
_  (StaticKey  VarName
a) (StaticKey  VarName
b) = VarName
a forall a. Eq a => a -> a -> Bool
== VarName
b
  liftEq a -> b -> Bool
_  NKeyName a
_              NKeyName b
_              = Bool
False

-- | @since 0.10.1
instance Ord1 NKeyName where
  liftCompare :: forall a b.
(a -> b -> Ordering) -> NKeyName a -> NKeyName b -> Ordering
liftCompare a -> b -> Ordering
cmp (DynamicKey Antiquoted (NString a) a
a) (DynamicKey Antiquoted (NString b) b
b) = forall (f :: * -> * -> *) a b c d.
Ord2 f =>
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
liftCompare2 (forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering) -> f a -> f b -> Ordering
liftCompare a -> b -> Ordering
cmp) a -> b -> Ordering
cmp Antiquoted (NString a) a
a Antiquoted (NString b) b
b
  liftCompare a -> b -> Ordering
_   (DynamicKey Antiquoted (NString a) a
_) (StaticKey  VarName
_) = Ordering
LT
  liftCompare a -> b -> Ordering
_   (StaticKey  VarName
_) (DynamicKey Antiquoted (NString b) b
_) = Ordering
GT
  liftCompare a -> b -> Ordering
_   (StaticKey  VarName
a) (StaticKey  VarName
b) = forall a. Ord a => a -> a -> Ordering
compare VarName
a VarName
b

instance Hashable1 NKeyName where
  liftHashWithSalt :: forall a. (Int -> a -> Int) -> Int -> NKeyName a -> Int
liftHashWithSalt Int -> a -> Int
h Int
salt (DynamicKey Antiquoted (NString a) a
a) =
    forall (t :: * -> * -> *) a b.
Hashable2 t =>
(Int -> a -> Int) -> (Int -> b -> Int) -> Int -> t a b -> Int
liftHashWithSalt2 (forall (t :: * -> *) a.
Hashable1 t =>
(Int -> a -> Int) -> Int -> t a -> Int
liftHashWithSalt Int -> a -> Int
h) Int -> a -> Int
h (Int
salt forall a. Hashable a => Int -> a -> Int
`hashWithSalt` (Int
0 :: Int)) Antiquoted (NString a) a
a
  liftHashWithSalt Int -> a -> Int
_ Int
salt (StaticKey VarName
n) =
    Int
salt forall a. Hashable a => Int -> a -> Int
`hashWithSalt` (Int
1 :: Int) forall a. Hashable a => Int -> a -> Int
`hashWithSalt` VarName
n

-- Deriving this instance automatically is not possible because @r@
-- occurs not only as last argument in @Antiquoted (NString r) r@
instance Show1 NKeyName where
  liftShowsPrec :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NKeyName a -> ShowS
liftShowsPrec Int -> a -> ShowS
sp [a] -> ShowS
sl Int
p = \case
    DynamicKey Antiquoted (NString a) a
a ->
      forall a. (Int -> a -> ShowS) -> FilePath -> Int -> a -> ShowS
showsUnaryWith
        (forall (f :: * -> * -> *) a b.
Show2 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS)
-> (Int -> b -> ShowS)
-> ([b] -> ShowS)
-> Int
-> f a b
-> ShowS
liftShowsPrec2 (forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
liftShowsPrec Int -> a -> ShowS
sp [a] -> ShowS
sl) (forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS
liftShowList Int -> a -> ShowS
sp [a] -> ShowS
sl) Int -> a -> ShowS
sp [a] -> ShowS
sl)
        FilePath
"DynamicKey"
        Int
p
        Antiquoted (NString a) a
a
    StaticKey VarName
t -> forall a. (Int -> a -> ShowS) -> FilePath -> Int -> a -> ShowS
showsUnaryWith forall a. Show a => Int -> a -> ShowS
Text.Show.showsPrec FilePath
"StaticKey" Int
p VarName
t

-- Deriving this instance automatically is not possible because @r@
-- occurs not only as last argument in @Antiquoted (NString r) r@
instance Functor NKeyName where
  fmap :: forall a b. (a -> b) -> NKeyName a -> NKeyName b
fmap = forall (t :: * -> *) a b. Traversable t => (a -> b) -> t a -> t b
fmapDefault

-- Deriving this instance automatically is not possible because @r@
-- occurs not only as last argument in @Antiquoted (NString r) r@
instance Foldable NKeyName where
  foldMap :: forall m a. Monoid m => (a -> m) -> NKeyName a -> m
foldMap = forall (t :: * -> *) m a.
(Traversable t, Monoid m) =>
(a -> m) -> t a -> m
foldMapDefault

-- Deriving this instance automatically is not possible because @r@
-- occurs not only as last argument in @Antiquoted (NString r) r@
instance Traversable NKeyName where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NKeyName a -> f (NKeyName b)
traverse a -> f b
f = \case
    DynamicKey (Plain      NString a
str) -> forall r. Antiquoted (NString r) r -> NKeyName r
DynamicKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v r. v -> Antiquoted v r
Plain 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 a -> f b
f NString a
str
    DynamicKey (Antiquoted a
e  ) -> forall r. Antiquoted (NString r) r -> NKeyName r
DynamicKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v r. r -> Antiquoted v r
Antiquoted forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
e
    DynamicKey Antiquoted (NString a) a
EscapedNewline   -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall r. Antiquoted (NString r) r -> NKeyName r
DynamicKey forall v r. Antiquoted v r
EscapedNewline
    StaticKey  VarName
key              -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall r. VarName -> NKeyName r
StaticKey VarName
key

-- *** lens traversals

$(makeTraversals ''NKeyName)


-- ** type NAttrPath

-- | A selector (for example in a @let@ or an attribute set) is made up
-- of strung-together key names.
--
-- > StaticKey "x" :| [DynamicKey (Antiquoted y)]  ~  x.${y}
type NAttrPath r = NonEmpty (NKeyName r)


-- ** data Binding

#if !MIN_VERSION_hashable(1,3,1)
-- Required by Hashable Binding deriving. There was none of this Hashable instance before mentioned version, remove this in year >2022
instance Hashable1 NonEmpty
#endif

-- | A single line of the bindings section of a let expression or of a set.
data Binding r
  = NamedVar !(NAttrPath r) !r !NSourcePos
  -- ^ An explicit naming.
  --
  -- > NamedVar (StaticKey "x" :| [StaticKey "y"]) z NSourcePos{}  ~  x.y = z;
  | Inherit !(Maybe r) ![VarName] !NSourcePos
  -- ^ Inheriting an attribute (binding) into the attribute set from the other scope (attribute set). No denoted scope means to inherit from the closest outside scope.
  --
  -- +----------------------------------------------------------------+--------------------+-----------------------+
  -- | Hask                                                           | Nix                | pseudocode            |
  -- +================================================================+====================+=======================+
  -- | @Inherit Nothing  [StaticKey "a"] NSourcePos{}@                | @inherit a;@       | @a = outside.a;@      |
  -- +----------------------------------------------------------------+--------------------+-----------------------+
  -- | @Inherit (pure x) [StaticKey "a"] NSourcePos{}@                | @inherit (x) a;@   | @a = x.a;@            |
  -- +----------------------------------------------------------------+--------------------+-----------------------+
  -- | @Inherit (pure x) [StaticKey "a", StaticKey "b"] NSourcePos{}@ | @inherit (x) a b;@ | @a = x.a;@            |
  -- |                                                                |                    | @b = x.b;@            |
  -- +----------------------------------------------------------------+--------------------+-----------------------+
  --
  -- (2021-07-07 use details):
  -- Inherits the position of the first name through @unsafeGetAttrPos@. The position of the scope inherited from else - the position of the first member of the binds list.
  deriving
    ( Binding r -> Binding r -> Bool
forall r. Eq r => Binding r -> Binding r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Binding r -> Binding r -> Bool
$c/= :: forall r. Eq r => Binding r -> Binding r -> Bool
== :: Binding r -> Binding r -> Bool
$c== :: forall r. Eq r => Binding r -> Binding r -> Bool
Eq, Binding r -> Binding r -> Bool
Binding r -> Binding r -> Ordering
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
forall {r}. Ord r => Eq (Binding r)
forall r. Ord r => Binding r -> Binding r -> Bool
forall r. Ord r => Binding r -> Binding r -> Ordering
forall r. Ord r => Binding r -> Binding r -> Binding r
min :: Binding r -> Binding r -> Binding r
$cmin :: forall r. Ord r => Binding r -> Binding r -> Binding r
max :: Binding r -> Binding r -> Binding r
$cmax :: forall r. Ord r => Binding r -> Binding r -> Binding r
>= :: Binding r -> Binding r -> Bool
$c>= :: forall r. Ord r => Binding r -> Binding r -> Bool
> :: Binding r -> Binding r -> Bool
$c> :: forall r. Ord r => Binding r -> Binding r -> Bool
<= :: Binding r -> Binding r -> Bool
$c<= :: forall r. Ord r => Binding r -> Binding r -> Bool
< :: Binding r -> Binding r -> Bool
$c< :: forall r. Ord r => Binding r -> Binding r -> Bool
compare :: Binding r -> Binding r -> Ordering
$ccompare :: forall r. Ord r => Binding r -> Binding r -> Ordering
Ord, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (Binding r) x -> Binding r
forall r x. Binding r -> Rep (Binding r) x
$cto :: forall r x. Rep (Binding r) x -> Binding r
$cfrom :: forall r x. Binding r -> Rep (Binding r) x
Generic, forall a. Rep1 Binding a -> Binding a
forall a. Binding a -> Rep1 Binding a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall a. Rep1 Binding a -> Binding a
$cfrom1 :: forall a. Binding a -> Rep1 Binding a
Generic1
    , Typeable, Binding r -> DataType
Binding r -> Constr
forall {r}. Data r => Typeable (Binding r)
forall r. Data r => Binding r -> DataType
forall r. Data r => Binding r -> Constr
forall r.
Data r =>
(forall b. Data b => b -> b) -> Binding r -> Binding r
forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> Binding r -> u
forall r u.
Data r =>
(forall d. Data d => d -> u) -> Binding r -> [u]
forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding r -> r
forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding r -> r
forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding r)
forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding r -> c (Binding r)
forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binding r))
forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding r))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding r -> c (Binding r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Binding r))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
$cgmapMo :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
$cgmapMp :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
$cgmapM :: forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Binding r -> u
$cgmapQi :: forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> Binding r -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Binding r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> Binding r -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding r -> r
$cgmapQr :: forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding r -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding r -> r
$cgmapQl :: forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding r -> r
gmapT :: (forall b. Data b => b -> b) -> Binding r -> Binding r
$cgmapT :: forall r.
Data r =>
(forall b. Data b => b -> b) -> Binding r -> Binding r
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding r))
$cdataCast2 :: forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding r))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Binding r))
$cdataCast1 :: forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Binding r))
dataTypeOf :: Binding r -> DataType
$cdataTypeOf :: forall r. Data r => Binding r -> DataType
toConstr :: Binding r -> Constr
$ctoConstr :: forall r. Data r => Binding r -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding r)
$cgunfold :: forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding r)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding r -> c (Binding r)
$cgfoldl :: forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding r -> c (Binding r)
Data, forall r. NFData r => Binding r -> ()
forall a. (a -> ()) -> NFData a
rnf :: Binding r -> ()
$crnf :: forall r. NFData r => Binding r -> ()
NFData, forall a. (a -> ()) -> Binding a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: forall a. (a -> ()) -> Binding a -> ()
$cliftRnf :: forall a. (a -> ()) -> Binding a -> ()
NFData1, forall r. Serialise r => [Binding r] -> Encoding
forall r. Serialise r => Binding r -> Encoding
forall r s. Serialise r => Decoder s [Binding r]
forall r s. Serialise r => Decoder s (Binding r)
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [Binding r]
$cdecodeList :: forall r s. Serialise r => Decoder s [Binding r]
encodeList :: [Binding r] -> Encoding
$cencodeList :: forall r. Serialise r => [Binding r] -> Encoding
decode :: forall s. Decoder s (Binding r)
$cdecode :: forall r s. Serialise r => Decoder s (Binding r)
encode :: Binding r -> Encoding
$cencode :: forall r. Serialise r => Binding r -> Encoding
Serialise, forall r. Binary r => Get (Binding r)
forall r. Binary r => [Binding r] -> Put
forall r. Binary r => Binding r -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [Binding r] -> Put
$cputList :: forall r. Binary r => [Binding r] -> Put
get :: Get (Binding r)
$cget :: forall r. Binary r => Get (Binding r)
put :: Binding r -> Put
$cput :: forall r. Binary r => Binding r -> Put
Binary, forall r. ToJSON r => [Binding r] -> Encoding
forall r. ToJSON r => [Binding r] -> Value
forall r. ToJSON r => Binding r -> Encoding
forall r. ToJSON r => Binding r -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Binding r] -> Encoding
$ctoEncodingList :: forall r. ToJSON r => [Binding r] -> Encoding
toJSONList :: [Binding r] -> Value
$ctoJSONList :: forall r. ToJSON r => [Binding r] -> Value
toEncoding :: Binding r -> Encoding
$ctoEncoding :: forall r. ToJSON r => Binding r -> Encoding
toJSON :: Binding r -> Value
$ctoJSON :: forall r. ToJSON r => Binding r -> Value
ToJSON, forall r. FromJSON r => Value -> Parser [Binding r]
forall r. FromJSON r => Value -> Parser (Binding r)
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Binding r]
$cparseJSONList :: forall r. FromJSON r => Value -> Parser [Binding r]
parseJSON :: Value -> Parser (Binding r)
$cparseJSON :: forall r. FromJSON r => Value -> Parser (Binding r)
FromJSON
    , forall a b. a -> Binding b -> Binding a
forall a b. (a -> b) -> Binding a -> Binding b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Binding b -> Binding a
$c<$ :: forall a b. a -> Binding b -> Binding a
fmap :: forall a b. (a -> b) -> Binding a -> Binding b
$cfmap :: forall a b. (a -> b) -> Binding a -> Binding b
Functor, forall a. Eq a => a -> Binding a -> Bool
forall a. Num a => Binding a -> a
forall a. Ord a => Binding a -> a
forall m. Monoid m => Binding m -> m
forall a. Binding a -> Bool
forall a. Binding a -> Int
forall a. Binding a -> [a]
forall a. (a -> a -> a) -> Binding a -> a
forall m a. Monoid m => (a -> m) -> Binding a -> m
forall b a. (b -> a -> b) -> b -> Binding a -> b
forall a b. (a -> b -> b) -> b -> Binding a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Binding a -> a
$cproduct :: forall a. Num a => Binding a -> a
sum :: forall a. Num a => Binding a -> a
$csum :: forall a. Num a => Binding a -> a
minimum :: forall a. Ord a => Binding a -> a
$cminimum :: forall a. Ord a => Binding a -> a
maximum :: forall a. Ord a => Binding a -> a
$cmaximum :: forall a. Ord a => Binding a -> a
elem :: forall a. Eq a => a -> Binding a -> Bool
$celem :: forall a. Eq a => a -> Binding a -> Bool
length :: forall a. Binding a -> Int
$clength :: forall a. Binding a -> Int
null :: forall a. Binding a -> Bool
$cnull :: forall a. Binding a -> Bool
toList :: forall a. Binding a -> [a]
$ctoList :: forall a. Binding a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Binding a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Binding a -> a
foldr1 :: forall a. (a -> a -> a) -> Binding a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Binding a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Binding a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Binding a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Binding a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Binding a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Binding a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Binding a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Binding a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Binding a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Binding a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Binding a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Binding a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Binding a -> m
fold :: forall m. Monoid m => Binding m -> m
$cfold :: forall m. Monoid m => Binding m -> m
Foldable, Functor Binding
Foldable Binding
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Binding (m a) -> m (Binding a)
forall (f :: * -> *) a.
Applicative f =>
Binding (f a) -> f (Binding a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binding a -> m (Binding b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binding a -> f (Binding b)
sequence :: forall (m :: * -> *) a. Monad m => Binding (m a) -> m (Binding a)
$csequence :: forall (m :: * -> *) a. Monad m => Binding (m a) -> m (Binding a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binding a -> m (Binding b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binding a -> m (Binding b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Binding (f a) -> f (Binding a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Binding (f a) -> f (Binding a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binding a -> f (Binding b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binding a -> f (Binding b)
Traversable
    , Int -> Binding r -> ShowS
forall r. Show r => Int -> Binding r -> ShowS
forall r. Show r => [Binding r] -> ShowS
forall r. Show r => Binding r -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Binding r] -> ShowS
$cshowList :: forall r. Show r => [Binding r] -> ShowS
show :: Binding r -> FilePath
$cshow :: forall r. Show r => Binding r -> FilePath
showsPrec :: Int -> Binding r -> ShowS
$cshowsPrec :: forall r. Show r => Int -> Binding r -> ShowS
Show, forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall {r}. Hashable r => Eq (Binding r)
forall r. Hashable r => Int -> Binding r -> Int
forall r. Hashable r => Binding r -> Int
hash :: Binding r -> Int
$chash :: forall r. Hashable r => Binding r -> Int
hashWithSalt :: Int -> Binding r -> Int
$chashWithSalt :: forall r. Hashable r => Int -> Binding r -> Int
Hashable
    )

$(deriveShow1 ''Binding)
$(deriveEq1   ''Binding)
$(deriveOrd1  ''Binding)
--x $(deriveJSON1 defaultOptions ''Binding)

deriving instance Hashable1 Binding

-- *** lens traversals

$(makeTraversals ''Binding)


-- ** data Recursivity

-- | Distinguishes between recursive and non-recursive. Mainly for attribute
-- sets.
data Recursivity
  = NonRecursive  -- ^ >     { ... }
  | Recursive     -- ^ > rec { ... }
  deriving
    ( Recursivity -> Recursivity -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Recursivity -> Recursivity -> Bool
$c/= :: Recursivity -> Recursivity -> Bool
== :: Recursivity -> Recursivity -> Bool
$c== :: Recursivity -> Recursivity -> Bool
Eq, Eq Recursivity
Recursivity -> Recursivity -> Bool
Recursivity -> Recursivity -> Ordering
Recursivity -> Recursivity -> Recursivity
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 :: Recursivity -> Recursivity -> Recursivity
$cmin :: Recursivity -> Recursivity -> Recursivity
max :: Recursivity -> Recursivity -> Recursivity
$cmax :: Recursivity -> Recursivity -> Recursivity
>= :: Recursivity -> Recursivity -> Bool
$c>= :: Recursivity -> Recursivity -> Bool
> :: Recursivity -> Recursivity -> Bool
$c> :: Recursivity -> Recursivity -> Bool
<= :: Recursivity -> Recursivity -> Bool
$c<= :: Recursivity -> Recursivity -> Bool
< :: Recursivity -> Recursivity -> Bool
$c< :: Recursivity -> Recursivity -> Bool
compare :: Recursivity -> Recursivity -> Ordering
$ccompare :: Recursivity -> Recursivity -> Ordering
Ord, Int -> Recursivity
Recursivity -> Int
Recursivity -> [Recursivity]
Recursivity -> Recursivity
Recursivity -> Recursivity -> [Recursivity]
Recursivity -> Recursivity -> Recursivity -> [Recursivity]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Recursivity -> Recursivity -> Recursivity -> [Recursivity]
$cenumFromThenTo :: Recursivity -> Recursivity -> Recursivity -> [Recursivity]
enumFromTo :: Recursivity -> Recursivity -> [Recursivity]
$cenumFromTo :: Recursivity -> Recursivity -> [Recursivity]
enumFromThen :: Recursivity -> Recursivity -> [Recursivity]
$cenumFromThen :: Recursivity -> Recursivity -> [Recursivity]
enumFrom :: Recursivity -> [Recursivity]
$cenumFrom :: Recursivity -> [Recursivity]
fromEnum :: Recursivity -> Int
$cfromEnum :: Recursivity -> Int
toEnum :: Int -> Recursivity
$ctoEnum :: Int -> Recursivity
pred :: Recursivity -> Recursivity
$cpred :: Recursivity -> Recursivity
succ :: Recursivity -> Recursivity
$csucc :: Recursivity -> Recursivity
Enum, Recursivity
forall a. a -> a -> Bounded a
maxBound :: Recursivity
$cmaxBound :: Recursivity
minBound :: Recursivity
$cminBound :: Recursivity
Bounded, forall x. Rep Recursivity x -> Recursivity
forall x. Recursivity -> Rep Recursivity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Recursivity x -> Recursivity
$cfrom :: forall x. Recursivity -> Rep Recursivity x
Generic
    , Typeable, Typeable Recursivity
Recursivity -> DataType
Recursivity -> Constr
(forall b. Data b => b -> b) -> Recursivity -> Recursivity
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Recursivity -> u
forall u. (forall d. Data d => d -> u) -> Recursivity -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Recursivity -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Recursivity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Recursivity -> m Recursivity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Recursivity -> m Recursivity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Recursivity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Recursivity -> c Recursivity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Recursivity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Recursivity)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Recursivity -> m Recursivity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Recursivity -> m Recursivity
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Recursivity -> m Recursivity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Recursivity -> m Recursivity
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Recursivity -> m Recursivity
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Recursivity -> m Recursivity
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Recursivity -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Recursivity -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Recursivity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Recursivity -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Recursivity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Recursivity -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Recursivity -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Recursivity -> r
gmapT :: (forall b. Data b => b -> b) -> Recursivity -> Recursivity
$cgmapT :: (forall b. Data b => b -> b) -> Recursivity -> Recursivity
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Recursivity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Recursivity)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Recursivity)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Recursivity)
dataTypeOf :: Recursivity -> DataType
$cdataTypeOf :: Recursivity -> DataType
toConstr :: Recursivity -> Constr
$ctoConstr :: Recursivity -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Recursivity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Recursivity
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Recursivity -> c Recursivity
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Recursivity -> c Recursivity
Data, Recursivity -> ()
forall a. (a -> ()) -> NFData a
rnf :: Recursivity -> ()
$crnf :: Recursivity -> ()
NFData, [Recursivity] -> Encoding
Recursivity -> Encoding
forall s. Decoder s [Recursivity]
forall s. Decoder s Recursivity
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [Recursivity]
$cdecodeList :: forall s. Decoder s [Recursivity]
encodeList :: [Recursivity] -> Encoding
$cencodeList :: [Recursivity] -> Encoding
decode :: forall s. Decoder s Recursivity
$cdecode :: forall s. Decoder s Recursivity
encode :: Recursivity -> Encoding
$cencode :: Recursivity -> Encoding
Serialise, Get Recursivity
[Recursivity] -> Put
Recursivity -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [Recursivity] -> Put
$cputList :: [Recursivity] -> Put
get :: Get Recursivity
$cget :: Get Recursivity
put :: Recursivity -> Put
$cput :: Recursivity -> Put
Binary, [Recursivity] -> Encoding
[Recursivity] -> Value
Recursivity -> Encoding
Recursivity -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Recursivity] -> Encoding
$ctoEncodingList :: [Recursivity] -> Encoding
toJSONList :: [Recursivity] -> Value
$ctoJSONList :: [Recursivity] -> Value
toEncoding :: Recursivity -> Encoding
$ctoEncoding :: Recursivity -> Encoding
toJSON :: Recursivity -> Value
$ctoJSON :: Recursivity -> Value
ToJSON, Value -> Parser [Recursivity]
Value -> Parser Recursivity
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Recursivity]
$cparseJSONList :: Value -> Parser [Recursivity]
parseJSON :: Value -> Parser Recursivity
$cparseJSON :: Value -> Parser Recursivity
FromJSON
    , Int -> Recursivity -> ShowS
[Recursivity] -> ShowS
Recursivity -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Recursivity] -> ShowS
$cshowList :: [Recursivity] -> ShowS
show :: Recursivity -> FilePath
$cshow :: Recursivity -> FilePath
showsPrec :: Int -> Recursivity -> ShowS
$cshowsPrec :: Int -> Recursivity -> ShowS
Show, ReadPrec [Recursivity]
ReadPrec Recursivity
Int -> ReadS Recursivity
ReadS [Recursivity]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Recursivity]
$creadListPrec :: ReadPrec [Recursivity]
readPrec :: ReadPrec Recursivity
$creadPrec :: ReadPrec Recursivity
readList :: ReadS [Recursivity]
$creadList :: ReadS [Recursivity]
readsPrec :: Int -> ReadS Recursivity
$creadsPrec :: Int -> ReadS Recursivity
Read, Eq Recursivity
Int -> Recursivity -> Int
Recursivity -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Recursivity -> Int
$chash :: Recursivity -> Int
hashWithSalt :: Int -> Recursivity -> Int
$chashWithSalt :: Int -> Recursivity -> Int
Hashable
    )

instance Semigroup Recursivity where
  <> :: Recursivity -> Recursivity -> Recursivity
(<>) Recursivity
NonRecursive Recursivity
NonRecursive = Recursivity
NonRecursive
  (<>) Recursivity
_ Recursivity
_ = Recursivity
Recursive

instance Monoid Recursivity where
  mempty :: Recursivity
mempty = Recursivity
NonRecursive

-- ** data NUnaryOp

-- | There are two unary operations: logical not and integer negation.
data NUnaryOp
  = NNeg  -- ^ @-@
  | NNot  -- ^ @!@
  deriving
    ( NUnaryOp -> NUnaryOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NUnaryOp -> NUnaryOp -> Bool
$c/= :: NUnaryOp -> NUnaryOp -> Bool
== :: NUnaryOp -> NUnaryOp -> Bool
$c== :: NUnaryOp -> NUnaryOp -> Bool
Eq, Eq NUnaryOp
NUnaryOp -> NUnaryOp -> Bool
NUnaryOp -> NUnaryOp -> Ordering
NUnaryOp -> NUnaryOp -> NUnaryOp
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 :: NUnaryOp -> NUnaryOp -> NUnaryOp
$cmin :: NUnaryOp -> NUnaryOp -> NUnaryOp
max :: NUnaryOp -> NUnaryOp -> NUnaryOp
$cmax :: NUnaryOp -> NUnaryOp -> NUnaryOp
>= :: NUnaryOp -> NUnaryOp -> Bool
$c>= :: NUnaryOp -> NUnaryOp -> Bool
> :: NUnaryOp -> NUnaryOp -> Bool
$c> :: NUnaryOp -> NUnaryOp -> Bool
<= :: NUnaryOp -> NUnaryOp -> Bool
$c<= :: NUnaryOp -> NUnaryOp -> Bool
< :: NUnaryOp -> NUnaryOp -> Bool
$c< :: NUnaryOp -> NUnaryOp -> Bool
compare :: NUnaryOp -> NUnaryOp -> Ordering
$ccompare :: NUnaryOp -> NUnaryOp -> Ordering
Ord, Int -> NUnaryOp
NUnaryOp -> Int
NUnaryOp -> [NUnaryOp]
NUnaryOp -> NUnaryOp
NUnaryOp -> NUnaryOp -> [NUnaryOp]
NUnaryOp -> NUnaryOp -> NUnaryOp -> [NUnaryOp]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: NUnaryOp -> NUnaryOp -> NUnaryOp -> [NUnaryOp]
$cenumFromThenTo :: NUnaryOp -> NUnaryOp -> NUnaryOp -> [NUnaryOp]
enumFromTo :: NUnaryOp -> NUnaryOp -> [NUnaryOp]
$cenumFromTo :: NUnaryOp -> NUnaryOp -> [NUnaryOp]
enumFromThen :: NUnaryOp -> NUnaryOp -> [NUnaryOp]
$cenumFromThen :: NUnaryOp -> NUnaryOp -> [NUnaryOp]
enumFrom :: NUnaryOp -> [NUnaryOp]
$cenumFrom :: NUnaryOp -> [NUnaryOp]
fromEnum :: NUnaryOp -> Int
$cfromEnum :: NUnaryOp -> Int
toEnum :: Int -> NUnaryOp
$ctoEnum :: Int -> NUnaryOp
pred :: NUnaryOp -> NUnaryOp
$cpred :: NUnaryOp -> NUnaryOp
succ :: NUnaryOp -> NUnaryOp
$csucc :: NUnaryOp -> NUnaryOp
Enum, NUnaryOp
forall a. a -> a -> Bounded a
maxBound :: NUnaryOp
$cmaxBound :: NUnaryOp
minBound :: NUnaryOp
$cminBound :: NUnaryOp
Bounded, forall x. Rep NUnaryOp x -> NUnaryOp
forall x. NUnaryOp -> Rep NUnaryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NUnaryOp x -> NUnaryOp
$cfrom :: forall x. NUnaryOp -> Rep NUnaryOp x
Generic
    , Typeable, Typeable NUnaryOp
NUnaryOp -> DataType
NUnaryOp -> Constr
(forall b. Data b => b -> b) -> NUnaryOp -> NUnaryOp
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NUnaryOp -> u
forall u. (forall d. Data d => d -> u) -> NUnaryOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NUnaryOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NUnaryOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NUnaryOp -> m NUnaryOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NUnaryOp -> m NUnaryOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NUnaryOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NUnaryOp -> c NUnaryOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NUnaryOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NUnaryOp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NUnaryOp -> m NUnaryOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NUnaryOp -> m NUnaryOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NUnaryOp -> m NUnaryOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NUnaryOp -> m NUnaryOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NUnaryOp -> m NUnaryOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NUnaryOp -> m NUnaryOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NUnaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NUnaryOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NUnaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NUnaryOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NUnaryOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NUnaryOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NUnaryOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NUnaryOp -> r
gmapT :: (forall b. Data b => b -> b) -> NUnaryOp -> NUnaryOp
$cgmapT :: (forall b. Data b => b -> b) -> NUnaryOp -> NUnaryOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NUnaryOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NUnaryOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NUnaryOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NUnaryOp)
dataTypeOf :: NUnaryOp -> DataType
$cdataTypeOf :: NUnaryOp -> DataType
toConstr :: NUnaryOp -> Constr
$ctoConstr :: NUnaryOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NUnaryOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NUnaryOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NUnaryOp -> c NUnaryOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NUnaryOp -> c NUnaryOp
Data, NUnaryOp -> ()
forall a. (a -> ()) -> NFData a
rnf :: NUnaryOp -> ()
$crnf :: NUnaryOp -> ()
NFData, [NUnaryOp] -> Encoding
NUnaryOp -> Encoding
forall s. Decoder s [NUnaryOp]
forall s. Decoder s NUnaryOp
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [NUnaryOp]
$cdecodeList :: forall s. Decoder s [NUnaryOp]
encodeList :: [NUnaryOp] -> Encoding
$cencodeList :: [NUnaryOp] -> Encoding
decode :: forall s. Decoder s NUnaryOp
$cdecode :: forall s. Decoder s NUnaryOp
encode :: NUnaryOp -> Encoding
$cencode :: NUnaryOp -> Encoding
Serialise, Get NUnaryOp
[NUnaryOp] -> Put
NUnaryOp -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [NUnaryOp] -> Put
$cputList :: [NUnaryOp] -> Put
get :: Get NUnaryOp
$cget :: Get NUnaryOp
put :: NUnaryOp -> Put
$cput :: NUnaryOp -> Put
Binary, [NUnaryOp] -> Encoding
[NUnaryOp] -> Value
NUnaryOp -> Encoding
NUnaryOp -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [NUnaryOp] -> Encoding
$ctoEncodingList :: [NUnaryOp] -> Encoding
toJSONList :: [NUnaryOp] -> Value
$ctoJSONList :: [NUnaryOp] -> Value
toEncoding :: NUnaryOp -> Encoding
$ctoEncoding :: NUnaryOp -> Encoding
toJSON :: NUnaryOp -> Value
$ctoJSON :: NUnaryOp -> Value
ToJSON, Value -> Parser [NUnaryOp]
Value -> Parser NUnaryOp
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NUnaryOp]
$cparseJSONList :: Value -> Parser [NUnaryOp]
parseJSON :: Value -> Parser NUnaryOp
$cparseJSON :: Value -> Parser NUnaryOp
FromJSON
    , Int -> NUnaryOp -> ShowS
[NUnaryOp] -> ShowS
NUnaryOp -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [NUnaryOp] -> ShowS
$cshowList :: [NUnaryOp] -> ShowS
show :: NUnaryOp -> FilePath
$cshow :: NUnaryOp -> FilePath
showsPrec :: Int -> NUnaryOp -> ShowS
$cshowsPrec :: Int -> NUnaryOp -> ShowS
Show, ReadPrec [NUnaryOp]
ReadPrec NUnaryOp
Int -> ReadS NUnaryOp
ReadS [NUnaryOp]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NUnaryOp]
$creadListPrec :: ReadPrec [NUnaryOp]
readPrec :: ReadPrec NUnaryOp
$creadPrec :: ReadPrec NUnaryOp
readList :: ReadS [NUnaryOp]
$creadList :: ReadS [NUnaryOp]
readsPrec :: Int -> ReadS NUnaryOp
$creadsPrec :: Int -> ReadS NUnaryOp
Read, Eq NUnaryOp
Int -> NUnaryOp -> Int
NUnaryOp -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: NUnaryOp -> Int
$chash :: NUnaryOp -> Int
hashWithSalt :: Int -> NUnaryOp -> Int
$chashWithSalt :: Int -> NUnaryOp -> Int
Hashable
    )

-- *** lens traversals

$(makeTraversals ''NUnaryOp)

-- ** data NBinaryOp

-- | Binary operators expressible in the nix language.
data NBinaryOp
  = NEq      -- ^ Equality (@==@)
  | NNEq     -- ^ Inequality (@!=@)
  | NLt      -- ^ Less than (@<@)
  | NLte     -- ^ Less than or equal (@<=@)
  | NGt      -- ^ Greater than (@>@)
  | NGte     -- ^ Greater than or equal (@>=@)
  | NAnd     -- ^ Logical and (@&&@)
  | NOr      -- ^ Logical or (@||@)
  | NImpl    -- ^ Logical implication (@->@)
  | NUpdate  -- ^ Get the left attr set, extend it with the right one & override equal keys (@//@)
  | NPlus    -- ^ Addition (@+@)
  | NMinus   -- ^ Subtraction (@-@)
  | NMult    -- ^ Multiplication (@*@)
  | NDiv     -- ^ Division (@/@)
  | NConcat  -- ^ List concatenation (@++@)
  deriving
    ( NBinaryOp -> NBinaryOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NBinaryOp -> NBinaryOp -> Bool
$c/= :: NBinaryOp -> NBinaryOp -> Bool
== :: NBinaryOp -> NBinaryOp -> Bool
$c== :: NBinaryOp -> NBinaryOp -> Bool
Eq, Eq NBinaryOp
NBinaryOp -> NBinaryOp -> Bool
NBinaryOp -> NBinaryOp -> Ordering
NBinaryOp -> NBinaryOp -> NBinaryOp
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 :: NBinaryOp -> NBinaryOp -> NBinaryOp
$cmin :: NBinaryOp -> NBinaryOp -> NBinaryOp
max :: NBinaryOp -> NBinaryOp -> NBinaryOp
$cmax :: NBinaryOp -> NBinaryOp -> NBinaryOp
>= :: NBinaryOp -> NBinaryOp -> Bool
$c>= :: NBinaryOp -> NBinaryOp -> Bool
> :: NBinaryOp -> NBinaryOp -> Bool
$c> :: NBinaryOp -> NBinaryOp -> Bool
<= :: NBinaryOp -> NBinaryOp -> Bool
$c<= :: NBinaryOp -> NBinaryOp -> Bool
< :: NBinaryOp -> NBinaryOp -> Bool
$c< :: NBinaryOp -> NBinaryOp -> Bool
compare :: NBinaryOp -> NBinaryOp -> Ordering
$ccompare :: NBinaryOp -> NBinaryOp -> Ordering
Ord, Int -> NBinaryOp
NBinaryOp -> Int
NBinaryOp -> [NBinaryOp]
NBinaryOp -> NBinaryOp
NBinaryOp -> NBinaryOp -> [NBinaryOp]
NBinaryOp -> NBinaryOp -> NBinaryOp -> [NBinaryOp]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: NBinaryOp -> NBinaryOp -> NBinaryOp -> [NBinaryOp]
$cenumFromThenTo :: NBinaryOp -> NBinaryOp -> NBinaryOp -> [NBinaryOp]
enumFromTo :: NBinaryOp -> NBinaryOp -> [NBinaryOp]
$cenumFromTo :: NBinaryOp -> NBinaryOp -> [NBinaryOp]
enumFromThen :: NBinaryOp -> NBinaryOp -> [NBinaryOp]
$cenumFromThen :: NBinaryOp -> NBinaryOp -> [NBinaryOp]
enumFrom :: NBinaryOp -> [NBinaryOp]
$cenumFrom :: NBinaryOp -> [NBinaryOp]
fromEnum :: NBinaryOp -> Int
$cfromEnum :: NBinaryOp -> Int
toEnum :: Int -> NBinaryOp
$ctoEnum :: Int -> NBinaryOp
pred :: NBinaryOp -> NBinaryOp
$cpred :: NBinaryOp -> NBinaryOp
succ :: NBinaryOp -> NBinaryOp
$csucc :: NBinaryOp -> NBinaryOp
Enum, NBinaryOp
forall a. a -> a -> Bounded a
maxBound :: NBinaryOp
$cmaxBound :: NBinaryOp
minBound :: NBinaryOp
$cminBound :: NBinaryOp
Bounded, forall x. Rep NBinaryOp x -> NBinaryOp
forall x. NBinaryOp -> Rep NBinaryOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NBinaryOp x -> NBinaryOp
$cfrom :: forall x. NBinaryOp -> Rep NBinaryOp x
Generic
    , Typeable, Typeable NBinaryOp
NBinaryOp -> DataType
NBinaryOp -> Constr
(forall b. Data b => b -> b) -> NBinaryOp -> NBinaryOp
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NBinaryOp -> u
forall u. (forall d. Data d => d -> u) -> NBinaryOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NBinaryOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NBinaryOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NBinaryOp -> m NBinaryOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NBinaryOp -> m NBinaryOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NBinaryOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NBinaryOp -> c NBinaryOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NBinaryOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NBinaryOp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NBinaryOp -> m NBinaryOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NBinaryOp -> m NBinaryOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NBinaryOp -> m NBinaryOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NBinaryOp -> m NBinaryOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NBinaryOp -> m NBinaryOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NBinaryOp -> m NBinaryOp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NBinaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NBinaryOp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NBinaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NBinaryOp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NBinaryOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NBinaryOp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NBinaryOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NBinaryOp -> r
gmapT :: (forall b. Data b => b -> b) -> NBinaryOp -> NBinaryOp
$cgmapT :: (forall b. Data b => b -> b) -> NBinaryOp -> NBinaryOp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NBinaryOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NBinaryOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NBinaryOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NBinaryOp)
dataTypeOf :: NBinaryOp -> DataType
$cdataTypeOf :: NBinaryOp -> DataType
toConstr :: NBinaryOp -> Constr
$ctoConstr :: NBinaryOp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NBinaryOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NBinaryOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NBinaryOp -> c NBinaryOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NBinaryOp -> c NBinaryOp
Data, NBinaryOp -> ()
forall a. (a -> ()) -> NFData a
rnf :: NBinaryOp -> ()
$crnf :: NBinaryOp -> ()
NFData, [NBinaryOp] -> Encoding
NBinaryOp -> Encoding
forall s. Decoder s [NBinaryOp]
forall s. Decoder s NBinaryOp
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [NBinaryOp]
$cdecodeList :: forall s. Decoder s [NBinaryOp]
encodeList :: [NBinaryOp] -> Encoding
$cencodeList :: [NBinaryOp] -> Encoding
decode :: forall s. Decoder s NBinaryOp
$cdecode :: forall s. Decoder s NBinaryOp
encode :: NBinaryOp -> Encoding
$cencode :: NBinaryOp -> Encoding
Serialise, Get NBinaryOp
[NBinaryOp] -> Put
NBinaryOp -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [NBinaryOp] -> Put
$cputList :: [NBinaryOp] -> Put
get :: Get NBinaryOp
$cget :: Get NBinaryOp
put :: NBinaryOp -> Put
$cput :: NBinaryOp -> Put
Binary, [NBinaryOp] -> Encoding
[NBinaryOp] -> Value
NBinaryOp -> Encoding
NBinaryOp -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [NBinaryOp] -> Encoding
$ctoEncodingList :: [NBinaryOp] -> Encoding
toJSONList :: [NBinaryOp] -> Value
$ctoJSONList :: [NBinaryOp] -> Value
toEncoding :: NBinaryOp -> Encoding
$ctoEncoding :: NBinaryOp -> Encoding
toJSON :: NBinaryOp -> Value
$ctoJSON :: NBinaryOp -> Value
ToJSON, Value -> Parser [NBinaryOp]
Value -> Parser NBinaryOp
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NBinaryOp]
$cparseJSONList :: Value -> Parser [NBinaryOp]
parseJSON :: Value -> Parser NBinaryOp
$cparseJSON :: Value -> Parser NBinaryOp
FromJSON
    , Int -> NBinaryOp -> ShowS
[NBinaryOp] -> ShowS
NBinaryOp -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [NBinaryOp] -> ShowS
$cshowList :: [NBinaryOp] -> ShowS
show :: NBinaryOp -> FilePath
$cshow :: NBinaryOp -> FilePath
showsPrec :: Int -> NBinaryOp -> ShowS
$cshowsPrec :: Int -> NBinaryOp -> ShowS
Show, ReadPrec [NBinaryOp]
ReadPrec NBinaryOp
Int -> ReadS NBinaryOp
ReadS [NBinaryOp]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NBinaryOp]
$creadListPrec :: ReadPrec [NBinaryOp]
readPrec :: ReadPrec NBinaryOp
$creadPrec :: ReadPrec NBinaryOp
readList :: ReadS [NBinaryOp]
$creadList :: ReadS [NBinaryOp]
readsPrec :: Int -> ReadS NBinaryOp
$creadsPrec :: Int -> ReadS NBinaryOp
Read, Eq NBinaryOp
Int -> NBinaryOp -> Int
NBinaryOp -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: NBinaryOp -> Int
$chash :: NBinaryOp -> Int
hashWithSalt :: Int -> NBinaryOp -> Int
$chashWithSalt :: Int -> NBinaryOp -> Int
Hashable
    )

-- *** lens traversals

$(makeTraversals ''NBinaryOp)


-- * data NExprF - Nix expressions, base functor

-- | The main Nix expression type. As it is polimorphic, has a functor,
-- which allows to traverse expressions and map functions over them.
-- The actual 'NExpr' type is a fixed point of this functor, defined
-- below.
data NExprF r
  = NConstant !NAtom
  -- ^ Constants: ints, floats, bools, URIs, and null.
  | NStr !(NString r)
  -- ^ A string, with interpolated expressions.
  | NSym !VarName
  -- ^ A variable. For example, in the expression @f a@, @f@ is represented
  -- as @NSym "f"@ and @a@ as @NSym "a"@.
  --
  -- > NSym "x"                                    ~  x
  | NList ![r]
  -- ^ A list literal.
  --
  -- > NList [x,y]                                 ~  [ x y ]
  | NSet !Recursivity ![Binding r]
  -- ^ An attribute set literal
  --
  -- > NSet Recursive    [NamedVar x y _]         ~  rec { x = y; }
  -- > NSet NonRecursive [Inherit Nothing [x] _]  ~  { inherit x; }
  | NLiteralPath !Path
  -- ^ A path expression, which is evaluated to a store path. The path here
  -- can be relative, in which case it's evaluated relative to the file in
  -- which it appears.
  --
  -- > NLiteralPath "/x"                           ~  /x
  -- > NLiteralPath "x/y"                          ~  x/y
  | NEnvPath !Path
  -- ^ A path which refers to something in the Nix search path (the NIX_PATH
  -- environment variable. For example, @<nixpkgs/pkgs>@.
  --
  -- > NEnvPath "x"                                ~  <x>
  | NApp !r !r
  -- ^ Functional application (aka F.A., apply a function to an argument).
  --
  -- > NApp f x  ~  f x
  | NUnary !NUnaryOp !r
  -- ^ Application of a unary operator to an expression.
  --
  -- > NUnary NNeg x                               ~  - x
  -- > NUnary NNot x                               ~  ! x
  | NBinary !NBinaryOp !r !r
  -- ^ Application of a binary operator to two expressions.
  --
  -- > NBinary NPlus x y                           ~  x + y
  -- > NBinary NApp  f x                           ~  f x
  | NSelect !(Maybe r) !r !(NAttrPath r)
  -- ^ Dot-reference into an attribute set, optionally providing an
  -- alternative if the key doesn't exist.
  --
  -- > NSelect Nothing  s (x :| [])                ~  s.x
  -- > NSelect (pure y) s (x :| [])                ~  s.x or y
  | NHasAttr !r !(NAttrPath r)
  -- ^ Ask if a set contains a given attribute path.
  --
  -- > NHasAttr s (x :| [])                        ~  s ? x
  | NAbs !(Params r) !r
  -- ^ A function literal (lambda abstraction).
  --
  -- > NAbs (Param "x") y                          ~  x: y
  | NLet ![Binding r] !r
  -- ^ Evaluate the second argument after introducing the bindings.
  --
  -- > NLet []                    x                ~  let in x
  -- > NLet [NamedVar x y _]      z                ~  let x = y; in z
  -- > NLet [Inherit Nothing x _] y                ~  let inherit x; in y
  | NIf !r !r !r
  -- ^ If-then-else statement.
  --
  -- > NIf x y z                                   ~  if x then y else z
  | NWith !r !r
  -- ^ Evaluate an attribute set, bring its bindings into scope, and
  -- evaluate the second argument.
  --
  -- > NWith x y                                   ~  with x; y
  | NAssert !r !r
  -- ^ Checks that the first argument is a predicate that is @true@ before evaluating the second argument.
  --
  -- > NAssert x y                                 ~  assert x; y
  | NSynHole !VarName
  -- ^ Syntactic hole.
  --
  -- See <https://github.com/haskell-nix/hnix/issues/197> for context.
  --
  -- > NSynHole "x"                                ~  ^x
  deriving
    ( NExprF r -> NExprF r -> Bool
forall r. Eq r => NExprF r -> NExprF r -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NExprF r -> NExprF r -> Bool
$c/= :: forall r. Eq r => NExprF r -> NExprF r -> Bool
== :: NExprF r -> NExprF r -> Bool
$c== :: forall r. Eq r => NExprF r -> NExprF r -> Bool
Eq, NExprF r -> NExprF r -> Ordering
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
forall {r}. Ord r => Eq (NExprF r)
forall r. Ord r => NExprF r -> NExprF r -> Bool
forall r. Ord r => NExprF r -> NExprF r -> Ordering
forall r. Ord r => NExprF r -> NExprF r -> NExprF r
min :: NExprF r -> NExprF r -> NExprF r
$cmin :: forall r. Ord r => NExprF r -> NExprF r -> NExprF r
max :: NExprF r -> NExprF r -> NExprF r
$cmax :: forall r. Ord r => NExprF r -> NExprF r -> NExprF r
>= :: NExprF r -> NExprF r -> Bool
$c>= :: forall r. Ord r => NExprF r -> NExprF r -> Bool
> :: NExprF r -> NExprF r -> Bool
$c> :: forall r. Ord r => NExprF r -> NExprF r -> Bool
<= :: NExprF r -> NExprF r -> Bool
$c<= :: forall r. Ord r => NExprF r -> NExprF r -> Bool
< :: NExprF r -> NExprF r -> Bool
$c< :: forall r. Ord r => NExprF r -> NExprF r -> Bool
compare :: NExprF r -> NExprF r -> Ordering
$ccompare :: forall r. Ord r => NExprF r -> NExprF r -> Ordering
Ord, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall r x. Rep (NExprF r) x -> NExprF r
forall r x. NExprF r -> Rep (NExprF r) x
$cto :: forall r x. Rep (NExprF r) x -> NExprF r
$cfrom :: forall r x. NExprF r -> Rep (NExprF r) x
Generic, forall a. Rep1 NExprF a -> NExprF a
forall a. NExprF a -> Rep1 NExprF a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall a. Rep1 NExprF a -> NExprF a
$cfrom1 :: forall a. NExprF a -> Rep1 NExprF a
Generic1
    , Typeable, NExprF r -> DataType
NExprF r -> Constr
forall {r}. Data r => Typeable (NExprF r)
forall r. Data r => NExprF r -> DataType
forall r. Data r => NExprF r -> Constr
forall r.
Data r =>
(forall b. Data b => b -> b) -> NExprF r -> NExprF r
forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> NExprF r -> u
forall r u.
Data r =>
(forall d. Data d => d -> u) -> NExprF r -> [u]
forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NExprF r -> r
forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NExprF r -> r
forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NExprF r)
forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NExprF r -> c (NExprF r)
forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NExprF r))
forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NExprF r))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NExprF r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NExprF r -> c (NExprF r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NExprF r))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
$cgmapMo :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
$cgmapMp :: forall r (m :: * -> *).
(Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
$cgmapM :: forall r (m :: * -> *).
(Data r, Monad m) =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NExprF r -> u
$cgmapQi :: forall r u.
Data r =>
Int -> (forall d. Data d => d -> u) -> NExprF r -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NExprF r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> NExprF r -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NExprF r -> r
$cgmapQr :: forall r r r'.
Data r =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NExprF r -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NExprF r -> r
$cgmapQl :: forall r r r'.
Data r =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NExprF r -> r
gmapT :: (forall b. Data b => b -> b) -> NExprF r -> NExprF r
$cgmapT :: forall r.
Data r =>
(forall b. Data b => b -> b) -> NExprF r -> NExprF r
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NExprF r))
$cdataCast2 :: forall r (t :: * -> * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NExprF r))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NExprF r))
$cdataCast1 :: forall r (t :: * -> *) (c :: * -> *).
(Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NExprF r))
dataTypeOf :: NExprF r -> DataType
$cdataTypeOf :: forall r. Data r => NExprF r -> DataType
toConstr :: NExprF r -> Constr
$ctoConstr :: forall r. Data r => NExprF r -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NExprF r)
$cgunfold :: forall r (c :: * -> *).
Data r =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NExprF r)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NExprF r -> c (NExprF r)
$cgfoldl :: forall r (c :: * -> *).
Data r =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NExprF r -> c (NExprF r)
Data, forall r. NFData r => NExprF r -> ()
forall a. (a -> ()) -> NFData a
rnf :: NExprF r -> ()
$crnf :: forall r. NFData r => NExprF r -> ()
NFData, forall a. (a -> ()) -> NExprF a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: forall a. (a -> ()) -> NExprF a -> ()
$cliftRnf :: forall a. (a -> ()) -> NExprF a -> ()
NFData1, forall r. Serialise r => [NExprF r] -> Encoding
forall r. Serialise r => NExprF r -> Encoding
forall r s. Serialise r => Decoder s [NExprF r]
forall r s. Serialise r => Decoder s (NExprF r)
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
decodeList :: forall s. Decoder s [NExprF r]
$cdecodeList :: forall r s. Serialise r => Decoder s [NExprF r]
encodeList :: [NExprF r] -> Encoding
$cencodeList :: forall r. Serialise r => [NExprF r] -> Encoding
decode :: forall s. Decoder s (NExprF r)
$cdecode :: forall r s. Serialise r => Decoder s (NExprF r)
encode :: NExprF r -> Encoding
$cencode :: forall r. Serialise r => NExprF r -> Encoding
Serialise, forall r. Binary r => Get (NExprF r)
forall r. Binary r => [NExprF r] -> Put
forall r. Binary r => NExprF r -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [NExprF r] -> Put
$cputList :: forall r. Binary r => [NExprF r] -> Put
get :: Get (NExprF r)
$cget :: forall r. Binary r => Get (NExprF r)
put :: NExprF r -> Put
$cput :: forall r. Binary r => NExprF r -> Put
Binary, forall r. ToJSON r => [NExprF r] -> Encoding
forall r. ToJSON r => [NExprF r] -> Value
forall r. ToJSON r => NExprF r -> Encoding
forall r. ToJSON r => NExprF r -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [NExprF r] -> Encoding
$ctoEncodingList :: forall r. ToJSON r => [NExprF r] -> Encoding
toJSONList :: [NExprF r] -> Value
$ctoJSONList :: forall r. ToJSON r => [NExprF r] -> Value
toEncoding :: NExprF r -> Encoding
$ctoEncoding :: forall r. ToJSON r => NExprF r -> Encoding
toJSON :: NExprF r -> Value
$ctoJSON :: forall r. ToJSON r => NExprF r -> Value
ToJSON, forall r. FromJSON r => Value -> Parser [NExprF r]
forall r. FromJSON r => Value -> Parser (NExprF r)
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NExprF r]
$cparseJSONList :: forall r. FromJSON r => Value -> Parser [NExprF r]
parseJSON :: Value -> Parser (NExprF r)
$cparseJSON :: forall r. FromJSON r => Value -> Parser (NExprF r)
FromJSON
    , forall a b. a -> NExprF b -> NExprF a
forall a b. (a -> b) -> NExprF a -> NExprF b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> NExprF b -> NExprF a
$c<$ :: forall a b. a -> NExprF b -> NExprF a
fmap :: forall a b. (a -> b) -> NExprF a -> NExprF b
$cfmap :: forall a b. (a -> b) -> NExprF a -> NExprF b
Functor, forall a. Eq a => a -> NExprF a -> Bool
forall a. Num a => NExprF a -> a
forall a. Ord a => NExprF a -> a
forall m. Monoid m => NExprF m -> m
forall a. NExprF a -> Bool
forall a. NExprF a -> Int
forall a. NExprF a -> [a]
forall a. (a -> a -> a) -> NExprF a -> a
forall m a. Monoid m => (a -> m) -> NExprF a -> m
forall b a. (b -> a -> b) -> b -> NExprF a -> b
forall a b. (a -> b -> b) -> b -> NExprF a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => NExprF a -> a
$cproduct :: forall a. Num a => NExprF a -> a
sum :: forall a. Num a => NExprF a -> a
$csum :: forall a. Num a => NExprF a -> a
minimum :: forall a. Ord a => NExprF a -> a
$cminimum :: forall a. Ord a => NExprF a -> a
maximum :: forall a. Ord a => NExprF a -> a
$cmaximum :: forall a. Ord a => NExprF a -> a
elem :: forall a. Eq a => a -> NExprF a -> Bool
$celem :: forall a. Eq a => a -> NExprF a -> Bool
length :: forall a. NExprF a -> Int
$clength :: forall a. NExprF a -> Int
null :: forall a. NExprF a -> Bool
$cnull :: forall a. NExprF a -> Bool
toList :: forall a. NExprF a -> [a]
$ctoList :: forall a. NExprF a -> [a]
foldl1 :: forall a. (a -> a -> a) -> NExprF a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NExprF a -> a
foldr1 :: forall a. (a -> a -> a) -> NExprF a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> NExprF a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> NExprF a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NExprF a -> b
foldl :: forall b a. (b -> a -> b) -> b -> NExprF a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NExprF a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> NExprF a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NExprF a -> b
foldr :: forall a b. (a -> b -> b) -> b -> NExprF a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> NExprF a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> NExprF a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NExprF a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> NExprF a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NExprF a -> m
fold :: forall m. Monoid m => NExprF m -> m
$cfold :: forall m. Monoid m => NExprF m -> m
Foldable, Functor NExprF
Foldable NExprF
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => NExprF (m a) -> m (NExprF a)
forall (f :: * -> *) a.
Applicative f =>
NExprF (f a) -> f (NExprF a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NExprF a -> m (NExprF b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NExprF a -> f (NExprF b)
sequence :: forall (m :: * -> *) a. Monad m => NExprF (m a) -> m (NExprF a)
$csequence :: forall (m :: * -> *) a. Monad m => NExprF (m a) -> m (NExprF a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NExprF a -> m (NExprF b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NExprF a -> m (NExprF b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
NExprF (f a) -> f (NExprF a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
NExprF (f a) -> f (NExprF a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NExprF a -> f (NExprF b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NExprF a -> f (NExprF b)
Traversable
    , Int -> NExprF r -> ShowS
forall r. Show r => Int -> NExprF r -> ShowS
forall r. Show r => [NExprF r] -> ShowS
forall r. Show r => NExprF r -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [NExprF r] -> ShowS
$cshowList :: forall r. Show r => [NExprF r] -> ShowS
show :: NExprF r -> FilePath
$cshow :: forall r. Show r => NExprF r -> FilePath
showsPrec :: Int -> NExprF r -> ShowS
$cshowsPrec :: forall r. Show r => Int -> NExprF r -> ShowS
Show, forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall {r}. Hashable r => Eq (NExprF r)
forall r. Hashable r => Int -> NExprF r -> Int
forall r. Hashable r => NExprF r -> Int
hash :: NExprF r -> Int
$chash :: forall r. Hashable r => NExprF r -> Int
hashWithSalt :: Int -> NExprF r -> Int
$chashWithSalt :: forall r. Hashable r => Int -> NExprF r -> Int
Hashable
    )


$(deriveShow1 ''NExprF)
$(deriveEq1   ''NExprF)
$(deriveOrd1  ''NExprF)
--x $(deriveJSON1 defaultOptions ''NExprF)

deriving instance Hashable1 NExprF

-- ** lens traversals

$(makeTraversals ''NExprF)


-- ** type NExpr

-- | The monomorphic expression type is a fixed point of the polymorphic one.
type NExpr = Fix NExprF

-- | We make an `IsString` for expressions, where the string is interpreted
-- as an identifier. This is the most common use-case...
instance IsString NExpr where
  fromString :: FilePath -> NExpr
fromString = forall (f :: * -> *). f (Fix f) -> Fix f
Fix forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r. VarName -> NExprF r
NSym forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IsString a => FilePath -> a
fromString

instance Serialise NExpr

instance TH.Lift NExpr where
  lift :: forall (m :: * -> *). Quote m => NExpr -> m Exp
lift =
    forall (m :: * -> *) a.
(Quote m, Data a) =>
(forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
TH.dataToExpQ
      (\b
b ->
        do
          -- Binding on constructor ensures type match and gives type inference to TH.
          -- Reflection is the ability of a process to examine, introspect, and modify its own structure and behavior.
          -- Reflection is a key strategy in metaprogramming.
          -- <https://en.wikipedia.org/wiki/Reflective_programming>
          Text :~~: b
HRefl <-
            forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
Reflection.eqTypeRep
              (forall {k} (a :: k). Typeable a => TypeRep a
Reflection.typeRep @Text)
              (forall a. Typeable a => a -> TypeRep a
Reflection.typeOf  b
b    )
          forall (f :: * -> *) a. Applicative f => a -> f a
pure [| $(TH.lift b) |]
      )
#if MIN_VERSION_template_haskell(2,17,0)
  liftTyped :: forall (m :: * -> *). Quote m => NExpr -> Code m NExpr
liftTyped = forall a (m :: * -> *). Quote m => m Exp -> Code m a
TH.unsafeCodeCoerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
TH.lift
#elif MIN_VERSION_template_haskell(2,16,0)
  liftTyped = TH.unsafeTExpCoerce . TH.lift
#endif


-- ** Methods

#if __GLASGOW_HASKELL__ >= 900
hashAt
  :: Functor f
  => VarName
  -> (Maybe v -> f (Maybe v))
  -> AttrSet v
  -> f (AttrSet v)
#else
hashAt :: VarName -> Lens' (AttrSet v) (Maybe v)
#endif
hashAt :: forall (f :: * -> *) v.
Functor f =>
VarName -> (Maybe v -> f (Maybe v)) -> AttrSet v -> f (AttrSet v)
hashAt = forall (f :: * -> *) v.
Functor f =>
VarName -> (Maybe v -> f (Maybe v)) -> AttrSet v -> f (AttrSet v)
alterF
 where
  alterF
    :: (Functor f)
    => VarName
    -> (Maybe v -> f (Maybe v))
    -> AttrSet v
    -> f (AttrSet v)
  alterF :: forall (f :: * -> *) v.
Functor f =>
VarName -> (Maybe v -> f (Maybe v)) -> AttrSet v -> f (AttrSet v)
alterF (coerce :: forall a b. Coercible a b => a -> b
coerce -> VarName
k) Maybe v -> f (Maybe v)
f AttrSet v
m =
    forall b a. b -> (a -> b) -> Maybe a -> b
maybe
      (forall k v. (Eq k, Hashable k) => k -> HashMap k v -> HashMap k v
MapL.delete VarName
k AttrSet v
m)
      (\ v
v -> forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
MapL.insert VarName
k v
v AttrSet v
m)
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe v -> f (Maybe v)
f (forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
MapL.lookup VarName
k AttrSet v
m)

-- | Get the name out of the parameter (there might be none).
paramName :: Params r -> Maybe VarName
paramName :: forall r. Params r -> Maybe VarName
paramName (Param VarName
name        ) = forall (f :: * -> *) a. Applicative f => a -> f a
pure VarName
name
paramName (ParamSet Maybe VarName
mname Variadic
_ ParamSet r
_) = Maybe VarName
mname

stringParts :: NString r -> [Antiquoted Text r]
stringParts :: forall r. NString r -> [Antiquoted Text r]
stringParts (DoubleQuoted [Antiquoted Text r]
parts) = [Antiquoted Text r]
parts
stringParts (Indented Int
_   [Antiquoted Text r]
parts) = [Antiquoted Text r]
parts

stripPositionInfo :: NExpr -> NExpr
stripPositionInfo :: NExpr -> NExpr
stripPositionInfo = forall {f :: * -> *} {f :: * -> *}.
Functor f =>
(f (Fix f) -> f (Fix f)) -> Fix f -> Fix f
transport forall {r}. NExprF r -> NExprF r
phi
 where
  transport :: (f (Fix f) -> f (Fix f)) -> Fix f -> Fix f
transport f (Fix f) -> f (Fix f)
f (Fix f (Fix f)
x) = forall (f :: * -> *). f (Fix f) -> Fix f
Fix forall a b. (a -> b) -> a -> b
$ (f (Fix f) -> f (Fix f)) -> Fix f -> Fix f
transport f (Fix f) -> f (Fix f)
f forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (Fix f) -> f (Fix f)
f f (Fix f)
x

  phi :: NExprF r -> NExprF r
phi (NSet Recursivity
recur [Binding r]
binds) = forall r. Recursivity -> [Binding r] -> NExprF r
NSet Recursivity
recur forall a b. (a -> b) -> a -> b
$ forall {r}. Binding r -> Binding r
erasePositions forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Binding r]
binds
  phi (NLet [Binding r]
binds r
body) = forall r. [Binding r] -> r -> NExprF r
NLet (forall {r}. Binding r -> Binding r
erasePositions forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Binding r]
binds) r
body
  phi NExprF r
x                 = NExprF r
x

  erasePositions :: Binding r -> Binding r
erasePositions (NamedVar NAttrPath r
path r
r     NSourcePos
_pos) = forall r. NAttrPath r -> r -> NSourcePos -> Binding r
NamedVar NAttrPath r
path r
r     NSourcePos
nullPos
  erasePositions (Inherit  Maybe r
ms   [VarName]
names NSourcePos
_pos) = forall r. Maybe r -> [VarName] -> NSourcePos -> Binding r
Inherit  Maybe r
ms   [VarName]
names NSourcePos
nullPos

nullPos :: NSourcePos
nullPos :: NSourcePos
nullPos = forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on (Path -> NPos -> NPos -> NSourcePos
NSourcePos Path
"<string>") (coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Pos
mkPos) Int
1 Int
1

-- * Dead code

-- ** class NExprAnn

class NExprAnn ann g | g -> ann where
  fromNExpr :: g r -> (NExprF r, ann)
  toNExpr :: (NExprF r, ann) -> g r

-- ** Other

ekey
  :: forall ann g
  . NExprAnn ann g
  => NonEmpty VarName
  -> NSourcePos
  -> Lens' (Fix g) (Maybe (Fix g))
ekey :: forall ann (g :: * -> *).
NExprAnn ann g =>
NonEmpty VarName -> NSourcePos -> Lens' (Fix g) (Maybe (Fix g))
ekey NonEmpty VarName
keys NSourcePos
pos Maybe (Fix g) -> f (Maybe (Fix g))
f e :: Fix g
e@(Fix g (Fix g)
x)
  | (NSet Recursivity
NonRecursive [Binding (Fix g)]
xs, ann
ann) <- forall ann (g :: * -> *) r.
NExprAnn ann g =>
g r -> (NExprF r, ann)
fromNExpr g (Fix g)
x =
    let
      vals :: [(Fix g, [VarName])]
      vals :: [(Fix g, [VarName])]
vals =
        do
          let keys' :: [VarName]
keys' = forall a. NonEmpty a -> [a]
NE.toList NonEmpty VarName
keys
          ([VarName]
ks, [VarName]
rest) <- forall a b. [a] -> [b] -> [(a, b)]
zip (forall a. [a] -> [[a]]
inits [VarName]
keys') (forall a. [a] -> [[a]]
tails [VarName]
keys')
          forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
handlePresence
            forall a. Monoid a => a
mempty
            (\ (VarName
j : [VarName]
js) ->
              do
                NamedVar NAttrPath (Fix g)
ns Fix g
v NSourcePos
_p <- [Binding (Fix g)]
xs
                forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall a b. (a -> b) -> a -> b
$ (VarName
j forall a. a -> [a] -> [a]
: [VarName]
js) forall a. Eq a => a -> a -> Bool
== (forall a. NonEmpty a -> [a]
NE.toList NAttrPath (Fix g)
ns forall s t a b. s -> Fold s t a b -> [a]
^.. forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {f :: * -> *} {r}.
Applicative f =>
(VarName -> f VarName) -> NKeyName r -> f (NKeyName r)
_StaticKey)
                pure (Fix g
v, [VarName]
rest)
            )
            [VarName]
ks
    in
    case [(Fix g, [VarName])]
vals of
      ((Fix g
v, []      ) : [(Fix g, [VarName])]
_) -> forall a. a -> Maybe a -> a
fromMaybe Fix g
e forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Fix g) -> f (Maybe (Fix g))
f (forall (f :: * -> *) a. Applicative f => a -> f a
pure Fix g
v)
      ((Fix g
v, VarName
r : [VarName]
rest) : [(Fix g, [VarName])]
_) -> forall ann (g :: * -> *).
NExprAnn ann g =>
NonEmpty VarName -> NSourcePos -> Lens' (Fix g) (Maybe (Fix g))
ekey (VarName
r forall a. a -> [a] -> NonEmpty a
:| [VarName]
rest) NSourcePos
pos Maybe (Fix g) -> f (Maybe (Fix g))
f Fix g
v

      [(Fix g, [VarName])]
_                   ->
        forall b a. b -> (a -> b) -> Maybe a -> b
maybe
          Fix g
e
          (\ Fix g
v ->
            let entry :: Binding (Fix g)
entry = forall r. NAttrPath r -> r -> NSourcePos -> Binding r
NamedVar (forall r. VarName -> NKeyName r
StaticKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty VarName
keys) Fix g
v NSourcePos
pos in
            forall (f :: * -> *). f (Fix f) -> Fix f
Fix forall a b. (a -> b) -> a -> b
$ forall ann (g :: * -> *) r.
NExprAnn ann g =>
(NExprF r, ann) -> g r
toNExpr ( forall r. Recursivity -> [Binding r] -> NExprF r
NSet forall a. Monoid a => a
mempty forall a b. (a -> b) -> a -> b
$ forall x. One x => OneItem x -> x
one Binding (Fix g)
entry forall a. Semigroup a => a -> a -> a
<> [Binding (Fix g)]
xs, ann
ann )
          )
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Fix g) -> f (Maybe (Fix g))
f forall a. Maybe a
Nothing
ekey NonEmpty VarName
_ NSourcePos
_ Maybe (Fix g) -> f (Maybe (Fix g))
f Fix g
e = forall a. a -> Maybe a -> a
fromMaybe Fix g
e forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Fix g) -> f (Maybe (Fix g))
f forall a. Maybe a
Nothing


getFreeVars :: NExpr -> Set VarName
getFreeVars :: NExpr -> Set VarName
getFreeVars NExpr
e =
  case forall (f :: * -> *). Fix f -> f (Fix f)
unFix NExpr
e of
    (NConstant    NAtom
_               ) -> forall a. Monoid a => a
mempty
    (NStr         NString NExpr
string          ) -> forall (t :: * -> *). Foldable t => t NExpr -> Set VarName
mapFreeVars NString NExpr
string
    (NSym         VarName
var             ) -> forall x. One x => OneItem x -> x
one VarName
var
    (NList        [NExpr]
list            ) -> forall (t :: * -> *). Foldable t => t NExpr -> Set VarName
mapFreeVars [NExpr]
list
    (NSet   Recursivity
NonRecursive  [Binding NExpr]
bindings) -> forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindFreeVars [Binding NExpr]
bindings
    (NSet   Recursivity
Recursive     [Binding NExpr]
bindings) -> forall a.
(a -> Set VarName) -> (a -> Set VarName) -> a -> Set VarName
diffBetween forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindFreeVars forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindDefs [Binding NExpr]
bindings
    (NLiteralPath Path
_               ) -> forall a. Monoid a => a
mempty
    (NEnvPath     Path
_               ) -> forall a. Monoid a => a
mempty
    (NUnary       NUnaryOp
_    NExpr
expr       ) -> NExpr -> Set VarName
getFreeVars NExpr
expr
    (NApp         NExpr
left NExpr
right      ) -> NExpr -> NExpr -> Set VarName
collectFreeVars NExpr
left NExpr
right
    (NBinary      NBinaryOp
_    NExpr
left NExpr
right ) -> NExpr -> NExpr -> Set VarName
collectFreeVars NExpr
left NExpr
right
    (NSelect      Maybe NExpr
orExpr NExpr
expr NAttrPath NExpr
path) ->
      forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions
        [ NExpr -> Set VarName
getFreeVars NExpr
expr
        , NAttrPath NExpr -> Set VarName
pathFree NAttrPath NExpr
path
        , NExpr -> Set VarName
getFreeVars forall b a. Monoid b => (a -> b) -> Maybe a -> b
`whenJust` Maybe NExpr
orExpr
        ]
    (NHasAttr NExpr
expr            NAttrPath NExpr
path) -> NExpr -> Set VarName
getFreeVars NExpr
expr forall a. Semigroup a => a -> a -> a
<> NAttrPath NExpr -> Set VarName
pathFree NAttrPath NExpr
path
    (NAbs     (Param VarName
varname) NExpr
expr) -> forall a. Ord a => a -> Set a -> Set a
Set.delete VarName
varname (NExpr -> Set VarName
getFreeVars NExpr
expr)
    (NAbs (ParamSet Maybe VarName
varname Variadic
_ ParamSet NExpr
pset) NExpr
expr) ->
      forall a. Ord a => Set a -> Set a -> Set a
Set.difference
        -- Include all free variables from the expression and the default arguments
        (NExpr -> Set VarName
getFreeVars NExpr
expr forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions (NExpr -> Set VarName
getFreeVars forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe forall a b. (a, b) -> b
snd ParamSet NExpr
pset))
        -- But remove the argument name if existing, and all arguments in the parameter set
        ((forall x. One x => OneItem x -> x
one forall b a. Monoid b => (a -> b) -> Maybe a -> b
`whenJust` Maybe VarName
varname) forall a. Semigroup a => a -> a -> a
<> forall a. Ord a => [a] -> Set a
Set.fromList (forall a b. (a, b) -> a
fst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParamSet NExpr
pset))
    (NLet         [Binding NExpr]
bindings NExpr
expr   ) ->
      forall a. Ord a => Set a -> Set a -> Set a
Set.difference
        (NExpr -> Set VarName
getFreeVars NExpr
expr forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindFreeVars [Binding NExpr]
bindings)
        (forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindDefs [Binding NExpr]
bindings)
    (NIf          NExpr
cond NExpr
th   NExpr
el    ) -> forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions forall a b. (a -> b) -> a -> b
$ NExpr -> Set VarName
getFreeVars forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [NExpr
cond, NExpr
th, NExpr
el]
    -- Evaluation is needed to find out whether x is a "real" free variable in `with y; x`, we just include it
    -- This also makes sense because its value can be overridden by `x: with y; x`
    (NWith        NExpr
set  NExpr
expr       ) -> NExpr -> NExpr -> Set VarName
collectFreeVars NExpr
set NExpr
expr
    (NAssert      NExpr
assertion NExpr
expr  ) -> NExpr -> NExpr -> Set VarName
collectFreeVars NExpr
assertion NExpr
expr
    (NSynHole     VarName
_               ) -> forall a. Monoid a => a
mempty
 where
  diffBetween :: (a -> Set VarName) -> (a -> Set VarName) -> a -> Set VarName
  diffBetween :: forall a.
(a -> Set VarName) -> (a -> Set VarName) -> a -> Set VarName
diffBetween a -> Set VarName
g a -> Set VarName
f a
b = forall a. Ord a => Set a -> Set a -> Set a
Set.difference (a -> Set VarName
g a
b) (a -> Set VarName
f a
b)

  collectFreeVars :: NExpr -> NExpr -> Set VarName
  collectFreeVars :: NExpr -> NExpr -> Set VarName
collectFreeVars = forall a. Semigroup a => a -> a -> a
(<>) forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` NExpr -> Set VarName
getFreeVars

  bindDefs :: Foldable t => t (Binding NExpr) -> Set VarName
  bindDefs :: forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindDefs = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall r. Binding r -> Set VarName
bind1Def
   where
    bind1Def :: Binding r -> Set VarName
    bind1Def :: forall r. Binding r -> Set VarName
bind1Def (Inherit   Maybe r
Nothing                  [VarName]
_    NSourcePos
_) = forall a. Monoid a => a
mempty
    bind1Def (Inherit  (Just r
_                 ) [VarName]
keys NSourcePos
_) = forall a. Ord a => [a] -> Set a
Set.fromList [VarName]
keys
    bind1Def (NamedVar (StaticKey  VarName
varname :| [NKeyName r]
_) r
_    NSourcePos
_) = forall x. One x => OneItem x -> x
one VarName
varname
    bind1Def (NamedVar (DynamicKey Antiquoted (NString r) r
_       :| [NKeyName r]
_) r
_    NSourcePos
_) = forall a. Monoid a => a
mempty

  bindFreeVars :: Foldable t => t (Binding NExpr) -> Set VarName
  bindFreeVars :: forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindFreeVars = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Binding NExpr -> Set VarName
bind1Free
   where
    bind1Free :: Binding NExpr -> Set VarName
    bind1Free :: Binding NExpr -> Set VarName
bind1Free (Inherit  Maybe NExpr
Nothing     [VarName]
keys NSourcePos
_) = forall a. Ord a => [a] -> Set a
Set.fromList [VarName]
keys
    bind1Free (Inherit (Just NExpr
scope) [VarName]
_    NSourcePos
_) = NExpr -> Set VarName
getFreeVars NExpr
scope
    bind1Free (NamedVar NAttrPath NExpr
path        NExpr
expr NSourcePos
_) = NAttrPath NExpr -> Set VarName
pathFree NAttrPath NExpr
path forall a. Semigroup a => a -> a -> a
<> NExpr -> Set VarName
getFreeVars NExpr
expr

  pathFree :: NAttrPath NExpr -> Set VarName
  pathFree :: NAttrPath NExpr -> Set VarName
pathFree = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall (t :: * -> *). Foldable t => t NExpr -> Set VarName
mapFreeVars

  mapFreeVars :: Foldable t => t NExpr -> Set VarName
  mapFreeVars :: forall (t :: * -> *). Foldable t => t NExpr -> Set VarName
mapFreeVars = forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap NExpr -> Set VarName
getFreeVars