{-# 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 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            ( SourcePos(SourcePos)
                                                , Pos
                                                , mkPos
                                                , unPos
                                                )
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

--  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 SourcePos@.
type PositionSet = AttrSet SourcePos

-- ** orphan instances

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

-- Upstreaming so far was not pursued.

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

instance Serialise SourcePos where
  encode :: SourcePos -> Encoding
encode (SourcePos FilePath
f Pos
l Pos
c) =
    FilePath -> Encoding
forall a. Serialise a => a -> Encoding
Serialise.encode FilePath
f Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<>
    Pos -> Encoding
forall a. Serialise a => a -> Encoding
Serialise.encode Pos
l Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<>
    Pos -> Encoding
forall a. Serialise a => a -> Encoding
Serialise.encode Pos
c
  decode :: Decoder s SourcePos
decode =
    (FilePath -> Pos -> Pos -> SourcePos)
-> Decoder s FilePath
-> Decoder s Pos
-> Decoder s Pos
-> Decoder s SourcePos
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 FilePath -> Pos -> Pos -> SourcePos
SourcePos
      Decoder s FilePath
forall a s. Serialise a => Decoder s a
Serialise.decode
      Decoder s Pos
forall a s. Serialise a => Decoder s a
Serialise.decode
      Decoder s Pos
forall a s. Serialise a => Decoder s a
Serialise.decode

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

instance Hashable SourcePos where
  hashWithSalt :: Int -> SourcePos -> Int
hashWithSalt Int
salt (SourcePos FilePath
f Pos
l Pos
c) =
    Int
salt
      Int -> FilePath -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` FilePath
f
      Int -> Pos -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` Pos
l
      Int -> Pos -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` Pos
c

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

instance ToJSON Pos where
  toJSON :: Pos -> Value
toJSON = Int -> Value
forall a. ToJSON a => a -> Value
toJSON (Int -> Value) -> (Pos -> Int) -> Pos -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pos -> Int
unPos
instance ToJSON SourcePos

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

-- * 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
(VarName -> VarName -> Bool)
-> (VarName -> VarName -> Bool) -> Eq VarName
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
Eq VarName
-> (VarName -> VarName -> Ordering)
-> (VarName -> VarName -> Bool)
-> (VarName -> VarName -> Bool)
-> (VarName -> VarName -> Bool)
-> (VarName -> VarName -> Bool)
-> (VarName -> VarName -> VarName)
-> (VarName -> VarName -> VarName)
-> Ord 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
$cp1Ord :: Eq VarName
Ord, (forall x. VarName -> Rep VarName x)
-> (forall x. Rep VarName x -> VarName) -> Generic VarName
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
DataType
Constr
Typeable VarName
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VarName -> c VarName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VarName)
-> (VarName -> Constr)
-> (VarName -> DataType)
-> (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))
-> ((forall b. Data b => b -> b) -> VarName -> VarName)
-> (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 u. (forall d. Data d => d -> u) -> VarName -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> VarName -> u)
-> (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 (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarName -> m VarName)
-> Data VarName
VarName -> DataType
VarName -> Constr
(forall b. Data b => b -> b) -> VarName -> VarName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarName -> c VarName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cVarName :: Constr
$tVarName :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> VarName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarName -> u
gmapQ :: (forall d. Data d => d -> u) -> VarName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VarName -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable VarName
Data, VarName -> ()
(VarName -> ()) -> NFData VarName
forall a. (a -> ()) -> NFData a
rnf :: VarName -> ()
$crnf :: VarName -> ()
NFData, [VarName] -> Encoding
VarName -> Encoding
(VarName -> Encoding)
-> (forall s. Decoder s VarName)
-> ([VarName] -> Encoding)
-> (forall s. Decoder s [VarName])
-> Serialise VarName
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 :: Decoder s [VarName]
$cdecodeList :: forall s. Decoder s [VarName]
encodeList :: [VarName] -> Encoding
$cencodeList :: [VarName] -> Encoding
decode :: Decoder s VarName
$cdecode :: forall s. Decoder s VarName
encode :: VarName -> Encoding
$cencode :: VarName -> Encoding
Serialise, Get VarName
[VarName] -> Put
VarName -> Put
(VarName -> Put)
-> Get VarName -> ([VarName] -> Put) -> Binary VarName
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
(VarName -> Value)
-> (VarName -> Encoding)
-> ([VarName] -> Value)
-> ([VarName] -> Encoding)
-> ToJSON VarName
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
(Value -> Parser VarName)
-> (Value -> Parser [VarName]) -> FromJSON 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
(Int -> VarName -> ShowS)
-> (VarName -> FilePath) -> ([VarName] -> ShowS) -> Show VarName
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]
(Int -> ReadS VarName)
-> ReadS [VarName]
-> ReadPrec VarName
-> ReadPrec [VarName]
-> Read 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, Int -> VarName -> Int
VarName -> Int
(Int -> VarName -> Int) -> (VarName -> Int) -> Hashable VarName
forall 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 = Text -> VarName
coerce (Text -> VarName) -> (FilePath -> Text) -> FilePath -> VarName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IsString Text => FilePath -> Text
forall a. IsString a => FilePath -> a
fromString @Text

instance ToString VarName where
  toString :: VarName -> FilePath
toString = ToString Text => Text -> FilePath
forall a. ToString a => a -> FilePath
toString @Text (Text -> FilePath) -> (VarName -> Text) -> VarName -> FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VarName -> Text
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
(Variadic -> Variadic -> Bool)
-> (Variadic -> Variadic -> Bool) -> Eq Variadic
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
Eq Variadic
-> (Variadic -> Variadic -> Ordering)
-> (Variadic -> Variadic -> Bool)
-> (Variadic -> Variadic -> Bool)
-> (Variadic -> Variadic -> Bool)
-> (Variadic -> Variadic -> Bool)
-> (Variadic -> Variadic -> Variadic)
-> (Variadic -> Variadic -> Variadic)
-> Ord 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
$cp1Ord :: Eq Variadic
Ord, (forall x. Variadic -> Rep Variadic x)
-> (forall x. Rep Variadic x -> Variadic) -> Generic Variadic
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
DataType
Constr
Typeable Variadic
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Variadic -> c Variadic)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Variadic)
-> (Variadic -> Constr)
-> (Variadic -> DataType)
-> (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))
-> ((forall b. Data b => b -> b) -> Variadic -> Variadic)
-> (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 u. (forall d. Data d => d -> u) -> Variadic -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Variadic -> u)
-> (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 (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Variadic -> m Variadic)
-> Data Variadic
Variadic -> DataType
Variadic -> Constr
(forall b. Data b => b -> b) -> Variadic -> Variadic
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Variadic -> c Variadic
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cVariadic :: Constr
$cClosed :: Constr
$tVariadic :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> Variadic -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Variadic -> u
gmapQ :: (forall d. Data d => d -> u) -> Variadic -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Variadic -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable Variadic
Data, Variadic -> ()
(Variadic -> ()) -> NFData Variadic
forall a. (a -> ()) -> NFData a
rnf :: Variadic -> ()
$crnf :: Variadic -> ()
NFData, [Variadic] -> Encoding
Variadic -> Encoding
(Variadic -> Encoding)
-> (forall s. Decoder s Variadic)
-> ([Variadic] -> Encoding)
-> (forall s. Decoder s [Variadic])
-> Serialise Variadic
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 :: Decoder s [Variadic]
$cdecodeList :: forall s. Decoder s [Variadic]
encodeList :: [Variadic] -> Encoding
$cencodeList :: [Variadic] -> Encoding
decode :: Decoder s Variadic
$cdecode :: forall s. Decoder s Variadic
encode :: Variadic -> Encoding
$cencode :: Variadic -> Encoding
Serialise, Get Variadic
[Variadic] -> Put
Variadic -> Put
(Variadic -> Put)
-> Get Variadic -> ([Variadic] -> Put) -> Binary Variadic
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
(Variadic -> Value)
-> (Variadic -> Encoding)
-> ([Variadic] -> Value)
-> ([Variadic] -> Encoding)
-> ToJSON Variadic
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
(Value -> Parser Variadic)
-> (Value -> Parser [Variadic]) -> FromJSON 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
(Int -> Variadic -> ShowS)
-> (Variadic -> FilePath) -> ([Variadic] -> ShowS) -> Show Variadic
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]
(Int -> ReadS Variadic)
-> ReadS [Variadic]
-> ReadPrec Variadic
-> ReadPrec [Variadic]
-> Read 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, Int -> Variadic -> Int
Variadic -> Int
(Int -> Variadic -> Int) -> (Variadic -> Int) -> Hashable Variadic
forall 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
(Params r -> Params r -> Bool)
-> (Params r -> Params r -> Bool) -> Eq (Params r)
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, Eq (Params r)
Eq (Params r)
-> (Params r -> Params r -> Ordering)
-> (Params r -> Params r -> Bool)
-> (Params r -> Params r -> Bool)
-> (Params r -> Params r -> Bool)
-> (Params r -> Params r -> Bool)
-> (Params r -> Params r -> Params r)
-> (Params r -> Params r -> Params r)
-> Ord (Params r)
Params r -> Params r -> Bool
Params r -> Params r -> Ordering
Params r -> Params r -> Params r
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
$cp1Ord :: forall r. Ord r => Eq (Params r)
Ord, (forall x. Params r -> Rep (Params r) x)
-> (forall x. Rep (Params r) x -> Params r) -> Generic (Params r)
forall x. Rep (Params r) x -> Params r
forall x. Params r -> Rep (Params r) x
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. Params a -> Rep1 Params a)
-> (forall a. Rep1 Params a -> Params a) -> Generic1 Params
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, Typeable (Params r)
DataType
Constr
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Params r))
-> (Params r -> Constr)
-> (Params r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Params r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Params r)))
-> ((forall b. Data b => b -> b) -> Params r -> Params r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Params r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Params r -> r)
-> (forall u. (forall d. Data d => d -> u) -> Params r -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Params r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Params r -> m (Params r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Params r -> m (Params r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Params r -> m (Params r))
-> Data (Params r)
Params r -> DataType
Params r -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Params r))
(forall b. Data b => b -> b) -> Params r -> Params r
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Params r -> c (Params r)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Params r)
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 u. Int -> (forall d. Data d => d -> u) -> Params r -> u
forall u. (forall d. Data d => d -> u) -> Params r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Params r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Params r -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Params r -> m (Params r)
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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Params r))
$cParamSet :: Constr
$cParam :: Constr
$tParams :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Params r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> Params r -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall r. Data r => Typeable (Params r)
Data, Params r -> ()
(Params r -> ()) -> NFData (Params r)
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 -> ()) -> NFData1 Params
forall a. (a -> ()) -> Params a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: (a -> ()) -> Params a -> ()
$cliftRnf :: forall a. (a -> ()) -> Params a -> ()
NFData1, [Params r] -> Encoding
Params r -> Encoding
(Params r -> Encoding)
-> (forall s. Decoder s (Params r))
-> ([Params r] -> Encoding)
-> (forall s. Decoder s [Params r])
-> Serialise (Params r)
forall s. Decoder s [Params r]
forall s. Decoder s (Params r)
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 :: 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 :: 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, Get (Params r)
[Params r] -> Put
Params r -> Put
(Params r -> Put)
-> Get (Params r) -> ([Params r] -> Put) -> Binary (Params r)
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, [Params r] -> Encoding
[Params r] -> Value
Params r -> Encoding
Params r -> Value
(Params r -> Value)
-> (Params r -> Encoding)
-> ([Params r] -> Value)
-> ([Params r] -> Encoding)
-> ToJSON (Params r)
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 -> Value) -> ([a] -> Value) -> Params a -> Value)
-> (forall a.
    (a -> Value) -> ([a] -> Value) -> [Params a] -> Value)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> Params a -> Encoding)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> [Params a] -> Encoding)
-> ToJSON1 Params
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 :: (a -> Encoding) -> ([a] -> Encoding) -> [Params a] -> Encoding
$cliftToEncodingList :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> [Params a] -> Encoding
liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Params a -> Encoding
$cliftToEncoding :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> Params a -> Encoding
liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Params a] -> Value
$cliftToJSONList :: forall a. (a -> Value) -> ([a] -> Value) -> [Params a] -> Value
liftToJSON :: (a -> Value) -> ([a] -> Value) -> Params a -> Value
$cliftToJSON :: forall a. (a -> Value) -> ([a] -> Value) -> Params a -> Value
ToJSON1, Value -> Parser [Params r]
Value -> Parser (Params r)
(Value -> Parser (Params r))
-> (Value -> Parser [Params r]) -> FromJSON (Params r)
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])
-> FromJSON1 Params
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 :: (Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [Params a]
$cliftParseJSONList :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [Params a]
liftParseJSON :: (Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (Params a)
$cliftParseJSON :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (Params a)
FromJSON1
    , a -> Params b -> Params a
(a -> b) -> Params a -> Params b
(forall a b. (a -> b) -> Params a -> Params b)
-> (forall a b. a -> Params b -> Params a) -> Functor Params
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
<$ :: a -> Params b -> Params a
$c<$ :: forall a b. a -> Params b -> Params a
fmap :: (a -> b) -> Params a -> Params b
$cfmap :: forall a b. (a -> b) -> Params a -> Params b
Functor, Params a -> Bool
(a -> m) -> Params a -> m
(a -> b -> b) -> b -> Params a -> b
(forall m. Monoid m => Params m -> m)
-> (forall m a. Monoid m => (a -> m) -> Params a -> m)
-> (forall m a. Monoid m => (a -> m) -> Params a -> m)
-> (forall a b. (a -> b -> b) -> b -> Params a -> b)
-> (forall a b. (a -> b -> b) -> b -> Params a -> b)
-> (forall b a. (b -> a -> b) -> b -> Params a -> b)
-> (forall b a. (b -> a -> b) -> b -> Params a -> b)
-> (forall a. (a -> a -> a) -> Params a -> a)
-> (forall a. (a -> a -> a) -> Params a -> a)
-> (forall a. Params a -> [a])
-> (forall a. Params a -> Bool)
-> (forall a. Params a -> Int)
-> (forall a. Eq a => a -> Params a -> Bool)
-> (forall a. Ord a => Params a -> a)
-> (forall a. Ord a => Params a -> a)
-> (forall a. Num a => Params a -> a)
-> (forall a. Num a => Params a -> a)
-> Foldable Params
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 :: Params a -> a
$cproduct :: forall a. Num a => Params a -> a
sum :: Params a -> a
$csum :: forall a. Num a => Params a -> a
minimum :: Params a -> a
$cminimum :: forall a. Ord a => Params a -> a
maximum :: Params a -> a
$cmaximum :: forall a. Ord a => Params a -> a
elem :: a -> Params a -> Bool
$celem :: forall a. Eq a => a -> Params a -> Bool
length :: Params a -> Int
$clength :: forall a. Params a -> Int
null :: Params a -> Bool
$cnull :: forall a. Params a -> Bool
toList :: Params a -> [a]
$ctoList :: forall a. Params a -> [a]
foldl1 :: (a -> a -> a) -> Params a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Params a -> a
foldr1 :: (a -> a -> a) -> Params a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Params a -> a
foldl' :: (b -> a -> b) -> b -> Params a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Params a -> b
foldl :: (b -> a -> b) -> b -> Params a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Params a -> b
foldr' :: (a -> b -> b) -> b -> Params a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Params a -> b
foldr :: (a -> b -> b) -> b -> Params a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Params a -> b
foldMap' :: (a -> m) -> Params a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Params a -> m
foldMap :: (a -> m) -> Params a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Params a -> m
fold :: Params m -> m
$cfold :: forall m. Monoid m => Params m -> m
Foldable, Functor Params
Foldable Params
Functor Params
-> Foldable Params
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Params a -> f (Params b))
-> (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 (m :: * -> *) a.
    Monad m =>
    Params (m a) -> m (Params a))
-> Traversable Params
(a -> f b) -> Params a -> f (Params b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => 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 :: Params (m a) -> m (Params a)
$csequence :: forall (m :: * -> *) a. Monad m => Params (m a) -> m (Params a)
mapM :: (a -> m b) -> Params a -> m (Params b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Params a -> m (Params b)
sequenceA :: Params (f a) -> f (Params a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Params (f a) -> f (Params a)
traverse :: (a -> f b) -> Params a -> f (Params b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Params a -> f (Params b)
$cp2Traversable :: Foldable Params
$cp1Traversable :: Functor Params
Traversable
    , Int -> Params r -> ShowS
[Params r] -> ShowS
Params r -> FilePath
(Int -> Params r -> ShowS)
-> (Params r -> FilePath)
-> ([Params r] -> ShowS)
-> Show (Params r)
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, Int -> Params r -> Int
Params r -> Int
(Int -> Params r -> Int)
-> (Params r -> Int) -> Hashable (Params r)
forall r. Hashable r => Int -> Params r -> Int
forall r. Hashable r => Params r -> Int
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
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 = VarName -> Params r
forall r. VarName -> Params r
Param (VarName -> Params r)
-> (FilePath -> VarName) -> FilePath -> Params r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> VarName
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
(Antiquoted v r -> Antiquoted v r -> Bool)
-> (Antiquoted v r -> Antiquoted v r -> Bool)
-> Eq (Antiquoted v r)
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, Eq (Antiquoted v r)
Eq (Antiquoted v r)
-> (Antiquoted v r -> Antiquoted v r -> Ordering)
-> (Antiquoted v r -> Antiquoted v r -> Bool)
-> (Antiquoted v r -> Antiquoted v r -> Bool)
-> (Antiquoted v r -> Antiquoted v r -> Bool)
-> (Antiquoted v r -> Antiquoted v r -> Bool)
-> (Antiquoted v r -> Antiquoted v r -> Antiquoted v r)
-> (Antiquoted v r -> Antiquoted v r -> Antiquoted v r)
-> Ord (Antiquoted v r)
Antiquoted v r -> Antiquoted v r -> Bool
Antiquoted v r -> Antiquoted v r -> Ordering
Antiquoted v r -> Antiquoted v r -> Antiquoted v r
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
$cp1Ord :: forall v r. (Ord v, Ord r) => Eq (Antiquoted v r)
Ord, (forall x. Antiquoted v r -> Rep (Antiquoted v r) x)
-> (forall x. Rep (Antiquoted v r) x -> Antiquoted v r)
-> Generic (Antiquoted v r)
forall x. Rep (Antiquoted v r) x -> Antiquoted v r
forall x. Antiquoted v r -> Rep (Antiquoted v r) x
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 a. Antiquoted v a -> Rep1 (Antiquoted v) a)
-> (forall a. Rep1 (Antiquoted v) a -> Antiquoted v a)
-> Generic1 (Antiquoted v)
forall a. Rep1 (Antiquoted v) a -> Antiquoted v a
forall a. Antiquoted v a -> Rep1 (Antiquoted v) a
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, Typeable (Antiquoted v r)
DataType
Constr
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Antiquoted v r))
-> (Antiquoted v r -> Constr)
-> (Antiquoted v r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (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)))
-> ((forall b. Data b => b -> b)
    -> Antiquoted v r -> Antiquoted v r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Antiquoted v r -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Antiquoted v r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Antiquoted v r -> m (Antiquoted v r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Antiquoted v r -> m (Antiquoted v r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Antiquoted v r -> m (Antiquoted v r))
-> Data (Antiquoted v r)
Antiquoted v r -> DataType
Antiquoted v r -> Constr
(forall b. Data b => b -> b) -> Antiquoted v r -> Antiquoted v 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 b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Antiquoted v r)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Antiquoted v 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 u.
Int -> (forall d. Data d => d -> u) -> Antiquoted v r -> u
forall u. (forall d. Data d => d -> u) -> Antiquoted v r -> [u]
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 r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Antiquoted v r -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (Antiquoted v r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Antiquoted v r -> m (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. Data d => c (t d)) -> Maybe (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))
$cAntiquoted :: Constr
$cEscapedNewline :: Constr
$cPlain :: Constr
$tAntiquoted :: DataType
gmapMo :: (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 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 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 :: 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 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 :: (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 :: (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 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 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 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 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)
$cp1Data :: forall v r. (Data v, Data r) => Typeable (Antiquoted v r)
Data, Antiquoted v r -> ()
(Antiquoted v r -> ()) -> NFData (Antiquoted v r)
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 a. (a -> ()) -> Antiquoted v a -> ())
-> NFData1 (Antiquoted v)
forall v a. NFData v => (a -> ()) -> Antiquoted v a -> ()
forall a. (a -> ()) -> Antiquoted v a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: (a -> ()) -> Antiquoted v a -> ()
$cliftRnf :: forall v a. NFData v => (a -> ()) -> Antiquoted v a -> ()
NFData1, [Antiquoted v r] -> Encoding
Antiquoted v r -> Encoding
(Antiquoted v r -> Encoding)
-> (forall s. Decoder s (Antiquoted v r))
-> ([Antiquoted v r] -> Encoding)
-> (forall s. Decoder s [Antiquoted v r])
-> Serialise (Antiquoted v r)
forall s. Decoder s [Antiquoted v r]
forall s. Decoder s (Antiquoted v r)
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 :: 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 :: 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, Get (Antiquoted v r)
[Antiquoted v r] -> Put
Antiquoted v r -> Put
(Antiquoted v r -> Put)
-> Get (Antiquoted v r)
-> ([Antiquoted v r] -> Put)
-> Binary (Antiquoted v r)
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
    , [Antiquoted v r] -> Encoding
[Antiquoted v r] -> Value
Antiquoted v r -> Encoding
Antiquoted v r -> Value
(Antiquoted v r -> Value)
-> (Antiquoted v r -> Encoding)
-> ([Antiquoted v r] -> Value)
-> ([Antiquoted v r] -> Encoding)
-> ToJSON (Antiquoted v r)
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 a.
 (a -> Value) -> ([a] -> Value) -> Antiquoted v a -> Value)
-> (forall a.
    (a -> Value) -> ([a] -> Value) -> [Antiquoted v a] -> Value)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> Antiquoted v a -> Encoding)
-> (forall a.
    (a -> Encoding)
    -> ([a] -> Encoding) -> [Antiquoted v a] -> Encoding)
-> ToJSON1 (Antiquoted v)
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 a.
(a -> Encoding)
-> ([a] -> Encoding) -> [Antiquoted v a] -> Encoding
forall a.
(a -> Encoding) -> ([a] -> Encoding) -> Antiquoted v a -> Encoding
forall a.
(a -> Value) -> ([a] -> Value) -> [Antiquoted v a] -> Value
forall a. (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 :: (a -> Encoding)
-> ([a] -> Encoding) -> [Antiquoted v a] -> Encoding
$cliftToEncodingList :: forall v a.
ToJSON v =>
(a -> Encoding)
-> ([a] -> Encoding) -> [Antiquoted v a] -> Encoding
liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Antiquoted v a -> Encoding
$cliftToEncoding :: forall v a.
ToJSON v =>
(a -> Encoding) -> ([a] -> Encoding) -> Antiquoted v a -> Encoding
liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Antiquoted v a] -> Value
$cliftToJSONList :: forall v a.
ToJSON v =>
(a -> Value) -> ([a] -> Value) -> [Antiquoted v a] -> Value
liftToJSON :: (a -> Value) -> ([a] -> Value) -> Antiquoted v a -> Value
$cliftToJSON :: forall v a.
ToJSON v =>
(a -> Value) -> ([a] -> Value) -> Antiquoted v a -> Value
ToJSON1, Value -> Parser [Antiquoted v r]
Value -> Parser (Antiquoted v r)
(Value -> Parser (Antiquoted v r))
-> (Value -> Parser [Antiquoted v r]) -> FromJSON (Antiquoted v r)
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 a.
 (Value -> Parser a)
 -> (Value -> Parser [a]) -> Value -> Parser (Antiquoted v a))
-> (forall a.
    (Value -> Parser a)
    -> (Value -> Parser [a]) -> Value -> Parser [Antiquoted v a])
-> FromJSON1 (Antiquoted v)
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 a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [Antiquoted v a]
forall a.
(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 :: (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 :: (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
    , a -> Antiquoted v b -> Antiquoted v a
(a -> b) -> Antiquoted v a -> Antiquoted v b
(forall a b. (a -> b) -> Antiquoted v a -> Antiquoted v b)
-> (forall a b. a -> Antiquoted v b -> Antiquoted v a)
-> Functor (Antiquoted v)
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
<$ :: a -> Antiquoted v b -> Antiquoted v a
$c<$ :: forall v a b. a -> Antiquoted v b -> Antiquoted v a
fmap :: (a -> b) -> Antiquoted v a -> Antiquoted v b
$cfmap :: forall v a b. (a -> b) -> Antiquoted v a -> Antiquoted v b
Functor, Antiquoted v a -> Bool
(a -> m) -> Antiquoted v a -> m
(a -> b -> b) -> b -> Antiquoted v a -> b
(forall m. Monoid m => Antiquoted v m -> m)
-> (forall m a. Monoid m => (a -> m) -> Antiquoted v a -> m)
-> (forall m a. Monoid m => (a -> m) -> Antiquoted v a -> m)
-> (forall a b. (a -> b -> b) -> b -> Antiquoted v a -> b)
-> (forall a b. (a -> b -> b) -> b -> Antiquoted v a -> b)
-> (forall b a. (b -> a -> b) -> b -> Antiquoted v a -> b)
-> (forall b a. (b -> a -> b) -> b -> Antiquoted v a -> b)
-> (forall a. (a -> a -> a) -> Antiquoted v a -> a)
-> (forall a. (a -> a -> a) -> Antiquoted v a -> a)
-> (forall a. Antiquoted v a -> [a])
-> (forall a. Antiquoted v a -> Bool)
-> (forall a. Antiquoted v a -> Int)
-> (forall a. Eq a => a -> Antiquoted v a -> Bool)
-> (forall a. Ord a => Antiquoted v a -> a)
-> (forall a. Ord a => Antiquoted v a -> a)
-> (forall a. Num a => Antiquoted v a -> a)
-> (forall a. Num a => Antiquoted v a -> a)
-> Foldable (Antiquoted v)
forall a. Eq a => a -> Antiquoted v a -> Bool
forall a. Num a => Antiquoted v a -> a
forall a. Ord a => Antiquoted v a -> a
forall m. Monoid m => Antiquoted v m -> m
forall a. Antiquoted v a -> Bool
forall a. Antiquoted v a -> Int
forall a. Antiquoted v a -> [a]
forall a. (a -> a -> a) -> Antiquoted v a -> a
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 b a. (b -> a -> b) -> b -> Antiquoted v a -> b
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 :: Antiquoted v a -> a
$cproduct :: forall v a. Num a => Antiquoted v a -> a
sum :: Antiquoted v a -> a
$csum :: forall v a. Num a => Antiquoted v a -> a
minimum :: Antiquoted v a -> a
$cminimum :: forall v a. Ord a => Antiquoted v a -> a
maximum :: Antiquoted v a -> a
$cmaximum :: forall v a. Ord a => Antiquoted v a -> a
elem :: a -> Antiquoted v a -> Bool
$celem :: forall v a. Eq a => a -> Antiquoted v a -> Bool
length :: Antiquoted v a -> Int
$clength :: forall v a. Antiquoted v a -> Int
null :: Antiquoted v a -> Bool
$cnull :: forall v a. Antiquoted v a -> Bool
toList :: Antiquoted v a -> [a]
$ctoList :: forall v a. Antiquoted v a -> [a]
foldl1 :: (a -> a -> a) -> Antiquoted v a -> a
$cfoldl1 :: forall v a. (a -> a -> a) -> Antiquoted v a -> a
foldr1 :: (a -> a -> a) -> Antiquoted v a -> a
$cfoldr1 :: forall v a. (a -> a -> a) -> Antiquoted v a -> a
foldl' :: (b -> a -> b) -> b -> Antiquoted v a -> b
$cfoldl' :: forall v b a. (b -> a -> b) -> b -> Antiquoted v a -> b
foldl :: (b -> a -> b) -> b -> Antiquoted v a -> b
$cfoldl :: forall v b a. (b -> a -> b) -> b -> Antiquoted v a -> b
foldr' :: (a -> b -> b) -> b -> Antiquoted v a -> b
$cfoldr' :: forall v a b. (a -> b -> b) -> b -> Antiquoted v a -> b
foldr :: (a -> b -> b) -> b -> Antiquoted v a -> b
$cfoldr :: forall v a b. (a -> b -> b) -> b -> Antiquoted v a -> b
foldMap' :: (a -> m) -> Antiquoted v a -> m
$cfoldMap' :: forall v m a. Monoid m => (a -> m) -> Antiquoted v a -> m
foldMap :: (a -> m) -> Antiquoted v a -> m
$cfoldMap :: forall v m a. Monoid m => (a -> m) -> Antiquoted v a -> m
fold :: Antiquoted v m -> m
$cfold :: forall v m. Monoid m => Antiquoted v m -> m
Foldable, Functor (Antiquoted v)
Foldable (Antiquoted v)
Functor (Antiquoted v)
-> Foldable (Antiquoted v)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Antiquoted v a -> f (Antiquoted v b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Antiquoted v (f a) -> f (Antiquoted v a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Antiquoted v a -> m (Antiquoted v b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Antiquoted v (m a) -> m (Antiquoted v a))
-> Traversable (Antiquoted v)
(a -> f b) -> Antiquoted v a -> f (Antiquoted v b)
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 (m :: * -> *) a.
Monad m =>
Antiquoted v (m a) -> m (Antiquoted v a)
forall (f :: * -> *) a.
Applicative f =>
Antiquoted v (f a) -> f (Antiquoted v a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Antiquoted v a -> m (Antiquoted v b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Antiquoted v a -> f (Antiquoted v b)
sequence :: Antiquoted v (m a) -> m (Antiquoted v a)
$csequence :: forall v (m :: * -> *) a.
Monad m =>
Antiquoted v (m a) -> m (Antiquoted v a)
mapM :: (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 :: Antiquoted v (f a) -> f (Antiquoted v a)
$csequenceA :: forall v (f :: * -> *) a.
Applicative f =>
Antiquoted v (f a) -> f (Antiquoted v a)
traverse :: (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)
$cp2Traversable :: forall v. Foldable (Antiquoted v)
$cp1Traversable :: forall v. Functor (Antiquoted v)
Traversable
    , Int -> Antiquoted v r -> ShowS
[Antiquoted v r] -> ShowS
Antiquoted v r -> FilePath
(Int -> Antiquoted v r -> ShowS)
-> (Antiquoted v r -> FilePath)
-> ([Antiquoted v r] -> ShowS)
-> Show (Antiquoted v r)
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)
Int -> ReadS (Antiquoted v r)
ReadS [Antiquoted v r]
(Int -> ReadS (Antiquoted v r))
-> ReadS [Antiquoted v r]
-> ReadPrec (Antiquoted v r)
-> ReadPrec [Antiquoted v r]
-> Read (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, Int -> Antiquoted v r -> Int
Antiquoted v r -> Int
(Int -> Antiquoted v r -> Int)
-> (Antiquoted v r -> Int) -> Hashable (Antiquoted v r)
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
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 :: (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 Int -> Int -> Int
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 Int -> Int -> Int
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 Int -> Int -> Int
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
(NString r -> NString r -> Bool)
-> (NString r -> NString r -> Bool) -> Eq (NString r)
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, Eq (NString r)
Eq (NString r)
-> (NString r -> NString r -> Ordering)
-> (NString r -> NString r -> Bool)
-> (NString r -> NString r -> Bool)
-> (NString r -> NString r -> Bool)
-> (NString r -> NString r -> Bool)
-> (NString r -> NString r -> NString r)
-> (NString r -> NString r -> NString r)
-> Ord (NString r)
NString r -> NString r -> Bool
NString r -> NString r -> Ordering
NString r -> NString r -> NString r
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
$cp1Ord :: forall r. Ord r => Eq (NString r)
Ord, (forall x. NString r -> Rep (NString r) x)
-> (forall x. Rep (NString r) x -> NString r)
-> Generic (NString r)
forall x. Rep (NString r) x -> NString r
forall x. NString r -> Rep (NString r) x
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. NString a -> Rep1 NString a)
-> (forall a. Rep1 NString a -> NString a) -> Generic1 NString
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, Typeable (NString r)
DataType
Constr
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NString r))
-> (NString r -> Constr)
-> (NString r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NString r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NString r)))
-> ((forall b. Data b => b -> b) -> NString r -> NString r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NString r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NString r -> r)
-> (forall u. (forall d. Data d => d -> u) -> NString r -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NString r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NString r -> m (NString r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NString r -> m (NString r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NString r -> m (NString r))
-> Data (NString r)
NString r -> DataType
NString r -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (NString r))
(forall b. Data b => b -> b) -> NString r -> NString r
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NString r -> c (NString r)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NString r)
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 u. Int -> (forall d. Data d => d -> u) -> NString r -> u
forall u. (forall d. Data d => d -> u) -> NString r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NString r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NString r -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NString r -> m (NString r)
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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NString r))
$cIndented :: Constr
$cDoubleQuoted :: Constr
$tNString :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> NString r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> NString r -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall r. Data r => Typeable (NString r)
Data, NString r -> ()
(NString r -> ()) -> NFData (NString r)
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 -> ()) -> NFData1 NString
forall a. (a -> ()) -> NString a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: (a -> ()) -> NString a -> ()
$cliftRnf :: forall a. (a -> ()) -> NString a -> ()
NFData1, [NString r] -> Encoding
NString r -> Encoding
(NString r -> Encoding)
-> (forall s. Decoder s (NString r))
-> ([NString r] -> Encoding)
-> (forall s. Decoder s [NString r])
-> Serialise (NString r)
forall s. Decoder s [NString r]
forall s. Decoder s (NString r)
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 :: 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 :: 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, Get (NString r)
[NString r] -> Put
NString r -> Put
(NString r -> Put)
-> Get (NString r) -> ([NString r] -> Put) -> Binary (NString r)
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, [NString r] -> Encoding
[NString r] -> Value
NString r -> Encoding
NString r -> Value
(NString r -> Value)
-> (NString r -> Encoding)
-> ([NString r] -> Value)
-> ([NString r] -> Encoding)
-> ToJSON (NString r)
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 -> Value) -> ([a] -> Value) -> NString a -> Value)
-> (forall a.
    (a -> Value) -> ([a] -> Value) -> [NString a] -> Value)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> NString a -> Encoding)
-> (forall a.
    (a -> Encoding) -> ([a] -> Encoding) -> [NString a] -> Encoding)
-> ToJSON1 NString
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 :: (a -> Encoding) -> ([a] -> Encoding) -> [NString a] -> Encoding
$cliftToEncodingList :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> [NString a] -> Encoding
liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> NString a -> Encoding
$cliftToEncoding :: forall a.
(a -> Encoding) -> ([a] -> Encoding) -> NString a -> Encoding
liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [NString a] -> Value
$cliftToJSONList :: forall a. (a -> Value) -> ([a] -> Value) -> [NString a] -> Value
liftToJSON :: (a -> Value) -> ([a] -> Value) -> NString a -> Value
$cliftToJSON :: forall a. (a -> Value) -> ([a] -> Value) -> NString a -> Value
ToJSON1, Value -> Parser [NString r]
Value -> Parser (NString r)
(Value -> Parser (NString r))
-> (Value -> Parser [NString r]) -> FromJSON (NString r)
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])
-> FromJSON1 NString
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 :: (Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [NString a]
$cliftParseJSONList :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser [NString a]
liftParseJSON :: (Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (NString a)
$cliftParseJSON :: forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Value -> Parser (NString a)
FromJSON1
    , a -> NString b -> NString a
(a -> b) -> NString a -> NString b
(forall a b. (a -> b) -> NString a -> NString b)
-> (forall a b. a -> NString b -> NString a) -> Functor NString
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
<$ :: a -> NString b -> NString a
$c<$ :: forall a b. a -> NString b -> NString a
fmap :: (a -> b) -> NString a -> NString b
$cfmap :: forall a b. (a -> b) -> NString a -> NString b
Functor, NString a -> Bool
(a -> m) -> NString a -> m
(a -> b -> b) -> b -> NString a -> b
(forall m. Monoid m => NString m -> m)
-> (forall m a. Monoid m => (a -> m) -> NString a -> m)
-> (forall m a. Monoid m => (a -> m) -> NString a -> m)
-> (forall a b. (a -> b -> b) -> b -> NString a -> b)
-> (forall a b. (a -> b -> b) -> b -> NString a -> b)
-> (forall b a. (b -> a -> b) -> b -> NString a -> b)
-> (forall b a. (b -> a -> b) -> b -> NString a -> b)
-> (forall a. (a -> a -> a) -> NString a -> a)
-> (forall a. (a -> a -> a) -> NString a -> a)
-> (forall a. NString a -> [a])
-> (forall a. NString a -> Bool)
-> (forall a. NString a -> Int)
-> (forall a. Eq a => a -> NString a -> Bool)
-> (forall a. Ord a => NString a -> a)
-> (forall a. Ord a => NString a -> a)
-> (forall a. Num a => NString a -> a)
-> (forall a. Num a => NString a -> a)
-> Foldable NString
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 :: NString a -> a
$cproduct :: forall a. Num a => NString a -> a
sum :: NString a -> a
$csum :: forall a. Num a => NString a -> a
minimum :: NString a -> a
$cminimum :: forall a. Ord a => NString a -> a
maximum :: NString a -> a
$cmaximum :: forall a. Ord a => NString a -> a
elem :: a -> NString a -> Bool
$celem :: forall a. Eq a => a -> NString a -> Bool
length :: NString a -> Int
$clength :: forall a. NString a -> Int
null :: NString a -> Bool
$cnull :: forall a. NString a -> Bool
toList :: NString a -> [a]
$ctoList :: forall a. NString a -> [a]
foldl1 :: (a -> a -> a) -> NString a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NString a -> a
foldr1 :: (a -> a -> a) -> NString a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> NString a -> a
foldl' :: (b -> a -> b) -> b -> NString a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NString a -> b
foldl :: (b -> a -> b) -> b -> NString a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NString a -> b
foldr' :: (a -> b -> b) -> b -> NString a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NString a -> b
foldr :: (a -> b -> b) -> b -> NString a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> NString a -> b
foldMap' :: (a -> m) -> NString a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NString a -> m
foldMap :: (a -> m) -> NString a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NString a -> m
fold :: NString m -> m
$cfold :: forall m. Monoid m => NString m -> m
Foldable, Functor NString
Foldable NString
Functor NString
-> Foldable NString
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> NString a -> f (NString b))
-> (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 (m :: * -> *) a.
    Monad m =>
    NString (m a) -> m (NString a))
-> Traversable NString
(a -> f b) -> NString a -> f (NString b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => 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 :: NString (m a) -> m (NString a)
$csequence :: forall (m :: * -> *) a. Monad m => NString (m a) -> m (NString a)
mapM :: (a -> m b) -> NString a -> m (NString b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NString a -> m (NString b)
sequenceA :: NString (f a) -> f (NString a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
NString (f a) -> f (NString a)
traverse :: (a -> f b) -> NString a -> f (NString b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NString a -> f (NString b)
$cp2Traversable :: Foldable NString
$cp1Traversable :: Functor NString
Traversable
    , Int -> NString r -> ShowS
[NString r] -> ShowS
NString r -> FilePath
(Int -> NString r -> ShowS)
-> (NString r -> FilePath)
-> ([NString r] -> ShowS)
-> Show (NString r)
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)
Int -> ReadS (NString r)
ReadS [NString r]
(Int -> ReadS (NString r))
-> ReadS [NString r]
-> ReadPrec (NString r)
-> ReadPrec [NString r]
-> Read (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, Int -> NString r -> Int
NString r -> Int
(Int -> NString r -> Int)
-> (NString r -> Int) -> Hashable (NString r)
forall r. Hashable r => Int -> NString r -> Int
forall r. Hashable r => NString r -> Int
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
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
""     = [Antiquoted Text r] -> NString r
forall r. [Antiquoted Text r] -> NString r
DoubleQuoted [Antiquoted Text r]
forall a. Monoid a => a
mempty
  fromString FilePath
string = [Antiquoted Text r] -> NString r
forall r. [Antiquoted Text r] -> NString r
DoubleQuoted ([Antiquoted Text r] -> NString r)
-> [Antiquoted Text r] -> NString r
forall a b. (a -> b) -> a -> b
$ OneItem [Antiquoted Text r] -> [Antiquoted Text r]
forall x. One x => OneItem x -> x
one (OneItem [Antiquoted Text r] -> [Antiquoted Text r])
-> OneItem [Antiquoted Text r] -> [Antiquoted Text r]
forall a b. (a -> b) -> a -> b
$ Text -> Antiquoted Text r
forall v r. v -> Antiquoted v r
Plain (Text -> Antiquoted Text r) -> Text -> Antiquoted Text r
forall a b. (a -> b) -> a -> b
$ FilePath -> Text
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
(NKeyName r -> NKeyName r -> Bool)
-> (NKeyName r -> NKeyName r -> Bool) -> Eq (NKeyName r)
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, Eq (NKeyName r)
Eq (NKeyName r)
-> (NKeyName r -> NKeyName r -> Ordering)
-> (NKeyName r -> NKeyName r -> Bool)
-> (NKeyName r -> NKeyName r -> Bool)
-> (NKeyName r -> NKeyName r -> Bool)
-> (NKeyName r -> NKeyName r -> Bool)
-> (NKeyName r -> NKeyName r -> NKeyName r)
-> (NKeyName r -> NKeyName r -> NKeyName r)
-> Ord (NKeyName r)
NKeyName r -> NKeyName r -> Bool
NKeyName r -> NKeyName r -> Ordering
NKeyName r -> NKeyName r -> NKeyName r
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
$cp1Ord :: forall r. Ord r => Eq (NKeyName r)
Ord, (forall x. NKeyName r -> Rep (NKeyName r) x)
-> (forall x. Rep (NKeyName r) x -> NKeyName r)
-> Generic (NKeyName r)
forall x. Rep (NKeyName r) x -> NKeyName r
forall x. NKeyName r -> Rep (NKeyName r) x
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, Typeable (NKeyName r)
DataType
Constr
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NKeyName r))
-> (NKeyName r -> Constr)
-> (NKeyName r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NKeyName r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NKeyName r)))
-> ((forall b. Data b => b -> b) -> NKeyName r -> NKeyName r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NKeyName r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NKeyName r -> r)
-> (forall u. (forall d. Data d => d -> u) -> NKeyName r -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NKeyName r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r))
-> Data (NKeyName r)
NKeyName r -> DataType
NKeyName r -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (NKeyName r))
(forall b. Data b => b -> b) -> NKeyName r -> NKeyName r
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NKeyName r -> c (NKeyName r)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NKeyName r)
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 u. Int -> (forall d. Data d => d -> u) -> NKeyName r -> u
forall u. (forall d. Data d => d -> u) -> NKeyName r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NKeyName r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NKeyName r -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NKeyName r -> m (NKeyName r)
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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NKeyName r))
$cStaticKey :: Constr
$cDynamicKey :: Constr
$tNKeyName :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> NKeyName r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> NKeyName r -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall r. Data r => Typeable (NKeyName r)
Data, NKeyName r -> ()
(NKeyName r -> ()) -> NFData (NKeyName r)
forall r. NFData r => NKeyName r -> ()
forall a. (a -> ()) -> NFData a
rnf :: NKeyName r -> ()
$crnf :: forall r. NFData r => NKeyName r -> ()
NFData, [NKeyName r] -> Encoding
NKeyName r -> Encoding
(NKeyName r -> Encoding)
-> (forall s. Decoder s (NKeyName r))
-> ([NKeyName r] -> Encoding)
-> (forall s. Decoder s [NKeyName r])
-> Serialise (NKeyName r)
forall s. Decoder s [NKeyName r]
forall s. Decoder s (NKeyName r)
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 :: 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 :: 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, Get (NKeyName r)
[NKeyName r] -> Put
NKeyName r -> Put
(NKeyName r -> Put)
-> Get (NKeyName r) -> ([NKeyName r] -> Put) -> Binary (NKeyName r)
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, [NKeyName r] -> Encoding
[NKeyName r] -> Value
NKeyName r -> Encoding
NKeyName r -> Value
(NKeyName r -> Value)
-> (NKeyName r -> Encoding)
-> ([NKeyName r] -> Value)
-> ([NKeyName r] -> Encoding)
-> ToJSON (NKeyName r)
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, Value -> Parser [NKeyName r]
Value -> Parser (NKeyName r)
(Value -> Parser (NKeyName r))
-> (Value -> Parser [NKeyName r]) -> FromJSON (NKeyName r)
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
[NKeyName r] -> ShowS
NKeyName r -> FilePath
(Int -> NKeyName r -> ShowS)
-> (NKeyName r -> FilePath)
-> ([NKeyName r] -> ShowS)
-> Show (NKeyName r)
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)
Int -> ReadS (NKeyName r)
ReadS [NKeyName r]
(Int -> ReadS (NKeyName r))
-> ReadS [NKeyName r]
-> ReadPrec (NKeyName r)
-> ReadPrec [NKeyName r]
-> Read (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, Int -> NKeyName r -> Int
NKeyName r -> Int
(Int -> NKeyName r -> Int)
-> (NKeyName r -> Int) -> Hashable (NKeyName r)
forall r. Hashable r => Int -> NKeyName r -> Int
forall r. Hashable r => NKeyName r -> Int
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
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 :: (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 = VarName -> NKeyName r
forall r. VarName -> NKeyName r
StaticKey (VarName -> NKeyName r)
-> (FilePath -> VarName) -> FilePath -> NKeyName r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> VarName
forall a. IsString a => FilePath -> a
fromString

instance Eq1 NKeyName where
  liftEq :: (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) = (NString a -> NString b -> Bool)
-> (a -> b -> Bool)
-> Antiquoted (NString a) a
-> Antiquoted (NString b) b
-> Bool
forall (f :: * -> * -> *) a b c d.
Eq2 f =>
(a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
liftEq2 ((a -> b -> Bool) -> NString a -> NString b -> Bool
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 VarName -> VarName -> Bool
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 :: (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) = (NString a -> NString b -> Ordering)
-> (a -> b -> Ordering)
-> Antiquoted (NString a) a
-> Antiquoted (NString b) b
-> Ordering
forall (f :: * -> * -> *) a b c d.
Ord2 f =>
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
liftCompare2 ((a -> b -> Ordering) -> NString a -> NString b -> Ordering
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) = VarName -> VarName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare VarName
a VarName
b

instance Hashable1 NKeyName where
  liftHashWithSalt :: (Int -> a -> Int) -> Int -> NKeyName a -> Int
liftHashWithSalt Int -> a -> Int
h Int
salt (DynamicKey Antiquoted (NString a) a
a) =
    (Int -> NString a -> Int)
-> (Int -> a -> Int) -> Int -> Antiquoted (NString a) a -> Int
forall (t :: * -> * -> *) a b.
Hashable2 t =>
(Int -> a -> Int) -> (Int -> b -> Int) -> Int -> t a b -> Int
liftHashWithSalt2 ((Int -> a -> Int) -> Int -> NString a -> Int
forall (t :: * -> *) a.
Hashable1 t =>
(Int -> a -> Int) -> Int -> t a -> Int
liftHashWithSalt Int -> a -> Int
h) Int -> a -> Int
h (Int
salt Int -> Int -> Int
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 Int -> Int -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` (Int
1 :: Int) Int -> VarName -> 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 :: (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 ->
      (Int -> Antiquoted (NString a) a -> ShowS)
-> FilePath -> Int -> Antiquoted (NString a) a -> ShowS
forall a. (Int -> a -> ShowS) -> FilePath -> Int -> a -> ShowS
showsUnaryWith
        ((Int -> NString a -> ShowS)
-> ([NString a] -> ShowS)
-> (Int -> a -> ShowS)
-> ([a] -> ShowS)
-> Int
-> Antiquoted (NString a) a
-> ShowS
forall (f :: * -> * -> *) a b.
Show2 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS)
-> (Int -> b -> ShowS)
-> ([b] -> ShowS)
-> Int
-> f a b
-> ShowS
liftShowsPrec2 ((Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NString a -> ShowS
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS
liftShowsPrec Int -> a -> ShowS
sp [a] -> ShowS
sl) ((Int -> a -> ShowS) -> ([a] -> ShowS) -> [NString a] -> ShowS
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 -> (Int -> VarName -> ShowS) -> FilePath -> Int -> VarName -> ShowS
forall a. (Int -> a -> ShowS) -> FilePath -> Int -> a -> ShowS
showsUnaryWith Int -> VarName -> ShowS
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 :: (a -> b) -> NKeyName a -> NKeyName b
fmap = (a -> b) -> NKeyName a -> NKeyName b
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 :: (a -> m) -> NKeyName a -> m
foldMap = (a -> m) -> NKeyName a -> m
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 :: (a -> f b) -> NKeyName a -> f (NKeyName b)
traverse a -> f b
f = \case
    DynamicKey (Plain      NString a
str) -> Antiquoted (NString b) b -> NKeyName b
forall r. Antiquoted (NString r) r -> NKeyName r
DynamicKey (Antiquoted (NString b) b -> NKeyName b)
-> (NString b -> Antiquoted (NString b) b)
-> NString b
-> NKeyName b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NString b -> Antiquoted (NString b) b
forall v r. v -> Antiquoted v r
Plain (NString b -> NKeyName b) -> f (NString b) -> f (NKeyName b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f b) -> NString a -> f (NString 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  ) -> Antiquoted (NString b) b -> NKeyName b
forall r. Antiquoted (NString r) r -> NKeyName r
DynamicKey (Antiquoted (NString b) b -> NKeyName b)
-> (b -> Antiquoted (NString b) b) -> b -> NKeyName b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Antiquoted (NString b) b
forall v r. r -> Antiquoted v r
Antiquoted (b -> NKeyName b) -> f b -> f (NKeyName b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
e
    DynamicKey Antiquoted (NString a) a
EscapedNewline   -> NKeyName b -> f (NKeyName b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NKeyName b -> f (NKeyName b)) -> NKeyName b -> f (NKeyName b)
forall a b. (a -> b) -> a -> b
$ Antiquoted (NString b) b -> NKeyName b
forall r. Antiquoted (NString r) r -> NKeyName r
DynamicKey Antiquoted (NString b) b
forall v r. Antiquoted v r
EscapedNewline
    StaticKey  VarName
key              -> NKeyName b -> f (NKeyName b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NKeyName b -> f (NKeyName b)) -> NKeyName b -> f (NKeyName b)
forall a b. (a -> b) -> a -> b
$ VarName -> NKeyName 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 !SourcePos
  -- ^ An explicit naming.
  --
  -- > NamedVar (StaticKey "x" :| [StaticKey "y"]) z SourcePos{}  ~  x.y = z;
  | Inherit !(Maybe r) ![VarName] !SourcePos
  -- ^ 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"] SourcePos{}@                | @inherit a;@       | @a = outside.a;@      |
  -- +---------------------------------------------------------------+--------------------+-----------------------+
  -- | @Inherit (pure x) [StaticKey "a"] SourcePos{}@                | @inherit (x) a;@   | @a = x.a;@            |
  -- +---------------------------------------------------------------+--------------------+-----------------------+
  -- | @Inherit (pure x) [StaticKey "a", StaticKey "b"] SourcePos{}@ | @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
(Binding r -> Binding r -> Bool)
-> (Binding r -> Binding r -> Bool) -> Eq (Binding r)
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, Eq (Binding r)
Eq (Binding r)
-> (Binding r -> Binding r -> Ordering)
-> (Binding r -> Binding r -> Bool)
-> (Binding r -> Binding r -> Bool)
-> (Binding r -> Binding r -> Bool)
-> (Binding r -> Binding r -> Bool)
-> (Binding r -> Binding r -> Binding r)
-> (Binding r -> Binding r -> Binding r)
-> Ord (Binding r)
Binding r -> Binding r -> Bool
Binding r -> Binding r -> Ordering
Binding r -> Binding r -> Binding r
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
$cp1Ord :: forall r. Ord r => Eq (Binding r)
Ord, (forall x. Binding r -> Rep (Binding r) x)
-> (forall x. Rep (Binding r) x -> Binding r)
-> Generic (Binding r)
forall x. Rep (Binding r) x -> Binding r
forall x. Binding r -> Rep (Binding r) x
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. Binding a -> Rep1 Binding a)
-> (forall a. Rep1 Binding a -> Binding a) -> Generic1 Binding
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, Typeable (Binding r)
DataType
Constr
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Binding r))
-> (Binding r -> Constr)
-> (Binding r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Binding r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Binding r)))
-> ((forall b. Data b => b -> b) -> Binding r -> Binding r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding r -> r)
-> (forall u. (forall d. Data d => d -> u) -> Binding r -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Binding r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Binding r -> m (Binding r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binding r -> m (Binding r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binding r -> m (Binding r))
-> Data (Binding r)
Binding r -> DataType
Binding r -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Binding r))
(forall b. Data b => b -> b) -> Binding r -> Binding r
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding r -> c (Binding r)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Binding r)
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 u. Int -> (forall d. Data d => d -> u) -> Binding r -> u
forall u. (forall d. Data d => d -> u) -> Binding r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding r -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding r -> m (Binding r)
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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Binding r))
$cInherit :: Constr
$cNamedVar :: Constr
$tBinding :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> Binding r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> Binding r -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall r. Data r => Typeable (Binding r)
Data, Binding r -> ()
(Binding r -> ()) -> NFData (Binding r)
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 -> ()) -> NFData1 Binding
forall a. (a -> ()) -> Binding a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: (a -> ()) -> Binding a -> ()
$cliftRnf :: forall a. (a -> ()) -> Binding a -> ()
NFData1, [Binding r] -> Encoding
Binding r -> Encoding
(Binding r -> Encoding)
-> (forall s. Decoder s (Binding r))
-> ([Binding r] -> Encoding)
-> (forall s. Decoder s [Binding r])
-> Serialise (Binding r)
forall s. Decoder s [Binding r]
forall s. Decoder s (Binding r)
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 :: 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 :: 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, Get (Binding r)
[Binding r] -> Put
Binding r -> Put
(Binding r -> Put)
-> Get (Binding r) -> ([Binding r] -> Put) -> Binary (Binding r)
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, [Binding r] -> Encoding
[Binding r] -> Value
Binding r -> Encoding
Binding r -> Value
(Binding r -> Value)
-> (Binding r -> Encoding)
-> ([Binding r] -> Value)
-> ([Binding r] -> Encoding)
-> ToJSON (Binding r)
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, Value -> Parser [Binding r]
Value -> Parser (Binding r)
(Value -> Parser (Binding r))
-> (Value -> Parser [Binding r]) -> FromJSON (Binding r)
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
    , a -> Binding b -> Binding a
(a -> b) -> Binding a -> Binding b
(forall a b. (a -> b) -> Binding a -> Binding b)
-> (forall a b. a -> Binding b -> Binding a) -> Functor Binding
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
<$ :: a -> Binding b -> Binding a
$c<$ :: forall a b. a -> Binding b -> Binding a
fmap :: (a -> b) -> Binding a -> Binding b
$cfmap :: forall a b. (a -> b) -> Binding a -> Binding b
Functor, Binding a -> Bool
(a -> m) -> Binding a -> m
(a -> b -> b) -> b -> Binding a -> b
(forall m. Monoid m => Binding m -> m)
-> (forall m a. Monoid m => (a -> m) -> Binding a -> m)
-> (forall m a. Monoid m => (a -> m) -> Binding a -> m)
-> (forall a b. (a -> b -> b) -> b -> Binding a -> b)
-> (forall a b. (a -> b -> b) -> b -> Binding a -> b)
-> (forall b a. (b -> a -> b) -> b -> Binding a -> b)
-> (forall b a. (b -> a -> b) -> b -> Binding a -> b)
-> (forall a. (a -> a -> a) -> Binding a -> a)
-> (forall a. (a -> a -> a) -> Binding a -> a)
-> (forall a. Binding a -> [a])
-> (forall a. Binding a -> Bool)
-> (forall a. Binding a -> Int)
-> (forall a. Eq a => a -> Binding a -> Bool)
-> (forall a. Ord a => Binding a -> a)
-> (forall a. Ord a => Binding a -> a)
-> (forall a. Num a => Binding a -> a)
-> (forall a. Num a => Binding a -> a)
-> Foldable Binding
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 :: Binding a -> a
$cproduct :: forall a. Num a => Binding a -> a
sum :: Binding a -> a
$csum :: forall a. Num a => Binding a -> a
minimum :: Binding a -> a
$cminimum :: forall a. Ord a => Binding a -> a
maximum :: Binding a -> a
$cmaximum :: forall a. Ord a => Binding a -> a
elem :: a -> Binding a -> Bool
$celem :: forall a. Eq a => a -> Binding a -> Bool
length :: Binding a -> Int
$clength :: forall a. Binding a -> Int
null :: Binding a -> Bool
$cnull :: forall a. Binding a -> Bool
toList :: Binding a -> [a]
$ctoList :: forall a. Binding a -> [a]
foldl1 :: (a -> a -> a) -> Binding a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Binding a -> a
foldr1 :: (a -> a -> a) -> Binding a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Binding a -> a
foldl' :: (b -> a -> b) -> b -> Binding a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Binding a -> b
foldl :: (b -> a -> b) -> b -> Binding a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Binding a -> b
foldr' :: (a -> b -> b) -> b -> Binding a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Binding a -> b
foldr :: (a -> b -> b) -> b -> Binding a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Binding a -> b
foldMap' :: (a -> m) -> Binding a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Binding a -> m
foldMap :: (a -> m) -> Binding a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Binding a -> m
fold :: Binding m -> m
$cfold :: forall m. Monoid m => Binding m -> m
Foldable, Functor Binding
Foldable Binding
Functor Binding
-> Foldable Binding
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Binding a -> f (Binding b))
-> (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 (m :: * -> *) a.
    Monad m =>
    Binding (m a) -> m (Binding a))
-> Traversable Binding
(a -> f b) -> Binding a -> f (Binding b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => 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 :: Binding (m a) -> m (Binding a)
$csequence :: forall (m :: * -> *) a. Monad m => Binding (m a) -> m (Binding a)
mapM :: (a -> m b) -> Binding a -> m (Binding b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binding a -> m (Binding b)
sequenceA :: Binding (f a) -> f (Binding a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Binding (f a) -> f (Binding a)
traverse :: (a -> f b) -> Binding a -> f (Binding b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binding a -> f (Binding b)
$cp2Traversable :: Foldable Binding
$cp1Traversable :: Functor Binding
Traversable
    , Int -> Binding r -> ShowS
[Binding r] -> ShowS
Binding r -> FilePath
(Int -> Binding r -> ShowS)
-> (Binding r -> FilePath)
-> ([Binding r] -> ShowS)
-> Show (Binding r)
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, Int -> Binding r -> Int
Binding r -> Int
(Int -> Binding r -> Int)
-> (Binding r -> Int) -> Hashable (Binding r)
forall r. Hashable r => Int -> Binding r -> Int
forall r. Hashable r => Binding r -> Int
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
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
(Recursivity -> Recursivity -> Bool)
-> (Recursivity -> Recursivity -> Bool) -> Eq Recursivity
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
Eq Recursivity
-> (Recursivity -> Recursivity -> Ordering)
-> (Recursivity -> Recursivity -> Bool)
-> (Recursivity -> Recursivity -> Bool)
-> (Recursivity -> Recursivity -> Bool)
-> (Recursivity -> Recursivity -> Bool)
-> (Recursivity -> Recursivity -> Recursivity)
-> (Recursivity -> Recursivity -> Recursivity)
-> Ord 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
$cp1Ord :: Eq Recursivity
Ord, Int -> Recursivity
Recursivity -> Int
Recursivity -> [Recursivity]
Recursivity -> Recursivity
Recursivity -> Recursivity -> [Recursivity]
Recursivity -> Recursivity -> Recursivity -> [Recursivity]
(Recursivity -> Recursivity)
-> (Recursivity -> Recursivity)
-> (Int -> Recursivity)
-> (Recursivity -> Int)
-> (Recursivity -> [Recursivity])
-> (Recursivity -> Recursivity -> [Recursivity])
-> (Recursivity -> Recursivity -> [Recursivity])
-> (Recursivity -> Recursivity -> Recursivity -> [Recursivity])
-> Enum 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
Recursivity -> Recursivity -> Bounded Recursivity
forall a. a -> a -> Bounded a
maxBound :: Recursivity
$cmaxBound :: Recursivity
minBound :: Recursivity
$cminBound :: Recursivity
Bounded, (forall x. Recursivity -> Rep Recursivity x)
-> (forall x. Rep Recursivity x -> Recursivity)
-> Generic Recursivity
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
DataType
Constr
Typeable Recursivity
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Recursivity -> c Recursivity)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Recursivity)
-> (Recursivity -> Constr)
-> (Recursivity -> DataType)
-> (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))
-> ((forall b. Data b => b -> b) -> Recursivity -> Recursivity)
-> (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 u. (forall d. Data d => d -> u) -> Recursivity -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Recursivity -> u)
-> (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 (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Recursivity -> m Recursivity)
-> Data Recursivity
Recursivity -> DataType
Recursivity -> Constr
(forall b. Data b => b -> b) -> Recursivity -> Recursivity
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Recursivity -> c Recursivity
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cRecursive :: Constr
$cNonRecursive :: Constr
$tRecursivity :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> Recursivity -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Recursivity -> u
gmapQ :: (forall d. Data d => d -> u) -> Recursivity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Recursivity -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable Recursivity
Data, Recursivity -> ()
(Recursivity -> ()) -> NFData Recursivity
forall a. (a -> ()) -> NFData a
rnf :: Recursivity -> ()
$crnf :: Recursivity -> ()
NFData, [Recursivity] -> Encoding
Recursivity -> Encoding
(Recursivity -> Encoding)
-> (forall s. Decoder s Recursivity)
-> ([Recursivity] -> Encoding)
-> (forall s. Decoder s [Recursivity])
-> Serialise Recursivity
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 :: Decoder s [Recursivity]
$cdecodeList :: forall s. Decoder s [Recursivity]
encodeList :: [Recursivity] -> Encoding
$cencodeList :: [Recursivity] -> Encoding
decode :: Decoder s Recursivity
$cdecode :: forall s. Decoder s Recursivity
encode :: Recursivity -> Encoding
$cencode :: Recursivity -> Encoding
Serialise, Get Recursivity
[Recursivity] -> Put
Recursivity -> Put
(Recursivity -> Put)
-> Get Recursivity -> ([Recursivity] -> Put) -> Binary Recursivity
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
(Recursivity -> Value)
-> (Recursivity -> Encoding)
-> ([Recursivity] -> Value)
-> ([Recursivity] -> Encoding)
-> ToJSON Recursivity
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
(Value -> Parser Recursivity)
-> (Value -> Parser [Recursivity]) -> FromJSON 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
(Int -> Recursivity -> ShowS)
-> (Recursivity -> FilePath)
-> ([Recursivity] -> ShowS)
-> Show Recursivity
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]
(Int -> ReadS Recursivity)
-> ReadS [Recursivity]
-> ReadPrec Recursivity
-> ReadPrec [Recursivity]
-> Read 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, Int -> Recursivity -> Int
Recursivity -> Int
(Int -> Recursivity -> Int)
-> (Recursivity -> Int) -> Hashable Recursivity
forall 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
(NUnaryOp -> NUnaryOp -> Bool)
-> (NUnaryOp -> NUnaryOp -> Bool) -> Eq NUnaryOp
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
Eq NUnaryOp
-> (NUnaryOp -> NUnaryOp -> Ordering)
-> (NUnaryOp -> NUnaryOp -> Bool)
-> (NUnaryOp -> NUnaryOp -> Bool)
-> (NUnaryOp -> NUnaryOp -> Bool)
-> (NUnaryOp -> NUnaryOp -> Bool)
-> (NUnaryOp -> NUnaryOp -> NUnaryOp)
-> (NUnaryOp -> NUnaryOp -> NUnaryOp)
-> Ord 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
$cp1Ord :: Eq NUnaryOp
Ord, Int -> NUnaryOp
NUnaryOp -> Int
NUnaryOp -> [NUnaryOp]
NUnaryOp -> NUnaryOp
NUnaryOp -> NUnaryOp -> [NUnaryOp]
NUnaryOp -> NUnaryOp -> NUnaryOp -> [NUnaryOp]
(NUnaryOp -> NUnaryOp)
-> (NUnaryOp -> NUnaryOp)
-> (Int -> NUnaryOp)
-> (NUnaryOp -> Int)
-> (NUnaryOp -> [NUnaryOp])
-> (NUnaryOp -> NUnaryOp -> [NUnaryOp])
-> (NUnaryOp -> NUnaryOp -> [NUnaryOp])
-> (NUnaryOp -> NUnaryOp -> NUnaryOp -> [NUnaryOp])
-> Enum 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
NUnaryOp -> NUnaryOp -> Bounded NUnaryOp
forall a. a -> a -> Bounded a
maxBound :: NUnaryOp
$cmaxBound :: NUnaryOp
minBound :: NUnaryOp
$cminBound :: NUnaryOp
Bounded, (forall x. NUnaryOp -> Rep NUnaryOp x)
-> (forall x. Rep NUnaryOp x -> NUnaryOp) -> Generic NUnaryOp
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
DataType
Constr
Typeable NUnaryOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NUnaryOp -> c NUnaryOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NUnaryOp)
-> (NUnaryOp -> Constr)
-> (NUnaryOp -> DataType)
-> (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))
-> ((forall b. Data b => b -> b) -> NUnaryOp -> NUnaryOp)
-> (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 u. (forall d. Data d => d -> u) -> NUnaryOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NUnaryOp -> u)
-> (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 (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NUnaryOp -> m NUnaryOp)
-> Data NUnaryOp
NUnaryOp -> DataType
NUnaryOp -> Constr
(forall b. Data b => b -> b) -> NUnaryOp -> NUnaryOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NUnaryOp -> c NUnaryOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cNNot :: Constr
$cNNeg :: Constr
$tNUnaryOp :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> NUnaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NUnaryOp -> u
gmapQ :: (forall d. Data d => d -> u) -> NUnaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NUnaryOp -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable NUnaryOp
Data, NUnaryOp -> ()
(NUnaryOp -> ()) -> NFData NUnaryOp
forall a. (a -> ()) -> NFData a
rnf :: NUnaryOp -> ()
$crnf :: NUnaryOp -> ()
NFData, [NUnaryOp] -> Encoding
NUnaryOp -> Encoding
(NUnaryOp -> Encoding)
-> (forall s. Decoder s NUnaryOp)
-> ([NUnaryOp] -> Encoding)
-> (forall s. Decoder s [NUnaryOp])
-> Serialise NUnaryOp
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 :: Decoder s [NUnaryOp]
$cdecodeList :: forall s. Decoder s [NUnaryOp]
encodeList :: [NUnaryOp] -> Encoding
$cencodeList :: [NUnaryOp] -> Encoding
decode :: Decoder s NUnaryOp
$cdecode :: forall s. Decoder s NUnaryOp
encode :: NUnaryOp -> Encoding
$cencode :: NUnaryOp -> Encoding
Serialise, Get NUnaryOp
[NUnaryOp] -> Put
NUnaryOp -> Put
(NUnaryOp -> Put)
-> Get NUnaryOp -> ([NUnaryOp] -> Put) -> Binary NUnaryOp
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
(NUnaryOp -> Value)
-> (NUnaryOp -> Encoding)
-> ([NUnaryOp] -> Value)
-> ([NUnaryOp] -> Encoding)
-> ToJSON NUnaryOp
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
(Value -> Parser NUnaryOp)
-> (Value -> Parser [NUnaryOp]) -> FromJSON 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
(Int -> NUnaryOp -> ShowS)
-> (NUnaryOp -> FilePath) -> ([NUnaryOp] -> ShowS) -> Show NUnaryOp
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]
(Int -> ReadS NUnaryOp)
-> ReadS [NUnaryOp]
-> ReadPrec NUnaryOp
-> ReadPrec [NUnaryOp]
-> Read 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, Int -> NUnaryOp -> Int
NUnaryOp -> Int
(Int -> NUnaryOp -> Int) -> (NUnaryOp -> Int) -> Hashable NUnaryOp
forall 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 (@++@)
  | NApp     -- ^ Apply a function to an argument.
             --
             -- > NBinary NApp f x  ~  f x
  deriving
    ( NBinaryOp -> NBinaryOp -> Bool
(NBinaryOp -> NBinaryOp -> Bool)
-> (NBinaryOp -> NBinaryOp -> Bool) -> Eq NBinaryOp
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
Eq NBinaryOp
-> (NBinaryOp -> NBinaryOp -> Ordering)
-> (NBinaryOp -> NBinaryOp -> Bool)
-> (NBinaryOp -> NBinaryOp -> Bool)
-> (NBinaryOp -> NBinaryOp -> Bool)
-> (NBinaryOp -> NBinaryOp -> Bool)
-> (NBinaryOp -> NBinaryOp -> NBinaryOp)
-> (NBinaryOp -> NBinaryOp -> NBinaryOp)
-> Ord 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
$cp1Ord :: Eq NBinaryOp
Ord, Int -> NBinaryOp
NBinaryOp -> Int
NBinaryOp -> [NBinaryOp]
NBinaryOp -> NBinaryOp
NBinaryOp -> NBinaryOp -> [NBinaryOp]
NBinaryOp -> NBinaryOp -> NBinaryOp -> [NBinaryOp]
(NBinaryOp -> NBinaryOp)
-> (NBinaryOp -> NBinaryOp)
-> (Int -> NBinaryOp)
-> (NBinaryOp -> Int)
-> (NBinaryOp -> [NBinaryOp])
-> (NBinaryOp -> NBinaryOp -> [NBinaryOp])
-> (NBinaryOp -> NBinaryOp -> [NBinaryOp])
-> (NBinaryOp -> NBinaryOp -> NBinaryOp -> [NBinaryOp])
-> Enum 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
NBinaryOp -> NBinaryOp -> Bounded NBinaryOp
forall a. a -> a -> Bounded a
maxBound :: NBinaryOp
$cmaxBound :: NBinaryOp
minBound :: NBinaryOp
$cminBound :: NBinaryOp
Bounded, (forall x. NBinaryOp -> Rep NBinaryOp x)
-> (forall x. Rep NBinaryOp x -> NBinaryOp) -> Generic NBinaryOp
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
DataType
Constr
Typeable NBinaryOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NBinaryOp -> c NBinaryOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NBinaryOp)
-> (NBinaryOp -> Constr)
-> (NBinaryOp -> DataType)
-> (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))
-> ((forall b. Data b => b -> b) -> NBinaryOp -> NBinaryOp)
-> (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 u. (forall d. Data d => d -> u) -> NBinaryOp -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NBinaryOp -> u)
-> (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 (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NBinaryOp -> m NBinaryOp)
-> Data NBinaryOp
NBinaryOp -> DataType
NBinaryOp -> Constr
(forall b. Data b => b -> b) -> NBinaryOp -> NBinaryOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NBinaryOp -> c NBinaryOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cNApp :: Constr
$cNConcat :: Constr
$cNDiv :: Constr
$cNMult :: Constr
$cNMinus :: Constr
$cNPlus :: Constr
$cNUpdate :: Constr
$cNImpl :: Constr
$cNOr :: Constr
$cNAnd :: Constr
$cNGte :: Constr
$cNGt :: Constr
$cNLte :: Constr
$cNLt :: Constr
$cNNEq :: Constr
$cNEq :: Constr
$tNBinaryOp :: DataType
gmapMo :: (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 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 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 :: Int -> (forall d. Data d => d -> u) -> NBinaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NBinaryOp -> u
gmapQ :: (forall d. Data d => d -> u) -> NBinaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NBinaryOp -> [u]
gmapQr :: (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 :: (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 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 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 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 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
$cp1Data :: Typeable NBinaryOp
Data, NBinaryOp -> ()
(NBinaryOp -> ()) -> NFData NBinaryOp
forall a. (a -> ()) -> NFData a
rnf :: NBinaryOp -> ()
$crnf :: NBinaryOp -> ()
NFData, [NBinaryOp] -> Encoding
NBinaryOp -> Encoding
(NBinaryOp -> Encoding)
-> (forall s. Decoder s NBinaryOp)
-> ([NBinaryOp] -> Encoding)
-> (forall s. Decoder s [NBinaryOp])
-> Serialise NBinaryOp
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 :: Decoder s [NBinaryOp]
$cdecodeList :: forall s. Decoder s [NBinaryOp]
encodeList :: [NBinaryOp] -> Encoding
$cencodeList :: [NBinaryOp] -> Encoding
decode :: Decoder s NBinaryOp
$cdecode :: forall s. Decoder s NBinaryOp
encode :: NBinaryOp -> Encoding
$cencode :: NBinaryOp -> Encoding
Serialise, Get NBinaryOp
[NBinaryOp] -> Put
NBinaryOp -> Put
(NBinaryOp -> Put)
-> Get NBinaryOp -> ([NBinaryOp] -> Put) -> Binary NBinaryOp
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
(NBinaryOp -> Value)
-> (NBinaryOp -> Encoding)
-> ([NBinaryOp] -> Value)
-> ([NBinaryOp] -> Encoding)
-> ToJSON NBinaryOp
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
(Value -> Parser NBinaryOp)
-> (Value -> Parser [NBinaryOp]) -> FromJSON 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
(Int -> NBinaryOp -> ShowS)
-> (NBinaryOp -> FilePath)
-> ([NBinaryOp] -> ShowS)
-> Show NBinaryOp
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]
(Int -> ReadS NBinaryOp)
-> ReadS [NBinaryOp]
-> ReadPrec NBinaryOp
-> ReadPrec [NBinaryOp]
-> Read 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, Int -> NBinaryOp -> Int
NBinaryOp -> Int
(Int -> NBinaryOp -> Int)
-> (NBinaryOp -> Int) -> Hashable NBinaryOp
forall 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>
  | 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
(NExprF r -> NExprF r -> Bool)
-> (NExprF r -> NExprF r -> Bool) -> Eq (NExprF r)
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, Eq (NExprF r)
Eq (NExprF r)
-> (NExprF r -> NExprF r -> Ordering)
-> (NExprF r -> NExprF r -> Bool)
-> (NExprF r -> NExprF r -> Bool)
-> (NExprF r -> NExprF r -> Bool)
-> (NExprF r -> NExprF r -> Bool)
-> (NExprF r -> NExprF r -> NExprF r)
-> (NExprF r -> NExprF r -> NExprF r)
-> Ord (NExprF r)
NExprF r -> NExprF r -> Bool
NExprF r -> NExprF r -> Ordering
NExprF r -> NExprF r -> NExprF r
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
$cp1Ord :: forall r. Ord r => Eq (NExprF r)
Ord, (forall x. NExprF r -> Rep (NExprF r) x)
-> (forall x. Rep (NExprF r) x -> NExprF r) -> Generic (NExprF r)
forall x. Rep (NExprF r) x -> NExprF r
forall x. NExprF r -> Rep (NExprF r) x
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. NExprF a -> Rep1 NExprF a)
-> (forall a. Rep1 NExprF a -> NExprF a) -> Generic1 NExprF
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, Typeable (NExprF r)
DataType
Constr
Typeable (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 (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NExprF r))
-> (NExprF r -> Constr)
-> (NExprF r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NExprF r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NExprF r)))
-> ((forall b. Data b => b -> b) -> NExprF r -> NExprF r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NExprF r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NExprF r -> r)
-> (forall u. (forall d. Data d => d -> u) -> NExprF r -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NExprF r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r))
-> Data (NExprF r)
NExprF r -> DataType
NExprF r -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (NExprF r))
(forall b. Data b => b -> b) -> NExprF r -> NExprF r
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NExprF r -> c (NExprF r)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NExprF r)
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 u. Int -> (forall d. Data d => d -> u) -> NExprF r -> u
forall u. (forall d. Data d => d -> u) -> NExprF r -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NExprF r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NExprF r -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NExprF r -> m (NExprF r)
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))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NExprF r))
$cNSynHole :: Constr
$cNAssert :: Constr
$cNWith :: Constr
$cNIf :: Constr
$cNLet :: Constr
$cNAbs :: Constr
$cNHasAttr :: Constr
$cNSelect :: Constr
$cNBinary :: Constr
$cNUnary :: Constr
$cNEnvPath :: Constr
$cNLiteralPath :: Constr
$cNSet :: Constr
$cNList :: Constr
$cNSym :: Constr
$cNStr :: Constr
$cNConstant :: Constr
$tNExprF :: DataType
gmapMo :: (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 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 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 :: 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 d. Data d => d -> u) -> NExprF r -> [u]
$cgmapQ :: forall r u.
Data r =>
(forall d. Data d => d -> u) -> NExprF r -> [u]
gmapQr :: (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 :: (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 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 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 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 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)
$cp1Data :: forall r. Data r => Typeable (NExprF r)
Data, NExprF r -> ()
(NExprF r -> ()) -> NFData (NExprF r)
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 -> ()) -> NFData1 NExprF
forall a. (a -> ()) -> NExprF a -> ()
forall (f :: * -> *).
(forall a. (a -> ()) -> f a -> ()) -> NFData1 f
liftRnf :: (a -> ()) -> NExprF a -> ()
$cliftRnf :: forall a. (a -> ()) -> NExprF a -> ()
NFData1, [NExprF r] -> Encoding
NExprF r -> Encoding
(NExprF r -> Encoding)
-> (forall s. Decoder s (NExprF r))
-> ([NExprF r] -> Encoding)
-> (forall s. Decoder s [NExprF r])
-> Serialise (NExprF r)
forall s. Decoder s [NExprF r]
forall s. Decoder s (NExprF r)
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 :: 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 :: 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, Get (NExprF r)
[NExprF r] -> Put
NExprF r -> Put
(NExprF r -> Put)
-> Get (NExprF r) -> ([NExprF r] -> Put) -> Binary (NExprF r)
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, [NExprF r] -> Encoding
[NExprF r] -> Value
NExprF r -> Encoding
NExprF r -> Value
(NExprF r -> Value)
-> (NExprF r -> Encoding)
-> ([NExprF r] -> Value)
-> ([NExprF r] -> Encoding)
-> ToJSON (NExprF r)
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, Value -> Parser [NExprF r]
Value -> Parser (NExprF r)
(Value -> Parser (NExprF r))
-> (Value -> Parser [NExprF r]) -> FromJSON (NExprF r)
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
    , a -> NExprF b -> NExprF a
(a -> b) -> NExprF a -> NExprF b
(forall a b. (a -> b) -> NExprF a -> NExprF b)
-> (forall a b. a -> NExprF b -> NExprF a) -> Functor NExprF
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
<$ :: a -> NExprF b -> NExprF a
$c<$ :: forall a b. a -> NExprF b -> NExprF a
fmap :: (a -> b) -> NExprF a -> NExprF b
$cfmap :: forall a b. (a -> b) -> NExprF a -> NExprF b
Functor, NExprF a -> Bool
(a -> m) -> NExprF a -> m
(a -> b -> b) -> b -> NExprF a -> b
(forall m. Monoid m => NExprF m -> m)
-> (forall m a. Monoid m => (a -> m) -> NExprF a -> m)
-> (forall m a. Monoid m => (a -> m) -> NExprF a -> m)
-> (forall a b. (a -> b -> b) -> b -> NExprF a -> b)
-> (forall a b. (a -> b -> b) -> b -> NExprF a -> b)
-> (forall b a. (b -> a -> b) -> b -> NExprF a -> b)
-> (forall b a. (b -> a -> b) -> b -> NExprF a -> b)
-> (forall a. (a -> a -> a) -> NExprF a -> a)
-> (forall a. (a -> a -> a) -> NExprF a -> a)
-> (forall a. NExprF a -> [a])
-> (forall a. NExprF a -> Bool)
-> (forall a. NExprF a -> Int)
-> (forall a. Eq a => a -> NExprF a -> Bool)
-> (forall a. Ord a => NExprF a -> a)
-> (forall a. Ord a => NExprF a -> a)
-> (forall a. Num a => NExprF a -> a)
-> (forall a. Num a => NExprF a -> a)
-> Foldable NExprF
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 :: NExprF a -> a
$cproduct :: forall a. Num a => NExprF a -> a
sum :: NExprF a -> a
$csum :: forall a. Num a => NExprF a -> a
minimum :: NExprF a -> a
$cminimum :: forall a. Ord a => NExprF a -> a
maximum :: NExprF a -> a
$cmaximum :: forall a. Ord a => NExprF a -> a
elem :: a -> NExprF a -> Bool
$celem :: forall a. Eq a => a -> NExprF a -> Bool
length :: NExprF a -> Int
$clength :: forall a. NExprF a -> Int
null :: NExprF a -> Bool
$cnull :: forall a. NExprF a -> Bool
toList :: NExprF a -> [a]
$ctoList :: forall a. NExprF a -> [a]
foldl1 :: (a -> a -> a) -> NExprF a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NExprF a -> a
foldr1 :: (a -> a -> a) -> NExprF a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> NExprF a -> a
foldl' :: (b -> a -> b) -> b -> NExprF a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NExprF a -> b
foldl :: (b -> a -> b) -> b -> NExprF a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NExprF a -> b
foldr' :: (a -> b -> b) -> b -> NExprF a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NExprF a -> b
foldr :: (a -> b -> b) -> b -> NExprF a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> NExprF a -> b
foldMap' :: (a -> m) -> NExprF a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NExprF a -> m
foldMap :: (a -> m) -> NExprF a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NExprF a -> m
fold :: NExprF m -> m
$cfold :: forall m. Monoid m => NExprF m -> m
Foldable, Functor NExprF
Foldable NExprF
Functor NExprF
-> Foldable NExprF
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> NExprF a -> f (NExprF b))
-> (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 (m :: * -> *) a.
    Monad m =>
    NExprF (m a) -> m (NExprF a))
-> Traversable NExprF
(a -> f b) -> NExprF a -> f (NExprF b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => 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 :: NExprF (m a) -> m (NExprF a)
$csequence :: forall (m :: * -> *) a. Monad m => NExprF (m a) -> m (NExprF a)
mapM :: (a -> m b) -> NExprF a -> m (NExprF b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NExprF a -> m (NExprF b)
sequenceA :: NExprF (f a) -> f (NExprF a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
NExprF (f a) -> f (NExprF a)
traverse :: (a -> f b) -> NExprF a -> f (NExprF b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NExprF a -> f (NExprF b)
$cp2Traversable :: Foldable NExprF
$cp1Traversable :: Functor NExprF
Traversable
    , Int -> NExprF r -> ShowS
[NExprF r] -> ShowS
NExprF r -> FilePath
(Int -> NExprF r -> ShowS)
-> (NExprF r -> FilePath)
-> ([NExprF r] -> ShowS)
-> Show (NExprF r)
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, Int -> NExprF r -> Int
NExprF r -> Int
(Int -> NExprF r -> Int)
-> (NExprF r -> Int) -> Hashable (NExprF r)
forall r. Hashable r => Int -> NExprF r -> Int
forall r. Hashable r => NExprF r -> Int
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
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 = NExprF NExpr -> NExpr
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NExprF NExpr -> NExpr)
-> (FilePath -> NExprF NExpr) -> FilePath -> NExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VarName -> NExprF NExpr
forall r. VarName -> NExprF r
NSym (VarName -> NExprF NExpr)
-> (FilePath -> VarName) -> FilePath -> NExprF NExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> VarName
forall a. IsString a => FilePath -> a
fromString

instance Serialise NExpr

instance TH.Lift NExpr where
  lift :: NExpr -> Q Exp
lift =
    (forall b. Data b => b -> Maybe (Q Exp)) -> NExpr -> Q Exp
forall a.
Data a =>
(forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q 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 <-
            TypeRep Text -> TypeRep b -> Maybe (Text :~~: b)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
Reflection.eqTypeRep
              (Typeable Text => TypeRep Text
forall k (a :: k). Typeable a => TypeRep a
Reflection.typeRep @Text)
              (b -> TypeRep b
forall a. Typeable a => a -> TypeRep a
Reflection.typeOf  b
b    )
          Q Exp -> Maybe (Q Exp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure [| $(TH.lift b) |]
      )
#if MIN_VERSION_template_haskell(2,17,0)
  liftTyped = TH.unsafeCodeCoerce . TH.lift
#elif MIN_VERSION_template_haskell(2,16,0)
  liftTyped :: NExpr -> Q (TExp NExpr)
liftTyped = Q Exp -> Q (TExp NExpr)
forall a. Q Exp -> Q (TExp a)
TH.unsafeTExpCoerce (Q Exp -> Q (TExp NExpr))
-> (NExpr -> Q Exp) -> NExpr -> Q (TExp NExpr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NExpr -> Q Exp
forall t. Lift t => t -> Q Exp
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 :: VarName -> Lens' (AttrSet v) (Maybe v)
hashAt = VarName -> (Maybe v -> f (Maybe v)) -> AttrSet v -> f (AttrSet v)
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 :: VarName -> (Maybe v -> f (Maybe v)) -> AttrSet v -> f (AttrSet v)
alterF (VarName -> VarName
coerce -> VarName
k) Maybe v -> f (Maybe v)
f AttrSet v
m =
    AttrSet v -> (v -> AttrSet v) -> Maybe v -> AttrSet v
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
      (VarName -> AttrSet v -> AttrSet v
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> HashMap k v
MapL.delete VarName
k AttrSet v
m)
      (\ v
v -> VarName -> v -> AttrSet v -> AttrSet 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)
      (Maybe v -> AttrSet v) -> f (Maybe v) -> f (AttrSet v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe v -> f (Maybe v)
f (VarName -> AttrSet v -> Maybe v
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 :: Params r -> Maybe VarName
paramName (Param VarName
name        ) = VarName -> Maybe VarName
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 :: 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 = (NExprF NExpr -> NExprF NExpr) -> NExpr -> NExpr
forall (f :: * -> *) (f :: * -> *).
Functor f =>
(f (Fix f) -> f (Fix f)) -> Fix f -> Fix f
transport NExprF NExpr -> NExprF NExpr
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) = f (Fix f) -> Fix f
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (f (Fix f) -> Fix f) -> f (Fix f) -> Fix f
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 (Fix f -> Fix f) -> f (Fix f) -> f (Fix 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) = Recursivity -> [Binding r] -> NExprF r
forall r. Recursivity -> [Binding r] -> NExprF r
NSet Recursivity
recur ([Binding r] -> NExprF r) -> [Binding r] -> NExprF r
forall a b. (a -> b) -> a -> b
$ Binding r -> Binding r
forall r. Binding r -> Binding r
erasePositions (Binding r -> Binding r) -> [Binding r] -> [Binding r]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Binding r]
binds
  phi (NLet [Binding r]
binds r
body) = [Binding r] -> r -> NExprF r
forall r. [Binding r] -> r -> NExprF r
NLet (Binding r -> Binding r
forall r. Binding r -> Binding r
erasePositions (Binding r -> Binding r) -> [Binding r] -> [Binding r]
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     SourcePos
_pos) = NAttrPath r -> r -> SourcePos -> Binding r
forall r. NAttrPath r -> r -> SourcePos -> Binding r
NamedVar NAttrPath r
path r
r     SourcePos
nullPos
  erasePositions (Inherit  Maybe r
ms   [VarName]
names SourcePos
_pos) = Maybe r -> [VarName] -> SourcePos -> Binding r
forall r. Maybe r -> [VarName] -> SourcePos -> Binding r
Inherit  Maybe r
ms   [VarName]
names SourcePos
nullPos

nullPos :: SourcePos
nullPos :: SourcePos
nullPos = (Pos -> Pos -> SourcePos)
-> (Int -> Pos) -> Int -> Int -> SourcePos
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on (FilePath -> Pos -> Pos -> SourcePos
SourcePos FilePath
"<string>") 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
  -> SourcePos
  -> Lens' (Fix g) (Maybe (Fix g))
ekey :: NonEmpty VarName -> SourcePos -> Lens' (Fix g) (Maybe (Fix g))
ekey NonEmpty VarName
keys SourcePos
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) <- g (Fix g) -> (NExprF (Fix g), 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' = NonEmpty VarName -> [VarName]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty VarName
keys
          ([VarName]
ks, [VarName]
rest) <- [[VarName]] -> [[VarName]] -> [([VarName], [VarName])]
forall a b. [a] -> [b] -> [(a, b)]
zip ([VarName] -> [[VarName]]
forall a. [a] -> [[a]]
inits [VarName]
keys') ([VarName] -> [[VarName]]
forall a. [a] -> [[a]]
tails [VarName]
keys')
          [(Fix g, [VarName])]
-> ([VarName] -> [(Fix g, [VarName])])
-> [VarName]
-> [(Fix g, [VarName])]
forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
list
            [(Fix g, [VarName])]
forall a. Monoid a => a
mempty
            (\ (VarName
j : [VarName]
js) ->
              do
                NamedVar NAttrPath (Fix g)
ns Fix g
v SourcePos
_p <- [Binding (Fix g)]
xs
                Bool -> [()]
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> [()]) -> Bool -> [()]
forall a b. (a -> b) -> a -> b
$ (VarName
j VarName -> [VarName] -> [VarName]
forall a. a -> [a] -> [a]
: [VarName]
js) [VarName] -> [VarName] -> Bool
forall a. Eq a => a -> a -> Bool
== (NAttrPath (Fix g) -> [NKeyName (Fix g)]
forall a. NonEmpty a -> [a]
NE.toList NAttrPath (Fix g)
ns [NKeyName (Fix g)]
-> Fold [NKeyName (Fix g)] [NKeyName (Fix g)] VarName VarName
-> [VarName]
forall s t a b. s -> Fold s t a b -> [a]
^.. (NKeyName (Fix g) -> f (NKeyName (Fix g)))
-> [NKeyName (Fix g)] -> f [NKeyName (Fix g)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((NKeyName (Fix g) -> f (NKeyName (Fix g)))
 -> [NKeyName (Fix g)] -> f [NKeyName (Fix g)])
-> ((VarName -> f VarName)
    -> NKeyName (Fix g) -> f (NKeyName (Fix g)))
-> (VarName -> f VarName)
-> [NKeyName (Fix g)]
-> f [NKeyName (Fix g)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VarName -> f VarName) -> NKeyName (Fix g) -> f (NKeyName (Fix g))
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])]
_) -> Fix g -> Maybe (Fix g) -> Fix g
forall a. a -> Maybe a -> a
fromMaybe Fix g
e (Maybe (Fix g) -> Fix g) -> f (Maybe (Fix g)) -> f (Fix g)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Fix g) -> f (Maybe (Fix g))
f (Fix g -> Maybe (Fix g)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Fix g
v)
      ((Fix g
v, VarName
r : [VarName]
rest) : [(Fix g, [VarName])]
_) -> NonEmpty VarName
-> SourcePos -> LensLike' f (Fix g) (Maybe (Fix g))
forall ann (g :: * -> *).
NExprAnn ann g =>
NonEmpty VarName -> SourcePos -> Lens' (Fix g) (Maybe (Fix g))
ekey (VarName
r VarName -> [VarName] -> NonEmpty VarName
forall a. a -> [a] -> NonEmpty a
:| [VarName]
rest) SourcePos
pos Maybe (Fix g) -> f (Maybe (Fix g))
f Fix g
v

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


getFreeVars :: NExpr -> Set VarName
getFreeVars :: NExpr -> Set VarName
getFreeVars NExpr
e =
  case NExpr -> NExprF NExpr
forall (f :: * -> *). Fix f -> f (Fix f)
unFix NExpr
e of
    (NConstant    NAtom
_               ) -> Set VarName
forall a. Monoid a => a
mempty
    (NStr         NString NExpr
string          ) -> NString NExpr -> Set VarName
forall (t :: * -> *). Foldable t => t NExpr -> Set VarName
mapFreeVars NString NExpr
string
    (NSym         VarName
var             ) -> OneItem (Set VarName) -> Set VarName
forall x. One x => OneItem x -> x
one OneItem (Set VarName)
VarName
var
    (NList        [NExpr]
list            ) -> [NExpr] -> Set VarName
forall (t :: * -> *). Foldable t => t NExpr -> Set VarName
mapFreeVars [NExpr]
list
    (NSet   Recursivity
NonRecursive  [Binding NExpr]
bindings) -> [Binding NExpr] -> Set VarName
forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindFreeVars [Binding NExpr]
bindings
    (NSet   Recursivity
Recursive     [Binding NExpr]
bindings) -> ([Binding NExpr] -> Set VarName)
-> ([Binding NExpr] -> Set VarName)
-> [Binding NExpr]
-> Set VarName
forall a.
(a -> Set VarName) -> (a -> Set VarName) -> a -> Set VarName
diffBetween [Binding NExpr] -> Set VarName
forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindFreeVars [Binding NExpr] -> Set VarName
forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindDefs [Binding NExpr]
bindings
    (NLiteralPath Path
_               ) -> Set VarName
forall a. Monoid a => a
mempty
    (NEnvPath     Path
_               ) -> Set VarName
forall a. Monoid a => a
mempty
    (NUnary       NUnaryOp
_    NExpr
expr       ) -> NExpr -> Set VarName
getFreeVars NExpr
expr
    (NBinary      NBinaryOp
_    NExpr
left NExpr
right ) -> NExpr -> NExpr -> Set VarName
collectFreeVars NExpr
left NExpr
right
    (NSelect      Maybe NExpr
orExpr NExpr
expr NAttrPath NExpr
path) ->
      [Set VarName] -> Set VarName
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 (NExpr -> Set VarName) -> Maybe NExpr -> Set VarName
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 Set VarName -> Set VarName -> Set VarName
forall a. Semigroup a => a -> a -> a
<> NAttrPath NExpr -> Set VarName
pathFree NAttrPath NExpr
path
    (NAbs     (Param VarName
varname) NExpr
expr) -> VarName -> Set VarName -> Set VarName
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) ->
      Set VarName -> Set VarName -> Set VarName
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 Set VarName -> Set VarName -> Set VarName
forall a. Semigroup a => a -> a -> a
<> [Set VarName] -> Set VarName
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions (NExpr -> Set VarName
getFreeVars (NExpr -> Set VarName) -> [NExpr] -> [Set VarName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((VarName, Maybe NExpr) -> Maybe NExpr)
-> ParamSet NExpr -> [NExpr]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (VarName, Maybe NExpr) -> Maybe NExpr
forall a b. (a, b) -> b
snd ParamSet NExpr
pset))
        -- But remove the argument name if existing, and all arguments in the parameter set
        ((VarName -> Set VarName
forall x. One x => OneItem x -> x
one (VarName -> Set VarName) -> Maybe VarName -> Set VarName
forall b a. Monoid b => (a -> b) -> Maybe a -> b
`whenJust` Maybe VarName
varname) Set VarName -> Set VarName -> Set VarName
forall a. Semigroup a => a -> a -> a
<> [VarName] -> Set VarName
forall a. Ord a => [a] -> Set a
Set.fromList ((VarName, Maybe NExpr) -> VarName
forall a b. (a, b) -> a
fst ((VarName, Maybe NExpr) -> VarName) -> ParamSet NExpr -> [VarName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParamSet NExpr
pset))
    (NLet         [Binding NExpr]
bindings NExpr
expr   ) ->
      Set VarName -> Set VarName -> Set VarName
forall a. Ord a => Set a -> Set a -> Set a
Set.difference
        (NExpr -> Set VarName
getFreeVars NExpr
expr Set VarName -> Set VarName -> Set VarName
forall a. Semigroup a => a -> a -> a
<> [Binding NExpr] -> Set VarName
forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindFreeVars [Binding NExpr]
bindings)
        ([Binding NExpr] -> Set VarName
forall (t :: * -> *).
Foldable t =>
t (Binding NExpr) -> Set VarName
bindDefs [Binding NExpr]
bindings)
    (NIf          NExpr
cond NExpr
th   NExpr
el    ) -> [Set VarName] -> Set VarName
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions ([Set VarName] -> Set VarName) -> [Set VarName] -> Set VarName
forall a b. (a -> b) -> a -> b
$ NExpr -> Set VarName
getFreeVars (NExpr -> Set VarName) -> [NExpr] -> [Set VarName]
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
_               ) -> Set VarName
forall a. Monoid a => a
mempty
 where
  diffBetween :: (a -> Set VarName) -> (a -> Set VarName) -> a -> Set VarName
  diffBetween :: (a -> Set VarName) -> (a -> Set VarName) -> a -> Set VarName
diffBetween a -> Set VarName
g a -> Set VarName
f a
b = Set VarName -> Set VarName -> Set VarName
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 = Set VarName -> Set VarName -> Set VarName
forall a. Semigroup a => a -> a -> a
(<>) (Set VarName -> Set VarName -> Set VarName)
-> (NExpr -> Set VarName) -> NExpr -> NExpr -> Set VarName
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 :: t (Binding NExpr) -> Set VarName
bindDefs = (Binding NExpr -> Set VarName) -> t (Binding NExpr) -> Set VarName
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Binding NExpr -> Set VarName
forall r. Binding r -> Set VarName
bind1Def
   where
    bind1Def :: Binding r -> Set VarName
    bind1Def :: Binding r -> Set VarName
bind1Def (Inherit   Maybe r
Nothing                  [VarName]
_    SourcePos
_) = Set VarName
forall a. Monoid a => a
mempty
    bind1Def (Inherit  (Just r
_                 ) [VarName]
keys SourcePos
_) = [VarName] -> Set VarName
forall a. Ord a => [a] -> Set a
Set.fromList [VarName]
keys
    bind1Def (NamedVar (StaticKey  VarName
varname :| [NKeyName r]
_) r
_    SourcePos
_) = OneItem (Set VarName) -> Set VarName
forall x. One x => OneItem x -> x
one OneItem (Set VarName)
VarName
varname
    bind1Def (NamedVar (DynamicKey Antiquoted (NString r) r
_       :| [NKeyName r]
_) r
_    SourcePos
_) = Set VarName
forall a. Monoid a => a
mempty

  bindFreeVars :: Foldable t => t (Binding NExpr) -> Set VarName
  bindFreeVars :: t (Binding NExpr) -> Set VarName
bindFreeVars = (Binding NExpr -> Set VarName) -> t (Binding NExpr) -> Set VarName
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 SourcePos
_) = [VarName] -> Set VarName
forall a. Ord a => [a] -> Set a
Set.fromList [VarName]
keys
    bind1Free (Inherit (Just NExpr
scope) [VarName]
_    SourcePos
_) = NExpr -> Set VarName
getFreeVars NExpr
scope
    bind1Free (NamedVar NAttrPath NExpr
path        NExpr
expr SourcePos
_) = NAttrPath NExpr -> Set VarName
pathFree NAttrPath NExpr
path Set VarName -> Set VarName -> Set VarName
forall a. Semigroup a => a -> a -> a
<> NExpr -> Set VarName
getFreeVars NExpr
expr

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

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