{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}

module Language.Ginger.AST
where

import Data.Aeson (ToJSON (..), ToJSONKey (..), FromJSON (..), FromJSONKey (..))
import Data.List (intercalate)
import Data.Maybe (maybeToList)
import Data.Set (Set)
import qualified Data.Set as Set
import Data.String (IsString (..))
import Data.Text (Text, pattern (:<) )
import qualified Data.Text as Text
import Data.Vector (Vector)
import qualified Data.Vector as V
import Test.Tasty.QuickCheck (Arbitrary (..))
import qualified Test.Tasty.QuickCheck as QC

import Language.Ginger.SourcePosition

-- | Identifiers are used to represent variable names and object fields.
newtype Identifier =
  Identifier { Identifier -> Text
identifierName :: Text }
  deriving (Int -> Identifier -> ShowS
[Identifier] -> ShowS
Identifier -> String
(Int -> Identifier -> ShowS)
-> (Identifier -> String)
-> ([Identifier] -> ShowS)
-> Show Identifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Identifier -> ShowS
showsPrec :: Int -> Identifier -> ShowS
$cshow :: Identifier -> String
show :: Identifier -> String
$cshowList :: [Identifier] -> ShowS
showList :: [Identifier] -> ShowS
Show, Identifier -> Identifier -> Bool
(Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool) -> Eq Identifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Identifier -> Identifier -> Bool
== :: Identifier -> Identifier -> Bool
$c/= :: Identifier -> Identifier -> Bool
/= :: Identifier -> Identifier -> Bool
Eq, Eq Identifier
Eq Identifier =>
(Identifier -> Identifier -> Ordering)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Identifier)
-> (Identifier -> Identifier -> Identifier)
-> Ord Identifier
Identifier -> Identifier -> Bool
Identifier -> Identifier -> Ordering
Identifier -> Identifier -> Identifier
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
$ccompare :: Identifier -> Identifier -> Ordering
compare :: Identifier -> Identifier -> Ordering
$c< :: Identifier -> Identifier -> Bool
< :: Identifier -> Identifier -> Bool
$c<= :: Identifier -> Identifier -> Bool
<= :: Identifier -> Identifier -> Bool
$c> :: Identifier -> Identifier -> Bool
> :: Identifier -> Identifier -> Bool
$c>= :: Identifier -> Identifier -> Bool
>= :: Identifier -> Identifier -> Bool
$cmax :: Identifier -> Identifier -> Identifier
max :: Identifier -> Identifier -> Identifier
$cmin :: Identifier -> Identifier -> Identifier
min :: Identifier -> Identifier -> Identifier
Ord, [Identifier] -> Value
[Identifier] -> Encoding
Identifier -> Bool
Identifier -> Value
Identifier -> Encoding
(Identifier -> Value)
-> (Identifier -> Encoding)
-> ([Identifier] -> Value)
-> ([Identifier] -> Encoding)
-> (Identifier -> Bool)
-> ToJSON Identifier
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Identifier -> Value
toJSON :: Identifier -> Value
$ctoEncoding :: Identifier -> Encoding
toEncoding :: Identifier -> Encoding
$ctoJSONList :: [Identifier] -> Value
toJSONList :: [Identifier] -> Value
$ctoEncodingList :: [Identifier] -> Encoding
toEncodingList :: [Identifier] -> Encoding
$comitField :: Identifier -> Bool
omitField :: Identifier -> Bool
ToJSON, ToJSONKeyFunction [Identifier]
ToJSONKeyFunction Identifier
ToJSONKeyFunction Identifier
-> ToJSONKeyFunction [Identifier] -> ToJSONKey Identifier
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
$ctoJSONKey :: ToJSONKeyFunction Identifier
toJSONKey :: ToJSONKeyFunction Identifier
$ctoJSONKeyList :: ToJSONKeyFunction [Identifier]
toJSONKeyList :: ToJSONKeyFunction [Identifier]
ToJSONKey, Maybe Identifier
Value -> Parser [Identifier]
Value -> Parser Identifier
(Value -> Parser Identifier)
-> (Value -> Parser [Identifier])
-> Maybe Identifier
-> FromJSON Identifier
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Identifier
parseJSON :: Value -> Parser Identifier
$cparseJSONList :: Value -> Parser [Identifier]
parseJSONList :: Value -> Parser [Identifier]
$comittedField :: Maybe Identifier
omittedField :: Maybe Identifier
FromJSON, FromJSONKeyFunction [Identifier]
FromJSONKeyFunction Identifier
FromJSONKeyFunction Identifier
-> FromJSONKeyFunction [Identifier] -> FromJSONKey Identifier
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
$cfromJSONKey :: FromJSONKeyFunction Identifier
fromJSONKey :: FromJSONKeyFunction Identifier
$cfromJSONKeyList :: FromJSONKeyFunction [Identifier]
fromJSONKeyList :: FromJSONKeyFunction [Identifier]
FromJSONKey)

instance IsString Identifier where
  fromString :: String -> Identifier
fromString = Text -> Identifier
Identifier (Text -> Identifier) -> (String -> Text) -> String -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack

instance Arbitrary Identifier where
  arbitrary :: Gen Identifier
arbitrary = do
    Char
x <- [Gen Char] -> Gen Char
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof ([Gen Char] -> Gen Char) -> [Gen Char] -> Gen Char
forall a b. (a -> b) -> a -> b
$ (Char -> Gen Char) -> String -> [Gen Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Gen Char
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure String
identifierLeadChars
    String
xs <- Gen Char -> Gen String
forall a. Gen a -> Gen [a]
QC.listOf ([Gen Char] -> Gen Char
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof ([Gen Char] -> Gen Char) -> [Gen Char] -> Gen Char
forall a b. (a -> b) -> a -> b
$ (Char -> Gen Char) -> String -> [Gen Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Gen Char
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure String
identifierChars)
    Identifier -> Gen Identifier
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Identifier -> Gen Identifier) -> Identifier -> Gen Identifier
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier (Text -> Identifier) -> Text -> Identifier
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack (Char
x Char -> ShowS
forall a. a -> [a] -> [a]
: String
xs)
  shrink :: Identifier -> [Identifier]
shrink Identifier
_ = [] -- shrinking identifiers breaks references

isValidIdentifier :: Text -> Bool
isValidIdentifier :: Text -> Bool
isValidIdentifier Text
t =
  case Text
t of
    Text
Text.Empty -> Bool
False
    Char
c :< Text
_ -> Char
c Char -> String -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
identifierLeadChars

identifierLeadChars :: [Char]
identifierLeadChars :: String
identifierLeadChars =
  [ Char
'a' .. Char
'z' ] String -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'A' .. Char
'Z'] String -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'_']

identifierChars :: [Char]
identifierChars :: String
identifierChars =
  String
identifierLeadChars String -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'0' .. Char
'9']

-- | Represents an encoded string value, as opposed to a raw (unencoded) string,
-- which we represent as a plain 'Text'.
newtype Encoded =
  Encoded { Encoded -> Text
encoded :: Text }
  deriving (Int -> Encoded -> ShowS
[Encoded] -> ShowS
Encoded -> String
(Int -> Encoded -> ShowS)
-> (Encoded -> String) -> ([Encoded] -> ShowS) -> Show Encoded
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Encoded -> ShowS
showsPrec :: Int -> Encoded -> ShowS
$cshow :: Encoded -> String
show :: Encoded -> String
$cshowList :: [Encoded] -> ShowS
showList :: [Encoded] -> ShowS
Show, Encoded -> Encoded -> Bool
(Encoded -> Encoded -> Bool)
-> (Encoded -> Encoded -> Bool) -> Eq Encoded
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Encoded -> Encoded -> Bool
== :: Encoded -> Encoded -> Bool
$c/= :: Encoded -> Encoded -> Bool
/= :: Encoded -> Encoded -> Bool
Eq, Eq Encoded
Eq Encoded =>
(Encoded -> Encoded -> Ordering)
-> (Encoded -> Encoded -> Bool)
-> (Encoded -> Encoded -> Bool)
-> (Encoded -> Encoded -> Bool)
-> (Encoded -> Encoded -> Bool)
-> (Encoded -> Encoded -> Encoded)
-> (Encoded -> Encoded -> Encoded)
-> Ord Encoded
Encoded -> Encoded -> Bool
Encoded -> Encoded -> Ordering
Encoded -> Encoded -> Encoded
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
$ccompare :: Encoded -> Encoded -> Ordering
compare :: Encoded -> Encoded -> Ordering
$c< :: Encoded -> Encoded -> Bool
< :: Encoded -> Encoded -> Bool
$c<= :: Encoded -> Encoded -> Bool
<= :: Encoded -> Encoded -> Bool
$c> :: Encoded -> Encoded -> Bool
> :: Encoded -> Encoded -> Bool
$c>= :: Encoded -> Encoded -> Bool
>= :: Encoded -> Encoded -> Bool
$cmax :: Encoded -> Encoded -> Encoded
max :: Encoded -> Encoded -> Encoded
$cmin :: Encoded -> Encoded -> Encoded
min :: Encoded -> Encoded -> Encoded
Ord, NonEmpty Encoded -> Encoded
Encoded -> Encoded -> Encoded
(Encoded -> Encoded -> Encoded)
-> (NonEmpty Encoded -> Encoded)
-> (forall b. Integral b => b -> Encoded -> Encoded)
-> Semigroup Encoded
forall b. Integral b => b -> Encoded -> Encoded
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: Encoded -> Encoded -> Encoded
<> :: Encoded -> Encoded -> Encoded
$csconcat :: NonEmpty Encoded -> Encoded
sconcat :: NonEmpty Encoded -> Encoded
$cstimes :: forall b. Integral b => b -> Encoded -> Encoded
stimes :: forall b. Integral b => b -> Encoded -> Encoded
Semigroup, Semigroup Encoded
Encoded
Semigroup Encoded =>
Encoded
-> (Encoded -> Encoded -> Encoded)
-> ([Encoded] -> Encoded)
-> Monoid Encoded
[Encoded] -> Encoded
Encoded -> Encoded -> Encoded
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: Encoded
mempty :: Encoded
$cmappend :: Encoded -> Encoded -> Encoded
mappend :: Encoded -> Encoded -> Encoded
$cmconcat :: [Encoded] -> Encoded
mconcat :: [Encoded] -> Encoded
Monoid)

instance Arbitrary Encoded where
  arbitrary :: Gen Encoded
arbitrary = Text -> Encoded
Encoded (Text -> Encoded) -> (String -> Text) -> String -> Encoded
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Text -> Text -> Text -> Text
Text -> Text -> Text -> Text
Text.replace Text
"{" Text
"{ " (Text -> Text) -> (String -> Text) -> String -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack (String -> Encoded) -> Gen String -> Gen Encoded
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Char -> Gen String
forall a. Gen a -> Gen [a]
QC.listOf Gen Char
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: Encoded -> [Encoded]
shrink (Encoded Text
e) =
    (String -> Encoded) -> [String] -> [Encoded]
forall a b. (a -> b) -> [a] -> [b]
map (Text -> Encoded
Encoded (Text -> Encoded) -> (String -> Text) -> String -> Encoded
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack) ([String] -> [Encoded])
-> ([String] -> [String]) -> [String] -> [Encoded]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (String -> Bool) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) ([String] -> [Encoded]) -> [String] -> [Encoded]
forall a b. (a -> b) -> a -> b
$ String -> [String]
forall a. Arbitrary a => a -> [a]
shrink (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ Text -> String
Text.unpack Text
e

-- | A template consists of an optional parent template (specified in the
-- source using the @{% extends %}@ construct), and a body statement.
data Template =
  Template
    { Template -> Maybe Text
templateParent :: !(Maybe Text)
    , Template -> Statement
templateBody :: !Statement
    }
    deriving (Int -> Template -> ShowS
[Template] -> ShowS
Template -> String
(Int -> Template -> ShowS)
-> (Template -> String) -> ([Template] -> ShowS) -> Show Template
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Template -> ShowS
showsPrec :: Int -> Template -> ShowS
$cshow :: Template -> String
show :: Template -> String
$cshowList :: [Template] -> ShowS
showList :: [Template] -> ShowS
Show, Template -> Template -> Bool
(Template -> Template -> Bool)
-> (Template -> Template -> Bool) -> Eq Template
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Template -> Template -> Bool
== :: Template -> Template -> Bool
$c/= :: Template -> Template -> Bool
/= :: Template -> Template -> Bool
Eq)

-- | A block represents a section of a template that can be overridden in
-- derived templates ("template inheritance").
data Block =
  Block
    { Block -> Statement
blockBody :: !Statement
    , Block -> Scoped
blockScoped :: !Scoped
    , Block -> Required
blockRequired :: !Required
    }
    deriving (Int -> Block -> ShowS
[Block] -> ShowS
Block -> String
(Int -> Block -> ShowS)
-> (Block -> String) -> ([Block] -> ShowS) -> Show Block
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Block -> ShowS
showsPrec :: Int -> Block -> ShowS
$cshow :: Block -> String
show :: Block -> String
$cshowList :: [Block] -> ShowS
showList :: [Block] -> ShowS
Show, Block -> Block -> Bool
(Block -> Block -> Bool) -> (Block -> Block -> Bool) -> Eq Block
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Block -> Block -> Bool
== :: Block -> Block -> Bool
$c/= :: Block -> Block -> Bool
/= :: Block -> Block -> Bool
Eq, Eq Block
Eq Block =>
(Block -> Block -> Ordering)
-> (Block -> Block -> Bool)
-> (Block -> Block -> Bool)
-> (Block -> Block -> Bool)
-> (Block -> Block -> Bool)
-> (Block -> Block -> Block)
-> (Block -> Block -> Block)
-> Ord Block
Block -> Block -> Bool
Block -> Block -> Ordering
Block -> Block -> Block
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
$ccompare :: Block -> Block -> Ordering
compare :: Block -> Block -> Ordering
$c< :: Block -> Block -> Bool
< :: Block -> Block -> Bool
$c<= :: Block -> Block -> Bool
<= :: Block -> Block -> Bool
$c> :: Block -> Block -> Bool
> :: Block -> Block -> Bool
$c>= :: Block -> Block -> Bool
>= :: Block -> Block -> Bool
$cmax :: Block -> Block -> Block
max :: Block -> Block -> Block
$cmin :: Block -> Block -> Block
min :: Block -> Block -> Block
Ord)

data SetTarget
  = SetVar !Identifier
  | SetMutable !Identifier !Identifier
  deriving (Int -> SetTarget -> ShowS
[SetTarget] -> ShowS
SetTarget -> String
(Int -> SetTarget -> ShowS)
-> (SetTarget -> String)
-> ([SetTarget] -> ShowS)
-> Show SetTarget
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SetTarget -> ShowS
showsPrec :: Int -> SetTarget -> ShowS
$cshow :: SetTarget -> String
show :: SetTarget -> String
$cshowList :: [SetTarget] -> ShowS
showList :: [SetTarget] -> ShowS
Show, SetTarget -> SetTarget -> Bool
(SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> Bool) -> Eq SetTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SetTarget -> SetTarget -> Bool
== :: SetTarget -> SetTarget -> Bool
$c/= :: SetTarget -> SetTarget -> Bool
/= :: SetTarget -> SetTarget -> Bool
Eq, Eq SetTarget
Eq SetTarget =>
(SetTarget -> SetTarget -> Ordering)
-> (SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> Bool)
-> (SetTarget -> SetTarget -> SetTarget)
-> (SetTarget -> SetTarget -> SetTarget)
-> Ord SetTarget
SetTarget -> SetTarget -> Bool
SetTarget -> SetTarget -> Ordering
SetTarget -> SetTarget -> SetTarget
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
$ccompare :: SetTarget -> SetTarget -> Ordering
compare :: SetTarget -> SetTarget -> Ordering
$c< :: SetTarget -> SetTarget -> Bool
< :: SetTarget -> SetTarget -> Bool
$c<= :: SetTarget -> SetTarget -> Bool
<= :: SetTarget -> SetTarget -> Bool
$c> :: SetTarget -> SetTarget -> Bool
> :: SetTarget -> SetTarget -> Bool
$c>= :: SetTarget -> SetTarget -> Bool
>= :: SetTarget -> SetTarget -> Bool
$cmax :: SetTarget -> SetTarget -> SetTarget
max :: SetTarget -> SetTarget -> SetTarget
$cmin :: SetTarget -> SetTarget -> SetTarget
min :: SetTarget -> SetTarget -> SetTarget
Ord)

-- | A statement in the template language.
data Statement
  = -- | Statement tagged with a source position
    PositionedS !SourcePosition !Statement
  | -- | Bare text written in the template, outside of any curly braces
    ImmediateS !Encoded
  | -- | An expression interpolation: @{{ expr }}@
    InterpolationS !Expr
  | -- | Comment: @{# comment text #}@
    CommentS !Text
  | -- | @@@
    --   {% for keyVar, valueVar in iteree if loopCondition recursive %}
    --   body
    --   {% else %}
    --   body if empty
    --   {% endfor %}
    --   @@@
    ForS
      !(Maybe Identifier) -- optional loop key variable
      !Identifier -- loop element variable
      !Expr -- iteree
      !(Maybe Expr) -- optional loop condition
      !Recursivity -- enable recursion?
      !Statement -- loop body
      !(Maybe Statement) -- else branch in case iteree is empty
  | -- | @{% if condition %}yes branch{% else %}no branch{% endif %}@
    IfS
      !Expr -- condition
      !Statement -- true branch
      !(Maybe Statement) -- false branch
  | -- | @{% macro name(args) %}body{% endmacro %}@
    MacroS
      !Identifier -- macro name
      ![MacroArg] -- arguments
      !Statement -- body
  | -- | @{% call macroName(args) %}body{% endcall %}@
    CallS
      !Identifier -- callee
      ![Expr] -- positional args
      ![(Identifier, Expr)] -- keyword args
      !Statement -- body (@caller()@)
  | -- | @{% filter filterName(args, kwargs) %}body{% endfilter %}@
    FilterS
      !Identifier -- name
      ![Expr] -- positional args
      ![(Identifier, Expr)] -- keyword args
      !Statement -- body
  | -- | @{% set name=expr %}@
    SetS
      !SetTarget -- variable name
      !Expr -- value
  | -- | @{% set name %}body{% endset %}@
    SetBlockS
      !SetTarget -- variable name
      !Statement -- body
      !(Maybe Expr) -- optional filter
  | -- | @{% include includee ignore missing with context %}@
    IncludeS
      !Expr
      !IncludeMissingPolicy
      !IncludeContextPolicy
  | -- | @{% import importee as localName item, other_item as other ignore missing with context %}@
    ImportS
      !Expr -- filename
      !(Maybe Identifier) -- local name
      !(Maybe [(Identifier, Maybe Identifier)]) -- [ (imported name, local name) ]
      !IncludeMissingPolicy !IncludeContextPolicy
  | -- | @{% block name with scope required %}body{% endblock %}@
    BlockS
      !Identifier -- block name
      !Block
  | -- | @{% with defs %}body{% endwith %}@
    WithS
      ![(Identifier, Expr)]
      !Statement
  | -- | Group of statements; not parsed, but needed for combining statements
    -- sequentially.
    GroupS ![Statement]
  deriving (Int -> Statement -> ShowS
[Statement] -> ShowS
Statement -> String
(Int -> Statement -> ShowS)
-> (Statement -> String)
-> ([Statement] -> ShowS)
-> Show Statement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Statement -> ShowS
showsPrec :: Int -> Statement -> ShowS
$cshow :: Statement -> String
show :: Statement -> String
$cshowList :: [Statement] -> ShowS
showList :: [Statement] -> ShowS
Show, Statement -> Statement -> Bool
(Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool) -> Eq Statement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Statement -> Statement -> Bool
== :: Statement -> Statement -> Bool
$c/= :: Statement -> Statement -> Bool
/= :: Statement -> Statement -> Bool
Eq, Eq Statement
Eq Statement =>
(Statement -> Statement -> Ordering)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Statement)
-> (Statement -> Statement -> Statement)
-> Ord Statement
Statement -> Statement -> Bool
Statement -> Statement -> Ordering
Statement -> Statement -> Statement
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
$ccompare :: Statement -> Statement -> Ordering
compare :: Statement -> Statement -> Ordering
$c< :: Statement -> Statement -> Bool
< :: Statement -> Statement -> Bool
$c<= :: Statement -> Statement -> Bool
<= :: Statement -> Statement -> Bool
$c> :: Statement -> Statement -> Bool
> :: Statement -> Statement -> Bool
$c>= :: Statement -> Statement -> Bool
>= :: Statement -> Statement -> Bool
$cmax :: Statement -> Statement -> Statement
max :: Statement -> Statement -> Statement
$cmin :: Statement -> Statement -> Statement
min :: Statement -> Statement -> Statement
Ord)

data IncludeMissingPolicy
  = RequireMissing
  | IgnoreMissing
  deriving (Int -> IncludeMissingPolicy -> ShowS
[IncludeMissingPolicy] -> ShowS
IncludeMissingPolicy -> String
(Int -> IncludeMissingPolicy -> ShowS)
-> (IncludeMissingPolicy -> String)
-> ([IncludeMissingPolicy] -> ShowS)
-> Show IncludeMissingPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IncludeMissingPolicy -> ShowS
showsPrec :: Int -> IncludeMissingPolicy -> ShowS
$cshow :: IncludeMissingPolicy -> String
show :: IncludeMissingPolicy -> String
$cshowList :: [IncludeMissingPolicy] -> ShowS
showList :: [IncludeMissingPolicy] -> ShowS
Show, IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
(IncludeMissingPolicy -> IncludeMissingPolicy -> Bool)
-> (IncludeMissingPolicy -> IncludeMissingPolicy -> Bool)
-> Eq IncludeMissingPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
== :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
$c/= :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
/= :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
Eq, Eq IncludeMissingPolicy
Eq IncludeMissingPolicy =>
(IncludeMissingPolicy -> IncludeMissingPolicy -> Ordering)
-> (IncludeMissingPolicy -> IncludeMissingPolicy -> Bool)
-> (IncludeMissingPolicy -> IncludeMissingPolicy -> Bool)
-> (IncludeMissingPolicy -> IncludeMissingPolicy -> Bool)
-> (IncludeMissingPolicy -> IncludeMissingPolicy -> Bool)
-> (IncludeMissingPolicy
    -> IncludeMissingPolicy -> IncludeMissingPolicy)
-> (IncludeMissingPolicy
    -> IncludeMissingPolicy -> IncludeMissingPolicy)
-> Ord IncludeMissingPolicy
IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
IncludeMissingPolicy -> IncludeMissingPolicy -> Ordering
IncludeMissingPolicy
-> IncludeMissingPolicy -> IncludeMissingPolicy
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
$ccompare :: IncludeMissingPolicy -> IncludeMissingPolicy -> Ordering
compare :: IncludeMissingPolicy -> IncludeMissingPolicy -> Ordering
$c< :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
< :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
$c<= :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
<= :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
$c> :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
> :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
$c>= :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
>= :: IncludeMissingPolicy -> IncludeMissingPolicy -> Bool
$cmax :: IncludeMissingPolicy
-> IncludeMissingPolicy -> IncludeMissingPolicy
max :: IncludeMissingPolicy
-> IncludeMissingPolicy -> IncludeMissingPolicy
$cmin :: IncludeMissingPolicy
-> IncludeMissingPolicy -> IncludeMissingPolicy
min :: IncludeMissingPolicy
-> IncludeMissingPolicy -> IncludeMissingPolicy
Ord, Int -> IncludeMissingPolicy
IncludeMissingPolicy -> Int
IncludeMissingPolicy -> [IncludeMissingPolicy]
IncludeMissingPolicy -> IncludeMissingPolicy
IncludeMissingPolicy
-> IncludeMissingPolicy -> [IncludeMissingPolicy]
IncludeMissingPolicy
-> IncludeMissingPolicy
-> IncludeMissingPolicy
-> [IncludeMissingPolicy]
(IncludeMissingPolicy -> IncludeMissingPolicy)
-> (IncludeMissingPolicy -> IncludeMissingPolicy)
-> (Int -> IncludeMissingPolicy)
-> (IncludeMissingPolicy -> Int)
-> (IncludeMissingPolicy -> [IncludeMissingPolicy])
-> (IncludeMissingPolicy
    -> IncludeMissingPolicy -> [IncludeMissingPolicy])
-> (IncludeMissingPolicy
    -> IncludeMissingPolicy -> [IncludeMissingPolicy])
-> (IncludeMissingPolicy
    -> IncludeMissingPolicy
    -> IncludeMissingPolicy
    -> [IncludeMissingPolicy])
-> Enum IncludeMissingPolicy
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: IncludeMissingPolicy -> IncludeMissingPolicy
succ :: IncludeMissingPolicy -> IncludeMissingPolicy
$cpred :: IncludeMissingPolicy -> IncludeMissingPolicy
pred :: IncludeMissingPolicy -> IncludeMissingPolicy
$ctoEnum :: Int -> IncludeMissingPolicy
toEnum :: Int -> IncludeMissingPolicy
$cfromEnum :: IncludeMissingPolicy -> Int
fromEnum :: IncludeMissingPolicy -> Int
$cenumFrom :: IncludeMissingPolicy -> [IncludeMissingPolicy]
enumFrom :: IncludeMissingPolicy -> [IncludeMissingPolicy]
$cenumFromThen :: IncludeMissingPolicy
-> IncludeMissingPolicy -> [IncludeMissingPolicy]
enumFromThen :: IncludeMissingPolicy
-> IncludeMissingPolicy -> [IncludeMissingPolicy]
$cenumFromTo :: IncludeMissingPolicy
-> IncludeMissingPolicy -> [IncludeMissingPolicy]
enumFromTo :: IncludeMissingPolicy
-> IncludeMissingPolicy -> [IncludeMissingPolicy]
$cenumFromThenTo :: IncludeMissingPolicy
-> IncludeMissingPolicy
-> IncludeMissingPolicy
-> [IncludeMissingPolicy]
enumFromThenTo :: IncludeMissingPolicy
-> IncludeMissingPolicy
-> IncludeMissingPolicy
-> [IncludeMissingPolicy]
Enum, IncludeMissingPolicy
IncludeMissingPolicy
-> IncludeMissingPolicy -> Bounded IncludeMissingPolicy
forall a. a -> a -> Bounded a
$cminBound :: IncludeMissingPolicy
minBound :: IncludeMissingPolicy
$cmaxBound :: IncludeMissingPolicy
maxBound :: IncludeMissingPolicy
Bounded)

data IncludeContextPolicy
  = WithContext
  | WithoutContext
  deriving (Int -> IncludeContextPolicy -> ShowS
[IncludeContextPolicy] -> ShowS
IncludeContextPolicy -> String
(Int -> IncludeContextPolicy -> ShowS)
-> (IncludeContextPolicy -> String)
-> ([IncludeContextPolicy] -> ShowS)
-> Show IncludeContextPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IncludeContextPolicy -> ShowS
showsPrec :: Int -> IncludeContextPolicy -> ShowS
$cshow :: IncludeContextPolicy -> String
show :: IncludeContextPolicy -> String
$cshowList :: [IncludeContextPolicy] -> ShowS
showList :: [IncludeContextPolicy] -> ShowS
Show, IncludeContextPolicy -> IncludeContextPolicy -> Bool
(IncludeContextPolicy -> IncludeContextPolicy -> Bool)
-> (IncludeContextPolicy -> IncludeContextPolicy -> Bool)
-> Eq IncludeContextPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
== :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
$c/= :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
/= :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
Eq, Eq IncludeContextPolicy
Eq IncludeContextPolicy =>
(IncludeContextPolicy -> IncludeContextPolicy -> Ordering)
-> (IncludeContextPolicy -> IncludeContextPolicy -> Bool)
-> (IncludeContextPolicy -> IncludeContextPolicy -> Bool)
-> (IncludeContextPolicy -> IncludeContextPolicy -> Bool)
-> (IncludeContextPolicy -> IncludeContextPolicy -> Bool)
-> (IncludeContextPolicy
    -> IncludeContextPolicy -> IncludeContextPolicy)
-> (IncludeContextPolicy
    -> IncludeContextPolicy -> IncludeContextPolicy)
-> Ord IncludeContextPolicy
IncludeContextPolicy -> IncludeContextPolicy -> Bool
IncludeContextPolicy -> IncludeContextPolicy -> Ordering
IncludeContextPolicy
-> IncludeContextPolicy -> IncludeContextPolicy
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
$ccompare :: IncludeContextPolicy -> IncludeContextPolicy -> Ordering
compare :: IncludeContextPolicy -> IncludeContextPolicy -> Ordering
$c< :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
< :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
$c<= :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
<= :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
$c> :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
> :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
$c>= :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
>= :: IncludeContextPolicy -> IncludeContextPolicy -> Bool
$cmax :: IncludeContextPolicy
-> IncludeContextPolicy -> IncludeContextPolicy
max :: IncludeContextPolicy
-> IncludeContextPolicy -> IncludeContextPolicy
$cmin :: IncludeContextPolicy
-> IncludeContextPolicy -> IncludeContextPolicy
min :: IncludeContextPolicy
-> IncludeContextPolicy -> IncludeContextPolicy
Ord, Int -> IncludeContextPolicy
IncludeContextPolicy -> Int
IncludeContextPolicy -> [IncludeContextPolicy]
IncludeContextPolicy -> IncludeContextPolicy
IncludeContextPolicy
-> IncludeContextPolicy -> [IncludeContextPolicy]
IncludeContextPolicy
-> IncludeContextPolicy
-> IncludeContextPolicy
-> [IncludeContextPolicy]
(IncludeContextPolicy -> IncludeContextPolicy)
-> (IncludeContextPolicy -> IncludeContextPolicy)
-> (Int -> IncludeContextPolicy)
-> (IncludeContextPolicy -> Int)
-> (IncludeContextPolicy -> [IncludeContextPolicy])
-> (IncludeContextPolicy
    -> IncludeContextPolicy -> [IncludeContextPolicy])
-> (IncludeContextPolicy
    -> IncludeContextPolicy -> [IncludeContextPolicy])
-> (IncludeContextPolicy
    -> IncludeContextPolicy
    -> IncludeContextPolicy
    -> [IncludeContextPolicy])
-> Enum IncludeContextPolicy
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: IncludeContextPolicy -> IncludeContextPolicy
succ :: IncludeContextPolicy -> IncludeContextPolicy
$cpred :: IncludeContextPolicy -> IncludeContextPolicy
pred :: IncludeContextPolicy -> IncludeContextPolicy
$ctoEnum :: Int -> IncludeContextPolicy
toEnum :: Int -> IncludeContextPolicy
$cfromEnum :: IncludeContextPolicy -> Int
fromEnum :: IncludeContextPolicy -> Int
$cenumFrom :: IncludeContextPolicy -> [IncludeContextPolicy]
enumFrom :: IncludeContextPolicy -> [IncludeContextPolicy]
$cenumFromThen :: IncludeContextPolicy
-> IncludeContextPolicy -> [IncludeContextPolicy]
enumFromThen :: IncludeContextPolicy
-> IncludeContextPolicy -> [IncludeContextPolicy]
$cenumFromTo :: IncludeContextPolicy
-> IncludeContextPolicy -> [IncludeContextPolicy]
enumFromTo :: IncludeContextPolicy
-> IncludeContextPolicy -> [IncludeContextPolicy]
$cenumFromThenTo :: IncludeContextPolicy
-> IncludeContextPolicy
-> IncludeContextPolicy
-> [IncludeContextPolicy]
enumFromThenTo :: IncludeContextPolicy
-> IncludeContextPolicy
-> IncludeContextPolicy
-> [IncludeContextPolicy]
Enum, IncludeContextPolicy
IncludeContextPolicy
-> IncludeContextPolicy -> Bounded IncludeContextPolicy
forall a. a -> a -> Bounded a
$cminBound :: IncludeContextPolicy
minBound :: IncludeContextPolicy
$cmaxBound :: IncludeContextPolicy
maxBound :: IncludeContextPolicy
Bounded)

escapeComment :: Statement -> Statement
escapeComment :: Statement -> Statement
escapeComment (CommentS Text
txt) =
  case HasCallStack => Text -> Text -> [Text]
Text -> Text -> [Text]
Text.splitOn Text
"#}" Text
txt of
    [] -> [Statement] -> Statement
GroupS []
    [Text
x] -> Text -> Statement
CommentS Text
x
    [Text]
xs -> [Statement] -> Statement
GroupS ([Statement] -> Statement)
-> ([Text] -> [Statement]) -> [Text] -> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Statement] -> [[Statement]] -> [Statement]
forall a. [a] -> [[a]] -> [a]
intercalate [Text -> Statement
CommentS Text
"#", Text -> Statement
CommentS Text
"}"] ([[Statement]] -> [Statement])
-> ([Text] -> [[Statement]]) -> [Text] -> [Statement]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> [Statement]) -> [Text] -> [[Statement]]
forall a b. (a -> b) -> [a] -> [b]
map ((Statement -> [Statement] -> [Statement]
forall a. a -> [a] -> [a]
:[]) (Statement -> [Statement])
-> (Text -> Statement) -> Text -> [Statement]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Statement
CommentS) ([Text] -> Statement) -> [Text] -> Statement
forall a b. (a -> b) -> a -> b
$ [Text]
xs
escapeComment Statement
x = Statement
x

instance Arbitrary Statement where
  arbitrary :: Gen Statement
arbitrary = Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
forall a. Monoid a => a
mempty
  shrink :: Statement -> [Statement]
shrink (PositionedS SourcePosition
pos Statement
s) =
    SourcePosition -> Statement -> Statement
PositionedS SourcePosition
pos (Statement -> Statement) -> [Statement] -> [Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
s [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    [Statement
s]
  shrink (GroupS [Statement]
xs) = ([Statement] -> Statement) -> [[Statement]] -> [Statement]
forall a b. (a -> b) -> [a] -> [b]
map [Statement] -> Statement
GroupS ([[Statement]] -> [Statement]) -> [[Statement]] -> [Statement]
forall a b. (a -> b) -> a -> b
$ [Statement] -> [[Statement]]
forall a. Arbitrary a => a -> [a]
shrink [Statement]
xs
  shrink (ImmediateS Encoded
txt) = (Encoded -> Statement) -> [Encoded] -> [Statement]
forall a b. (a -> b) -> [a] -> [b]
map Encoded -> Statement
ImmediateS ([Encoded] -> [Statement]) -> [Encoded] -> [Statement]
forall a b. (a -> b) -> a -> b
$ Encoded -> [Encoded]
forall a. Arbitrary a => a -> [a]
shrink Encoded
txt
  shrink (InterpolationS Expr
e) = (Expr -> Statement) -> [Expr] -> [Statement]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> Statement
InterpolationS ([Expr] -> [Statement]) -> [Expr] -> [Statement]
forall a b. (a -> b) -> a -> b
$ Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
e
  shrink (CommentS Text
txt) = (String -> Statement) -> [String] -> [Statement]
forall a b. (a -> b) -> [a] -> [b]
map (Statement -> Statement
escapeComment (Statement -> Statement)
-> (String -> Statement) -> String -> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Statement
CommentS (Text -> Statement) -> (String -> Text) -> String -> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack) ([String] -> [Statement]) -> [String] -> [Statement]
forall a b. (a -> b) -> a -> b
$ String -> [String]
forall a. Arbitrary a => a -> [a]
shrink (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ Text -> String
Text.unpack Text
txt
  shrink (ForS Maybe Identifier
keyMay Identifier
val Expr
iteree Maybe Expr
condMay Recursivity
recur Statement
body Maybe Statement
elseBranchMay) =
    (Maybe Identifier
-> Identifier
-> Expr
-> Maybe Expr
-> Recursivity
-> Statement
-> Maybe Statement
-> Statement
ForS (Maybe Identifier
 -> Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement)
-> [Maybe Identifier]
-> [Identifier
    -> Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Identifier
keyMay [Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Identifier]
-> [Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
val [Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Expr]
-> [Maybe Expr
    -> Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
iteree [Maybe Expr
 -> Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Maybe Expr]
-> [Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
condMay [Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Recursivity] -> [Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Recursivity -> [Recursivity]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Recursivity
recur [Statement -> Maybe Statement -> Statement]
-> [Statement] -> [Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
body [Maybe Statement -> Statement] -> [Maybe Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Statement -> [Maybe Statement]
forall a. Arbitrary a => a -> [a]
shrink Maybe Statement
elseBranchMay) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Maybe Identifier
-> Identifier
-> Expr
-> Maybe Expr
-> Recursivity
-> Statement
-> Maybe Statement
-> Statement
ForS (Maybe Identifier
 -> Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement)
-> [Maybe Identifier]
-> [Identifier
    -> Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Identifier
keyMay [Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Identifier]
-> [Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
val [Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Expr]
-> [Maybe Expr
    -> Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
iteree [Maybe Expr
 -> Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Maybe Expr]
-> [Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
condMay [Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Recursivity] -> [Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Recursivity -> [Recursivity]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Recursivity
recur [Statement -> Maybe Statement -> Statement]
-> [Statement] -> [Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
body [Maybe Statement -> Statement] -> [Maybe Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Statement -> [Maybe Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Statement
elseBranchMay) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Maybe Identifier
-> Identifier
-> Expr
-> Maybe Expr
-> Recursivity
-> Statement
-> Maybe Statement
-> Statement
ForS (Maybe Identifier
 -> Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement)
-> [Maybe Identifier]
-> [Identifier
    -> Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Identifier
keyMay [Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Identifier]
-> [Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
val [Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Expr]
-> [Maybe Expr
    -> Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
iteree [Maybe Expr
 -> Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Maybe Expr]
-> [Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
condMay [Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Recursivity] -> [Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Recursivity -> [Recursivity]
forall a. Arbitrary a => a -> [a]
shrink Recursivity
recur [Statement -> Maybe Statement -> Statement]
-> [Statement] -> [Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
body [Maybe Statement -> Statement] -> [Maybe Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Statement -> [Maybe Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Statement
elseBranchMay) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Maybe Identifier
-> Identifier
-> Expr
-> Maybe Expr
-> Recursivity
-> Statement
-> Maybe Statement
-> Statement
ForS (Maybe Identifier
 -> Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement)
-> [Maybe Identifier]
-> [Identifier
    -> Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Identifier
keyMay [Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Identifier]
-> [Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
val [Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Expr]
-> [Maybe Expr
    -> Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
iteree [Maybe Expr
 -> Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Maybe Expr]
-> [Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. Arbitrary a => a -> [a]
shrink Maybe Expr
condMay [Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Recursivity] -> [Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Recursivity -> [Recursivity]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Recursivity
recur [Statement -> Maybe Statement -> Statement]
-> [Statement] -> [Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
body [Maybe Statement -> Statement] -> [Maybe Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Statement -> [Maybe Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Statement
elseBranchMay) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Maybe Identifier
-> Identifier
-> Expr
-> Maybe Expr
-> Recursivity
-> Statement
-> Maybe Statement
-> Statement
ForS (Maybe Identifier
 -> Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement)
-> [Maybe Identifier]
-> [Identifier
    -> Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Identifier
keyMay [Identifier
 -> Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Identifier]
-> [Expr
    -> Maybe Expr
    -> Recursivity
    -> Statement
    -> Maybe Statement
    -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
val [Expr
 -> Maybe Expr
 -> Recursivity
 -> Statement
 -> Maybe Statement
 -> Statement]
-> [Expr]
-> [Maybe Expr
    -> Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
iteree [Maybe Expr
 -> Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Maybe Expr]
-> [Recursivity -> Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
condMay [Recursivity -> Statement -> Maybe Statement -> Statement]
-> [Recursivity] -> [Statement -> Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Recursivity -> [Recursivity]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Recursivity
recur [Statement -> Maybe Statement -> Statement]
-> [Statement] -> [Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
body [Maybe Statement -> Statement] -> [Maybe Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Statement -> [Maybe Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Statement
elseBranchMay) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    [Statement
body] [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    [Statement]
-> (Statement -> [Statement]) -> Maybe Statement -> [Statement]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (Statement -> [Statement] -> [Statement]
forall a. a -> [a] -> [a]
:[]) Maybe Statement
elseBranchMay
  shrink (IfS Expr
cond Statement
yes Maybe Statement
noMay) =
    (Expr -> Statement -> Maybe Statement -> Statement
IfS (Expr -> Statement -> Maybe Statement -> Statement)
-> [Expr] -> [Statement -> Maybe Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
cond [Statement -> Maybe Statement -> Statement]
-> [Statement] -> [Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
yes [Maybe Statement -> Statement] -> [Maybe Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Statement -> [Maybe Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Statement
noMay) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Statement -> Maybe Statement -> Statement
IfS (Expr -> Statement -> Maybe Statement -> Statement)
-> [Expr] -> [Statement -> Maybe Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
cond [Statement -> Maybe Statement -> Statement]
-> [Statement] -> [Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
yes [Maybe Statement -> Statement] -> [Maybe Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Statement -> [Maybe Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Statement
noMay) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Statement -> Maybe Statement -> Statement
IfS (Expr -> Statement -> Maybe Statement -> Statement)
-> [Expr] -> [Statement -> Maybe Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
cond [Statement -> Maybe Statement -> Statement]
-> [Statement] -> [Maybe Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
yes [Maybe Statement -> Statement] -> [Maybe Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Statement -> [Maybe Statement]
forall a. Arbitrary a => a -> [a]
shrink Maybe Statement
noMay) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
yes) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Maybe Statement -> [Statement]
forall a. Maybe a -> [a]
maybeToList Maybe Statement
noMay)
  shrink (MacroS Identifier
name [MacroArg]
args Statement
body) =
    (Identifier -> [MacroArg] -> Statement -> Statement
MacroS (Identifier -> [MacroArg] -> Statement -> Statement)
-> [Identifier] -> [[MacroArg] -> Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [[MacroArg] -> Statement -> Statement]
-> [[MacroArg]] -> [Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [MacroArg] -> [[MacroArg]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [MacroArg]
args [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Identifier -> [MacroArg] -> Statement -> Statement
MacroS (Identifier -> [MacroArg] -> Statement -> Statement)
-> [Identifier] -> [[MacroArg] -> Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [[MacroArg] -> Statement -> Statement]
-> [[MacroArg]] -> [Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [MacroArg] -> [[MacroArg]]
forall a. Arbitrary a => a -> [a]
shrink [MacroArg]
args [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Identifier -> [MacroArg] -> Statement -> Statement
MacroS (Identifier -> [MacroArg] -> Statement -> Statement)
-> [Identifier] -> [[MacroArg] -> Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. Arbitrary a => a -> [a]
shrink Identifier
name [[MacroArg] -> Statement -> Statement]
-> [[MacroArg]] -> [Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [MacroArg] -> [[MacroArg]]
forall a. Arbitrary a => a -> [a]
shrink [MacroArg]
args [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    [Statement
body]
  shrink (CallS Identifier
name [Expr]
args [(Identifier, Expr)]
kwargs Statement
body) =
    (Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
CallS (Identifier
 -> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> [Identifier]
-> [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
-> [[Expr]] -> [[(Identifier, Expr)] -> Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Statement -> Statement]
-> [[(Identifier, Expr)]] -> [Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
CallS (Identifier
 -> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> [Identifier]
-> [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
-> [[Expr]] -> [[(Identifier, Expr)] -> Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Statement -> Statement]
-> [[(Identifier, Expr)]] -> [Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. Arbitrary a => a -> [a]
shrink [(Identifier, Expr)]
kwargs [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
CallS (Identifier
 -> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> [Identifier]
-> [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
-> [[Expr]] -> [[(Identifier, Expr)] -> Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. Arbitrary a => a -> [a]
shrink [Expr]
args [[(Identifier, Expr)] -> Statement -> Statement]
-> [[(Identifier, Expr)]] -> [Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    [Statement
body]
  shrink (FilterS Identifier
name [Expr]
args [(Identifier, Expr)]
kwargs Statement
body) =
    (Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
FilterS (Identifier
 -> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> [Identifier]
-> [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
-> [[Expr]] -> [[(Identifier, Expr)] -> Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Statement -> Statement]
-> [[(Identifier, Expr)]] -> [Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
FilterS (Identifier
 -> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> [Identifier]
-> [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
-> [[Expr]] -> [[(Identifier, Expr)] -> Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Statement -> Statement]
-> [[(Identifier, Expr)]] -> [Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. Arbitrary a => a -> [a]
shrink [(Identifier, Expr)]
kwargs [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
FilterS (Identifier
 -> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> [Identifier]
-> [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [[Expr] -> [(Identifier, Expr)] -> Statement -> Statement]
-> [[Expr]] -> [[(Identifier, Expr)] -> Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. Arbitrary a => a -> [a]
shrink [Expr]
args [[(Identifier, Expr)] -> Statement -> Statement]
-> [[(Identifier, Expr)]] -> [Statement -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    [Statement
body]
  shrink (SetS SetTarget
name Expr
expr) =
    (SetTarget -> Expr -> Statement
SetS (SetTarget -> Expr -> Statement)
-> [SetTarget] -> [Expr -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SetTarget -> [SetTarget]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure SetTarget
name [Expr -> Statement] -> [Expr] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
expr)
  shrink (SetBlockS SetTarget
name Statement
body Maybe Expr
filterMay) =
    (SetTarget -> Statement -> Maybe Expr -> Statement
SetBlockS (SetTarget -> Statement -> Maybe Expr -> Statement)
-> [SetTarget] -> [Statement -> Maybe Expr -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SetTarget -> [SetTarget]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure SetTarget
name [Statement -> Maybe Expr -> Statement]
-> [Statement] -> [Maybe Expr -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
body [Maybe Expr -> Statement] -> [Maybe Expr] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. Arbitrary a => a -> [a]
shrink Maybe Expr
filterMay) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (SetTarget -> Statement -> Maybe Expr -> Statement
SetBlockS (SetTarget -> Statement -> Maybe Expr -> Statement)
-> [SetTarget] -> [Statement -> Maybe Expr -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SetTarget -> [SetTarget]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure SetTarget
name [Statement -> Maybe Expr -> Statement]
-> [Statement] -> [Maybe Expr -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
body [Maybe Expr -> Statement] -> [Maybe Expr] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
filterMay)
  shrink (IncludeS Expr
name IncludeMissingPolicy
m IncludeContextPolicy
c) =
    (Expr -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement
IncludeS (Expr -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement)
-> [Expr]
-> [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
name [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [IncludeMissingPolicy] -> [IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeMissingPolicy -> [IncludeMissingPolicy]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure IncludeMissingPolicy
m [IncludeContextPolicy -> Statement]
-> [IncludeContextPolicy] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeContextPolicy -> [IncludeContextPolicy]
forall a. Arbitrary a => a -> [a]
shrink IncludeContextPolicy
c) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Expr -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement
IncludeS (Expr -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement)
-> [Expr]
-> [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
name [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [IncludeMissingPolicy] -> [IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeMissingPolicy -> [IncludeMissingPolicy]
forall a. Arbitrary a => a -> [a]
shrink IncludeMissingPolicy
m [IncludeContextPolicy -> Statement]
-> [IncludeContextPolicy] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeContextPolicy -> [IncludeContextPolicy]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure IncludeContextPolicy
c)
  shrink (ImportS Expr
name Maybe Identifier
lname Maybe [(Identifier, Maybe Identifier)]
imports IncludeMissingPolicy
m IncludeContextPolicy
c) =
    (Expr
-> Maybe Identifier
-> Maybe [(Identifier, Maybe Identifier)]
-> IncludeMissingPolicy
-> IncludeContextPolicy
-> Statement
ImportS (Expr
 -> Maybe Identifier
 -> Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy
 -> IncludeContextPolicy
 -> Statement)
-> [Expr]
-> [Maybe Identifier
    -> Maybe [(Identifier, Maybe Identifier)]
    -> IncludeMissingPolicy
    -> IncludeContextPolicy
    -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
name [Maybe Identifier
 -> Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy
 -> IncludeContextPolicy
 -> Statement]
-> [Maybe Identifier]
-> [Maybe [(Identifier, Maybe Identifier)]
    -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Identifier
lname [Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [Maybe [(Identifier, Maybe Identifier)]]
-> [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe [(Identifier, Maybe Identifier)]
-> [Maybe [(Identifier, Maybe Identifier)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe [(Identifier, Maybe Identifier)]
imports [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [IncludeMissingPolicy] -> [IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeMissingPolicy -> [IncludeMissingPolicy]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure IncludeMissingPolicy
m [IncludeContextPolicy -> Statement]
-> [IncludeContextPolicy] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeContextPolicy -> [IncludeContextPolicy]
forall a. Arbitrary a => a -> [a]
shrink IncludeContextPolicy
c) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Expr
-> Maybe Identifier
-> Maybe [(Identifier, Maybe Identifier)]
-> IncludeMissingPolicy
-> IncludeContextPolicy
-> Statement
ImportS (Expr
 -> Maybe Identifier
 -> Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy
 -> IncludeContextPolicy
 -> Statement)
-> [Expr]
-> [Maybe Identifier
    -> Maybe [(Identifier, Maybe Identifier)]
    -> IncludeMissingPolicy
    -> IncludeContextPolicy
    -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
name [Maybe Identifier
 -> Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy
 -> IncludeContextPolicy
 -> Statement]
-> [Maybe Identifier]
-> [Maybe [(Identifier, Maybe Identifier)]
    -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Identifier
lname [Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [Maybe [(Identifier, Maybe Identifier)]]
-> [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe [(Identifier, Maybe Identifier)]
-> [Maybe [(Identifier, Maybe Identifier)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe [(Identifier, Maybe Identifier)]
imports [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [IncludeMissingPolicy] -> [IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeMissingPolicy -> [IncludeMissingPolicy]
forall a. Arbitrary a => a -> [a]
shrink IncludeMissingPolicy
m [IncludeContextPolicy -> Statement]
-> [IncludeContextPolicy] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeContextPolicy -> [IncludeContextPolicy]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure IncludeContextPolicy
c) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Expr
-> Maybe Identifier
-> Maybe [(Identifier, Maybe Identifier)]
-> IncludeMissingPolicy
-> IncludeContextPolicy
-> Statement
ImportS (Expr
 -> Maybe Identifier
 -> Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy
 -> IncludeContextPolicy
 -> Statement)
-> [Expr]
-> [Maybe Identifier
    -> Maybe [(Identifier, Maybe Identifier)]
    -> IncludeMissingPolicy
    -> IncludeContextPolicy
    -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
name [Maybe Identifier
 -> Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy
 -> IncludeContextPolicy
 -> Statement]
-> [Maybe Identifier]
-> [Maybe [(Identifier, Maybe Identifier)]
    -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Identifier -> [Maybe Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Identifier
lname [Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [Maybe [(Identifier, Maybe Identifier)]]
-> [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe [(Identifier, Maybe Identifier)]
-> [Maybe [(Identifier, Maybe Identifier)]]
forall a. Arbitrary a => a -> [a]
shrink Maybe [(Identifier, Maybe Identifier)]
imports [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [IncludeMissingPolicy] -> [IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeMissingPolicy -> [IncludeMissingPolicy]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure IncludeMissingPolicy
m [IncludeContextPolicy -> Statement]
-> [IncludeContextPolicy] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeContextPolicy -> [IncludeContextPolicy]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure IncludeContextPolicy
c) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Expr
-> Maybe Identifier
-> Maybe [(Identifier, Maybe Identifier)]
-> IncludeMissingPolicy
-> IncludeContextPolicy
-> Statement
ImportS (Expr
 -> Maybe Identifier
 -> Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy
 -> IncludeContextPolicy
 -> Statement)
-> [Expr]
-> [Maybe Identifier
    -> Maybe [(Identifier, Maybe Identifier)]
    -> IncludeMissingPolicy
    -> IncludeContextPolicy
    -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
name [Maybe Identifier
 -> Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy
 -> IncludeContextPolicy
 -> Statement]
-> [Maybe Identifier]
-> [Maybe [(Identifier, Maybe Identifier)]
    -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Identifier -> [Maybe Identifier]
forall a. Arbitrary a => a -> [a]
shrink Maybe Identifier
lname [Maybe [(Identifier, Maybe Identifier)]
 -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [Maybe [(Identifier, Maybe Identifier)]]
-> [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe [(Identifier, Maybe Identifier)]
-> [Maybe [(Identifier, Maybe Identifier)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe [(Identifier, Maybe Identifier)]
imports [IncludeMissingPolicy -> IncludeContextPolicy -> Statement]
-> [IncludeMissingPolicy] -> [IncludeContextPolicy -> Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeMissingPolicy -> [IncludeMissingPolicy]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure IncludeMissingPolicy
m [IncludeContextPolicy -> Statement]
-> [IncludeContextPolicy] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IncludeContextPolicy -> [IncludeContextPolicy]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure IncludeContextPolicy
c)
  shrink (BlockS Identifier
name (Block Statement
b Scoped
s Required
r)) =
    (Identifier -> Block -> Statement
BlockS (Identifier -> Block -> Statement)
-> [Identifier] -> [Block -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [Block -> Statement] -> [Block] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Statement -> Scoped -> Required -> Block
Block (Statement -> Scoped -> Required -> Block)
-> [Statement] -> [Scoped -> Required -> Block]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
b [Scoped -> Required -> Block] -> [Scoped] -> [Required -> Block]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Scoped -> [Scoped]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Scoped
s [Required -> Block] -> [Required] -> [Block]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Required -> [Required]
forall a. Arbitrary a => a -> [a]
shrink Required
r)) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    (Identifier -> Block -> Statement
BlockS (Identifier -> Block -> Statement)
-> [Identifier] -> [Block -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
name [Block -> Statement] -> [Block] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Statement -> Scoped -> Required -> Block
Block (Statement -> Scoped -> Required -> Block)
-> [Statement] -> [Scoped -> Required -> Block]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
b [Scoped -> Required -> Block] -> [Scoped] -> [Required -> Block]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Scoped -> [Scoped]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Scoped
s [Required -> Block] -> [Required] -> [Block]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Required -> [Required]
forall a. Arbitrary a => a -> [a]
shrink Required
r)) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    [Statement
b]
  shrink (WithS [(Identifier, Expr)]
defs Statement
body) =
    ([(Identifier, Expr)] -> Statement -> Statement
WithS ([(Identifier, Expr)] -> Statement -> Statement)
-> [[(Identifier, Expr)]] -> [Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
defs [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    ([(Identifier, Expr)] -> Statement -> Statement
WithS ([(Identifier, Expr)] -> Statement -> Statement)
-> [[(Identifier, Expr)]] -> [Statement -> Statement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. Arbitrary a => a -> [a]
shrink [(Identifier, Expr)]
defs [Statement -> Statement] -> [Statement] -> [Statement]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Statement -> [Statement]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement
body) [Statement] -> [Statement] -> [Statement]
forall a. [a] -> [a] -> [a]
++
    [Statement
body]

instance Arbitrary IncludeMissingPolicy where
  arbitrary :: Gen IncludeMissingPolicy
arbitrary = [Gen IncludeMissingPolicy] -> Gen IncludeMissingPolicy
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof ([Gen IncludeMissingPolicy] -> Gen IncludeMissingPolicy)
-> [Gen IncludeMissingPolicy] -> Gen IncludeMissingPolicy
forall a b. (a -> b) -> a -> b
$ (IncludeMissingPolicy -> Gen IncludeMissingPolicy)
-> [IncludeMissingPolicy] -> [Gen IncludeMissingPolicy]
forall a b. (a -> b) -> [a] -> [b]
map IncludeMissingPolicy -> Gen IncludeMissingPolicy
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [IncludeMissingPolicy
forall a. Bounded a => a
minBound .. IncludeMissingPolicy
forall a. Bounded a => a
maxBound]

instance Arbitrary IncludeContextPolicy where
  arbitrary :: Gen IncludeContextPolicy
arbitrary = [Gen IncludeContextPolicy] -> Gen IncludeContextPolicy
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof ([Gen IncludeContextPolicy] -> Gen IncludeContextPolicy)
-> [Gen IncludeContextPolicy] -> Gen IncludeContextPolicy
forall a b. (a -> b) -> a -> b
$ (IncludeContextPolicy -> Gen IncludeContextPolicy)
-> [IncludeContextPolicy] -> [Gen IncludeContextPolicy]
forall a b. (a -> b) -> [a] -> [b]
map IncludeContextPolicy -> Gen IncludeContextPolicy
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [IncludeContextPolicy
forall a. Bounded a => a
minBound .. IncludeContextPolicy
forall a. Bounded a => a
maxBound]

arbitraryStatement :: Set Identifier -> QC.Gen Statement
arbitraryStatement :: Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
defined = do
    Int
fuel <- Gen Int
QC.getSize
    Int -> Gen Statement -> Gen Statement
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int
fuel Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (Gen Statement -> Gen Statement) -> Gen Statement -> Gen Statement
forall a b. (a -> b) -> a -> b
$
      [Gen Statement] -> Gen Statement
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof
        [ Encoded -> Statement
ImmediateS (Encoded -> Statement) -> Gen Encoded -> Gen Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Encoded
forall a. Arbitrary a => Gen a
arbitrary
        , Expr -> Statement
InterpolationS (Expr -> Statement) -> Gen Expr -> Gen Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
        , Statement -> Statement
escapeComment (Statement -> Statement)
-> (String -> Statement) -> String -> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Statement
CommentS (Text -> Statement) -> (String -> Text) -> String -> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
Text.strip (Text -> Text) -> (String -> Text) -> String -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack (String -> Statement) -> Gen String -> Gen Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen String
forall a. Arbitrary a => Gen a
arbitrary

        , do
            let fuel' :: Int
fuel' = Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
6
            Maybe Identifier
keyNameMaybe <- Gen (Maybe Identifier)
forall a. Arbitrary a => Gen a
arbitrary
            Identifier
valName <- Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary
            Expr
iteree <- Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize Int
fuel' (Gen Expr -> Gen Expr) -> Gen Expr -> Gen Expr
forall a b. (a -> b) -> a -> b
$ Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
            let defined' :: Set Identifier
defined' = Set Identifier
forall a. Monoid a => a
mempty Set Identifier -> Set Identifier -> Set Identifier
forall a. Semigroup a => a -> a -> a
<> Identifier -> Set Identifier
forall a. a -> Set a
Set.singleton Identifier
valName Set Identifier -> Set Identifier -> Set Identifier
forall a. Semigroup a => a -> a -> a
<> [Identifier] -> Set Identifier
forall a. Ord a => [a] -> Set a
Set.fromList (Maybe Identifier -> [Identifier]
forall a. Maybe a -> [a]
maybeToList Maybe Identifier
keyNameMaybe) Set Identifier -> Set Identifier -> Set Identifier
forall a. Semigroup a => a -> a -> a
<> Identifier -> Set Identifier
forall a. a -> Set a
Set.singleton Identifier
"loop"
            Maybe Expr
filterMay <- [Gen (Maybe Expr)] -> Gen (Maybe Expr)
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof [ Maybe Expr -> Gen (Maybe Expr)
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
forall a. Maybe a
Nothing, Int -> Gen (Maybe Expr) -> Gen (Maybe Expr)
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize Int
fuel' (Gen (Maybe Expr) -> Gen (Maybe Expr))
-> Gen (Maybe Expr) -> Gen (Maybe Expr)
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Gen Expr -> Gen (Maybe Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined ]
            Statement
body <- Int -> Gen Statement -> Gen Statement
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize Int
fuel' (Gen Statement -> Gen Statement) -> Gen Statement -> Gen Statement
forall a b. (a -> b) -> a -> b
$ Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
defined'
            Maybe Statement
elseBody <- Int -> Gen (Maybe Statement) -> Gen (Maybe Statement)
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize Int
fuel' (Gen (Maybe Statement) -> Gen (Maybe Statement))
-> Gen (Maybe Statement) -> Gen (Maybe Statement)
forall a b. (a -> b) -> a -> b
$ [Gen (Maybe Statement)] -> Gen (Maybe Statement)
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof [ Maybe Statement -> Gen (Maybe Statement)
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Statement
forall a. Maybe a
Nothing, Statement -> Maybe Statement
forall a. a -> Maybe a
Just (Statement -> Maybe Statement)
-> Gen Statement -> Gen (Maybe Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
defined' ]
            Recursivity
recursive <- Gen Recursivity
forall a. Arbitrary a => Gen a
arbitrary

            Statement -> Gen Statement
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Statement -> Gen Statement) -> Statement -> Gen Statement
forall a b. (a -> b) -> a -> b
$ Maybe Identifier
-> Identifier
-> Expr
-> Maybe Expr
-> Recursivity
-> Statement
-> Maybe Statement
-> Statement
ForS Maybe Identifier
keyNameMaybe Identifier
valName Expr
iteree Maybe Expr
filterMay Recursivity
recursive Statement
body Maybe Statement
elseBody

        , Expr -> Statement -> Maybe Statement -> Statement
IfS (Expr -> Statement -> Maybe Statement -> Statement)
-> Gen Expr -> Gen (Statement -> Maybe Statement -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
3) (Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined)
              Gen (Statement -> Maybe Statement -> Statement)
-> Gen Statement -> Gen (Maybe Statement -> Statement)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen Statement -> Gen Statement
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
3) (Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
defined)
              Gen (Maybe Statement -> Statement)
-> Gen (Maybe Statement) -> Gen Statement
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen (Maybe Statement) -> Gen (Maybe Statement)
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
3) ([Gen (Maybe Statement)] -> Gen (Maybe Statement)
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof [ Maybe Statement -> Gen (Maybe Statement)
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Statement
forall a. Maybe a
Nothing, Statement -> Maybe Statement
forall a. a -> Maybe a
Just (Statement -> Maybe Statement)
-> Gen Statement -> Gen (Maybe Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
defined ])

        , do
            [MacroArg]
args <- Int -> Gen [MacroArg] -> Gen [MacroArg]
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2) (Gen [MacroArg] -> Gen [MacroArg])
-> Gen [MacroArg] -> Gen [MacroArg]
forall a b. (a -> b) -> a -> b
$
                      Gen MacroArg -> Gen [MacroArg]
forall a. Gen a -> Gen [a]
QC.listOf ((,) (Identifier -> Maybe Expr -> MacroArg)
-> Gen Identifier -> Gen (Maybe Expr -> MacroArg)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary Gen (Maybe Expr -> MacroArg) -> Gen (Maybe Expr) -> Gen MacroArg
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Gen (Maybe Expr)] -> Gen (Maybe Expr)
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof [ Maybe Expr -> Gen (Maybe Expr)
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
forall a. Maybe a
Nothing, Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Gen Expr -> Gen (Maybe Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
forall a. Monoid a => a
mempty ])
            let defined' :: Set Identifier
defined' = [Identifier] -> Set Identifier
forall a. Ord a => [a] -> Set a
Set.fromList ((MacroArg -> Identifier) -> [MacroArg] -> [Identifier]
forall a b. (a -> b) -> [a] -> [b]
map MacroArg -> Identifier
forall a b. (a, b) -> a
fst [MacroArg]
args)
            Statement
body <- Int -> Gen Statement -> Gen Statement
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2) (Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
defined')
            Identifier
name <- Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary
            Statement -> Gen Statement
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Statement -> Gen Statement) -> Statement -> Gen Statement
forall a b. (a -> b) -> a -> b
$ Identifier -> [MacroArg] -> Statement -> Statement
MacroS Identifier
name [MacroArg]
args Statement
body
        , Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
CallS (Identifier
 -> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> Gen Identifier
-> Gen ([Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary
                 Gen ([Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> Gen [Expr]
-> Gen ([(Identifier, Expr)] -> Statement -> Statement)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen [Expr] -> Gen [Expr]
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
4) (Gen Expr -> Gen [Expr]
forall a. Gen a -> Gen [a]
QC.listOf (Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined))
                 Gen ([(Identifier, Expr)] -> Statement -> Statement)
-> Gen [(Identifier, Expr)] -> Gen (Statement -> Statement)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen [(Identifier, Expr)] -> Gen [(Identifier, Expr)]
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
4) (Gen (Identifier, Expr) -> Gen [(Identifier, Expr)]
forall a. Gen a -> Gen [a]
QC.listOf ((,) (Identifier -> Expr -> (Identifier, Expr))
-> Gen Identifier -> Gen (Expr -> (Identifier, Expr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary Gen (Expr -> (Identifier, Expr))
-> Gen Expr -> Gen (Identifier, Expr)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined))
                 Gen (Statement -> Statement) -> Gen Statement -> Gen Statement
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen Statement -> Gen Statement
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2) (Set Identifier -> Gen Statement
arbitraryStatement (Set Identifier -> Gen Statement)
-> Set Identifier -> Gen Statement
forall a b. (a -> b) -> a -> b
$ Set Identifier
defined Set Identifier -> Set Identifier -> Set Identifier
forall a. Semigroup a => a -> a -> a
<> Identifier -> Set Identifier
forall a. a -> Set a
Set.singleton Identifier
"caller")
        , Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
FilterS (Identifier
 -> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> Gen Identifier
-> Gen ([Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary
                  Gen ([Expr] -> [(Identifier, Expr)] -> Statement -> Statement)
-> Gen [Expr]
-> Gen ([(Identifier, Expr)] -> Statement -> Statement)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen [Expr] -> Gen [Expr]
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
3) (Gen Expr -> Gen [Expr]
forall a. Gen a -> Gen [a]
QC.listOf (Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined))
                  Gen ([(Identifier, Expr)] -> Statement -> Statement)
-> Gen [(Identifier, Expr)] -> Gen (Statement -> Statement)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen [(Identifier, Expr)] -> Gen [(Identifier, Expr)]
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
3) (Gen (Identifier, Expr) -> Gen [(Identifier, Expr)]
forall a. Gen a -> Gen [a]
QC.listOf ((,) (Identifier -> Expr -> (Identifier, Expr))
-> Gen Identifier -> Gen (Expr -> (Identifier, Expr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary Gen (Expr -> (Identifier, Expr))
-> Gen Expr -> Gen (Identifier, Expr)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined))
                  Gen (Statement -> Statement) -> Gen Statement -> Gen Statement
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen Statement -> Gen Statement
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
3) (Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
defined)
        , SetTarget -> Expr -> Statement
SetS (SetTarget -> Expr -> Statement)
-> Gen SetTarget -> Gen (Expr -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, Gen SetTarget)] -> Gen SetTarget
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
QC.frequency
                      [ (Int
100, Identifier -> SetTarget
SetVar (Identifier -> SetTarget) -> Gen Identifier -> Gen SetTarget
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary)
                      , (Int
5, Identifier -> Identifier -> SetTarget
SetMutable (Identifier -> Identifier -> SetTarget)
-> Gen Identifier -> Gen (Identifier -> SetTarget)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary Gen (Identifier -> SetTarget) -> Gen Identifier -> Gen SetTarget
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary)
                      ]
               Gen (Expr -> Statement) -> Gen Expr -> Gen Statement
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2) (Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined)
        , SetTarget -> Statement -> Maybe Expr -> Statement
SetBlockS (SetTarget -> Statement -> Maybe Expr -> Statement)
-> Gen SetTarget -> Gen (Statement -> Maybe Expr -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, Gen SetTarget)] -> Gen SetTarget
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
QC.frequency
                          [ (Int
100, Identifier -> SetTarget
SetVar (Identifier -> SetTarget) -> Gen Identifier -> Gen SetTarget
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary)
                          , (Int
5, Identifier -> Identifier -> SetTarget
SetMutable (Identifier -> Identifier -> SetTarget)
-> Gen Identifier -> Gen (Identifier -> SetTarget)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary Gen (Identifier -> SetTarget) -> Gen Identifier -> Gen SetTarget
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary)
                          ]
                    Gen (Statement -> Maybe Expr -> Statement)
-> Gen Statement -> Gen (Maybe Expr -> Statement)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen Statement -> Gen Statement
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2) (Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
defined)
                    Gen (Maybe Expr -> Statement) -> Gen (Maybe Expr) -> Gen Statement
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen (Maybe Expr) -> Gen (Maybe Expr)
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2) ([Gen (Maybe Expr)] -> Gen (Maybe Expr)
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof [ Maybe Expr -> Gen (Maybe Expr)
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
forall a. Maybe a
Nothing, Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Gen Expr -> Gen (Maybe Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined ])

        -- , IncludeS <$> arbitraryExpr defined
        -- , BlockS <$> arbitrary
        --          <*> QC.resize (fuel `div` 2) (arbitraryStatement defined)
        --          <*> arbitrary
        --          <*> arbitrary

        , do
            [(Identifier, Expr)]
vars <- Gen (Identifier, Expr) -> Gen [(Identifier, Expr)]
forall a. Gen a -> Gen [a]
QC.listOf1 ((,) (Identifier -> Expr -> (Identifier, Expr))
-> Gen Identifier -> Gen (Expr -> (Identifier, Expr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary Gen (Expr -> (Identifier, Expr))
-> Gen Expr -> Gen (Identifier, Expr)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
4) (Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined))
            let defined' :: Set Identifier
defined' = Set Identifier
forall a. Monoid a => a
mempty Set Identifier -> Set Identifier -> Set Identifier
forall a. Semigroup a => a -> a -> a
<> [Identifier] -> Set Identifier
forall a. Ord a => [a] -> Set a
Set.fromList (((Identifier, Expr) -> Identifier)
-> [(Identifier, Expr)] -> [Identifier]
forall a b. (a -> b) -> [a] -> [b]
map (Identifier, Expr) -> Identifier
forall a b. (a, b) -> a
fst [(Identifier, Expr)]
vars)
            Statement
body <- Int -> Gen Statement -> Gen Statement
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
3 Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
4) (Set Identifier -> Gen Statement
arbitraryStatement Set Identifier
defined')
            Statement -> Gen Statement
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Statement -> Gen Statement) -> Statement -> Gen Statement
forall a b. (a -> b) -> a -> b
$ [(Identifier, Expr)] -> Statement -> Statement
WithS [(Identifier, Expr)]
vars Statement
body
        ]

class Boolish a where
  is :: a -> Bool

isNot :: Boolish a => a -> Bool
isNot :: forall a. Boolish a => a -> Bool
isNot = Bool -> Bool
not (Bool -> Bool) -> (a -> Bool) -> a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
forall a. Boolish a => a -> Bool
is

data Scoped = NotScoped | Scoped
  deriving (Int -> Scoped -> ShowS
[Scoped] -> ShowS
Scoped -> String
(Int -> Scoped -> ShowS)
-> (Scoped -> String) -> ([Scoped] -> ShowS) -> Show Scoped
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Scoped -> ShowS
showsPrec :: Int -> Scoped -> ShowS
$cshow :: Scoped -> String
show :: Scoped -> String
$cshowList :: [Scoped] -> ShowS
showList :: [Scoped] -> ShowS
Show, ReadPrec [Scoped]
ReadPrec Scoped
Int -> ReadS Scoped
ReadS [Scoped]
(Int -> ReadS Scoped)
-> ReadS [Scoped]
-> ReadPrec Scoped
-> ReadPrec [Scoped]
-> Read Scoped
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Scoped
readsPrec :: Int -> ReadS Scoped
$creadList :: ReadS [Scoped]
readList :: ReadS [Scoped]
$creadPrec :: ReadPrec Scoped
readPrec :: ReadPrec Scoped
$creadListPrec :: ReadPrec [Scoped]
readListPrec :: ReadPrec [Scoped]
Read, Scoped -> Scoped -> Bool
(Scoped -> Scoped -> Bool)
-> (Scoped -> Scoped -> Bool) -> Eq Scoped
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Scoped -> Scoped -> Bool
== :: Scoped -> Scoped -> Bool
$c/= :: Scoped -> Scoped -> Bool
/= :: Scoped -> Scoped -> Bool
Eq, Eq Scoped
Eq Scoped =>
(Scoped -> Scoped -> Ordering)
-> (Scoped -> Scoped -> Bool)
-> (Scoped -> Scoped -> Bool)
-> (Scoped -> Scoped -> Bool)
-> (Scoped -> Scoped -> Bool)
-> (Scoped -> Scoped -> Scoped)
-> (Scoped -> Scoped -> Scoped)
-> Ord Scoped
Scoped -> Scoped -> Bool
Scoped -> Scoped -> Ordering
Scoped -> Scoped -> Scoped
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
$ccompare :: Scoped -> Scoped -> Ordering
compare :: Scoped -> Scoped -> Ordering
$c< :: Scoped -> Scoped -> Bool
< :: Scoped -> Scoped -> Bool
$c<= :: Scoped -> Scoped -> Bool
<= :: Scoped -> Scoped -> Bool
$c> :: Scoped -> Scoped -> Bool
> :: Scoped -> Scoped -> Bool
$c>= :: Scoped -> Scoped -> Bool
>= :: Scoped -> Scoped -> Bool
$cmax :: Scoped -> Scoped -> Scoped
max :: Scoped -> Scoped -> Scoped
$cmin :: Scoped -> Scoped -> Scoped
min :: Scoped -> Scoped -> Scoped
Ord, Int -> Scoped
Scoped -> Int
Scoped -> [Scoped]
Scoped -> Scoped
Scoped -> Scoped -> [Scoped]
Scoped -> Scoped -> Scoped -> [Scoped]
(Scoped -> Scoped)
-> (Scoped -> Scoped)
-> (Int -> Scoped)
-> (Scoped -> Int)
-> (Scoped -> [Scoped])
-> (Scoped -> Scoped -> [Scoped])
-> (Scoped -> Scoped -> [Scoped])
-> (Scoped -> Scoped -> Scoped -> [Scoped])
-> Enum Scoped
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Scoped -> Scoped
succ :: Scoped -> Scoped
$cpred :: Scoped -> Scoped
pred :: Scoped -> Scoped
$ctoEnum :: Int -> Scoped
toEnum :: Int -> Scoped
$cfromEnum :: Scoped -> Int
fromEnum :: Scoped -> Int
$cenumFrom :: Scoped -> [Scoped]
enumFrom :: Scoped -> [Scoped]
$cenumFromThen :: Scoped -> Scoped -> [Scoped]
enumFromThen :: Scoped -> Scoped -> [Scoped]
$cenumFromTo :: Scoped -> Scoped -> [Scoped]
enumFromTo :: Scoped -> Scoped -> [Scoped]
$cenumFromThenTo :: Scoped -> Scoped -> Scoped -> [Scoped]
enumFromThenTo :: Scoped -> Scoped -> Scoped -> [Scoped]
Enum, Scoped
Scoped -> Scoped -> Bounded Scoped
forall a. a -> a -> Bounded a
$cminBound :: Scoped
minBound :: Scoped
$cmaxBound :: Scoped
maxBound :: Scoped
Bounded)

instance Boolish Scoped where
  is :: Scoped -> Bool
is = (Scoped -> Scoped -> Bool
forall a. Eq a => a -> a -> Bool
== Scoped
Scoped)

data Required = Optional | Required
  deriving (Int -> Required -> ShowS
[Required] -> ShowS
Required -> String
(Int -> Required -> ShowS)
-> (Required -> String) -> ([Required] -> ShowS) -> Show Required
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Required -> ShowS
showsPrec :: Int -> Required -> ShowS
$cshow :: Required -> String
show :: Required -> String
$cshowList :: [Required] -> ShowS
showList :: [Required] -> ShowS
Show, ReadPrec [Required]
ReadPrec Required
Int -> ReadS Required
ReadS [Required]
(Int -> ReadS Required)
-> ReadS [Required]
-> ReadPrec Required
-> ReadPrec [Required]
-> Read Required
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Required
readsPrec :: Int -> ReadS Required
$creadList :: ReadS [Required]
readList :: ReadS [Required]
$creadPrec :: ReadPrec Required
readPrec :: ReadPrec Required
$creadListPrec :: ReadPrec [Required]
readListPrec :: ReadPrec [Required]
Read, Required -> Required -> Bool
(Required -> Required -> Bool)
-> (Required -> Required -> Bool) -> Eq Required
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Required -> Required -> Bool
== :: Required -> Required -> Bool
$c/= :: Required -> Required -> Bool
/= :: Required -> Required -> Bool
Eq, Eq Required
Eq Required =>
(Required -> Required -> Ordering)
-> (Required -> Required -> Bool)
-> (Required -> Required -> Bool)
-> (Required -> Required -> Bool)
-> (Required -> Required -> Bool)
-> (Required -> Required -> Required)
-> (Required -> Required -> Required)
-> Ord Required
Required -> Required -> Bool
Required -> Required -> Ordering
Required -> Required -> Required
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
$ccompare :: Required -> Required -> Ordering
compare :: Required -> Required -> Ordering
$c< :: Required -> Required -> Bool
< :: Required -> Required -> Bool
$c<= :: Required -> Required -> Bool
<= :: Required -> Required -> Bool
$c> :: Required -> Required -> Bool
> :: Required -> Required -> Bool
$c>= :: Required -> Required -> Bool
>= :: Required -> Required -> Bool
$cmax :: Required -> Required -> Required
max :: Required -> Required -> Required
$cmin :: Required -> Required -> Required
min :: Required -> Required -> Required
Ord, Int -> Required
Required -> Int
Required -> [Required]
Required -> Required
Required -> Required -> [Required]
Required -> Required -> Required -> [Required]
(Required -> Required)
-> (Required -> Required)
-> (Int -> Required)
-> (Required -> Int)
-> (Required -> [Required])
-> (Required -> Required -> [Required])
-> (Required -> Required -> [Required])
-> (Required -> Required -> Required -> [Required])
-> Enum Required
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Required -> Required
succ :: Required -> Required
$cpred :: Required -> Required
pred :: Required -> Required
$ctoEnum :: Int -> Required
toEnum :: Int -> Required
$cfromEnum :: Required -> Int
fromEnum :: Required -> Int
$cenumFrom :: Required -> [Required]
enumFrom :: Required -> [Required]
$cenumFromThen :: Required -> Required -> [Required]
enumFromThen :: Required -> Required -> [Required]
$cenumFromTo :: Required -> Required -> [Required]
enumFromTo :: Required -> Required -> [Required]
$cenumFromThenTo :: Required -> Required -> Required -> [Required]
enumFromThenTo :: Required -> Required -> Required -> [Required]
Enum, Required
Required -> Required -> Bounded Required
forall a. a -> a -> Bounded a
$cminBound :: Required
minBound :: Required
$cmaxBound :: Required
maxBound :: Required
Bounded)

instance Boolish Required where
  is :: Required -> Bool
is = (Required -> Required -> Bool
forall a. Eq a => a -> a -> Bool
== Required
Required)

data Recursivity = NotRecursive | Recursive
  deriving (Int -> Recursivity -> ShowS
[Recursivity] -> ShowS
Recursivity -> String
(Int -> Recursivity -> ShowS)
-> (Recursivity -> String)
-> ([Recursivity] -> ShowS)
-> Show Recursivity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Recursivity -> ShowS
showsPrec :: Int -> Recursivity -> ShowS
$cshow :: Recursivity -> String
show :: Recursivity -> String
$cshowList :: [Recursivity] -> ShowS
showList :: [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
$creadsPrec :: Int -> ReadS Recursivity
readsPrec :: Int -> ReadS Recursivity
$creadList :: ReadS [Recursivity]
readList :: ReadS [Recursivity]
$creadPrec :: ReadPrec Recursivity
readPrec :: ReadPrec Recursivity
$creadListPrec :: ReadPrec [Recursivity]
readListPrec :: ReadPrec [Recursivity]
Read, Recursivity -> Recursivity -> Bool
(Recursivity -> Recursivity -> Bool)
-> (Recursivity -> Recursivity -> Bool) -> Eq Recursivity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Recursivity -> Recursivity -> Bool
== :: Recursivity -> Recursivity -> Bool
$c/= :: Recursivity -> Recursivity -> Bool
/= :: 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
$ccompare :: Recursivity -> Recursivity -> Ordering
compare :: Recursivity -> Recursivity -> Ordering
$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
>= :: Recursivity -> Recursivity -> Bool
$cmax :: Recursivity -> Recursivity -> Recursivity
max :: Recursivity -> Recursivity -> Recursivity
$cmin :: Recursivity -> Recursivity -> Recursivity
min :: Recursivity -> Recursivity -> 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
$csucc :: Recursivity -> Recursivity
succ :: Recursivity -> Recursivity
$cpred :: Recursivity -> Recursivity
pred :: Recursivity -> Recursivity
$ctoEnum :: Int -> Recursivity
toEnum :: Int -> Recursivity
$cfromEnum :: Recursivity -> Int
fromEnum :: Recursivity -> Int
$cenumFrom :: Recursivity -> [Recursivity]
enumFrom :: Recursivity -> [Recursivity]
$cenumFromThen :: Recursivity -> Recursivity -> [Recursivity]
enumFromThen :: Recursivity -> Recursivity -> [Recursivity]
$cenumFromTo :: Recursivity -> Recursivity -> [Recursivity]
enumFromTo :: Recursivity -> Recursivity -> [Recursivity]
$cenumFromThenTo :: Recursivity -> Recursivity -> Recursivity -> [Recursivity]
enumFromThenTo :: Recursivity -> Recursivity -> Recursivity -> [Recursivity]
Enum, Recursivity
Recursivity -> Recursivity -> Bounded Recursivity
forall a. a -> a -> Bounded a
$cminBound :: Recursivity
minBound :: Recursivity
$cmaxBound :: Recursivity
maxBound :: Recursivity
Bounded)

instance Boolish Recursivity where
  is :: Recursivity -> Bool
is = (Recursivity -> Recursivity -> Bool
forall a. Eq a => a -> a -> Bool
== Recursivity
Recursive)

instance Arbitrary Scoped where
  arbitrary :: Gen Scoped
arbitrary = [Gen Scoped] -> Gen Scoped
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof ([Gen Scoped] -> Gen Scoped) -> [Gen Scoped] -> Gen Scoped
forall a b. (a -> b) -> a -> b
$ (Scoped -> Gen Scoped) -> [Scoped] -> [Gen Scoped]
forall a b. (a -> b) -> [a] -> [b]
map Scoped -> Gen Scoped
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Scoped
forall a. Bounded a => a
minBound..Scoped
forall a. Bounded a => a
maxBound]

instance Arbitrary Required where
  arbitrary :: Gen Required
arbitrary = [Gen Required] -> Gen Required
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof ([Gen Required] -> Gen Required) -> [Gen Required] -> Gen Required
forall a b. (a -> b) -> a -> b
$ (Required -> Gen Required) -> [Required] -> [Gen Required]
forall a b. (a -> b) -> [a] -> [b]
map Required -> Gen Required
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Required
forall a. Bounded a => a
minBound..Required
forall a. Bounded a => a
maxBound]

instance Arbitrary Recursivity where
  arbitrary :: Gen Recursivity
arbitrary = [Gen Recursivity] -> Gen Recursivity
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof ([Gen Recursivity] -> Gen Recursivity)
-> [Gen Recursivity] -> Gen Recursivity
forall a b. (a -> b) -> a -> b
$ (Recursivity -> Gen Recursivity)
-> [Recursivity] -> [Gen Recursivity]
forall a b. (a -> b) -> [a] -> [b]
map Recursivity -> Gen Recursivity
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Recursivity
forall a. Bounded a => a
minBound..Recursivity
forall a. Bounded a => a
maxBound]

type MacroArg = (Identifier, Maybe Expr)

-- | An expression. Expressions can occur in interpolations (@{{ ... }}@), and
-- in various places inside statements.
data Expr
  = PositionedE !SourcePosition !Expr
  | NoneE
  | BoolE !Bool
  | StringLitE !Text
  | IntLitE !Integer
  | FloatLitE !Double
  | StatementE !Statement
  | ListE !(Vector Expr)
  | DictE ![(Expr, Expr)]
    -- | @UnaryE op rhs
  | UnaryE !UnaryOperator !Expr
    -- | @BinaryE op lhs rhs
  | BinaryE !BinaryOperator !Expr !Expr
    -- | @SliceE slicee start length
  | SliceE !Expr !(Maybe Expr) !(Maybe Expr)
    -- | @DotE lhs rhs
  | DotE !Expr !Identifier
    -- | @IsE scrutinee test args kwargs@
  | IsE !Expr !Expr ![Expr] ![(Identifier, Expr)]
    -- | @CallE callee args kwargs@
  | CallE !Expr ![Expr] ![(Identifier, Expr)]
    -- | @FilterE arg0 filter args kwargs@
  | FilterE !Expr !Expr ![Expr] ![(Identifier, Expr)]
    -- | @TernaryE cond yes no@
  | TernaryE !Expr !Expr !Expr
  | VarE !Identifier
  deriving (Int -> Expr -> ShowS
[Expr] -> ShowS
Expr -> String
(Int -> Expr -> ShowS)
-> (Expr -> String) -> ([Expr] -> ShowS) -> Show Expr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Expr -> ShowS
showsPrec :: Int -> Expr -> ShowS
$cshow :: Expr -> String
show :: Expr -> String
$cshowList :: [Expr] -> ShowS
showList :: [Expr] -> ShowS
Show, Expr -> Expr -> Bool
(Expr -> Expr -> Bool) -> (Expr -> Expr -> Bool) -> Eq Expr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Expr -> Expr -> Bool
== :: Expr -> Expr -> Bool
$c/= :: Expr -> Expr -> Bool
/= :: Expr -> Expr -> Bool
Eq, Eq Expr
Eq Expr =>
(Expr -> Expr -> Ordering)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Expr)
-> (Expr -> Expr -> Expr)
-> Ord Expr
Expr -> Expr -> Bool
Expr -> Expr -> Ordering
Expr -> Expr -> Expr
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
$ccompare :: Expr -> Expr -> Ordering
compare :: Expr -> Expr -> Ordering
$c< :: Expr -> Expr -> Bool
< :: Expr -> Expr -> Bool
$c<= :: Expr -> Expr -> Bool
<= :: Expr -> Expr -> Bool
$c> :: Expr -> Expr -> Bool
> :: Expr -> Expr -> Bool
$c>= :: Expr -> Expr -> Bool
>= :: Expr -> Expr -> Bool
$cmax :: Expr -> Expr -> Expr
max :: Expr -> Expr -> Expr
$cmin :: Expr -> Expr -> Expr
min :: Expr -> Expr -> Expr
Ord)

pattern TrueE :: Expr
pattern $mTrueE :: forall {r}. Expr -> ((# #) -> r) -> ((# #) -> r) -> r
$bTrueE :: Expr
TrueE = BoolE True

pattern FalseE :: Expr
pattern $mFalseE :: forall {r}. Expr -> ((# #) -> r) -> ((# #) -> r) -> r
$bFalseE :: Expr
FalseE = BoolE False

instance Arbitrary Expr where
  arbitrary :: Gen Expr
arbitrary = Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
forall a. Monoid a => a
mempty
  shrink :: Expr -> [Expr]
shrink (PositionedE SourcePosition
pos Expr
e) =
    SourcePosition -> Expr -> Expr
PositionedE SourcePosition
pos (Expr -> Expr) -> [Expr] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
e [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    [Expr
e]
  shrink (StringLitE Text
txt) = (String -> Expr) -> [String] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (Text -> Expr
StringLitE (Text -> Expr) -> (String -> Text) -> String -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack) ([String] -> [Expr]) -> [String] -> [Expr]
forall a b. (a -> b) -> a -> b
$ String -> [String]
forall a. Arbitrary a => a -> [a]
shrink (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ Text -> String
Text.unpack Text
txt
  shrink (IntLitE Integer
i) = Integer -> Expr
IntLitE (Integer -> Expr) -> [Integer] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Integer -> [Integer]
forall a. Arbitrary a => a -> [a]
shrink Integer
i
  shrink (FloatLitE Double
i) = Double -> Expr
FloatLitE (Double -> Expr) -> [Double] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> [Double]
forall a. Arbitrary a => a -> [a]
shrink Double
i
  shrink (StatementE Statement
s) = Statement -> Expr
StatementE (Statement -> Expr) -> [Statement] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Statement -> [Statement]
forall a. Arbitrary a => a -> [a]
shrink Statement
s
  shrink (ListE Vector Expr
v) =
    case Vector Expr -> Maybe (Expr, Vector Expr)
forall a. Vector a -> Maybe (a, Vector a)
V.uncons Vector Expr
v of
      Maybe (Expr, Vector Expr)
Nothing -> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
NoneE
      Just (Expr
x, Vector Expr
xs) | Vector Expr -> Bool
forall a. Vector a -> Bool
V.null Vector Expr
xs ->
        (Vector Expr -> Expr
ListE (Vector Expr -> Expr) -> (Expr -> Vector Expr) -> Expr -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr -> Vector Expr
forall a. a -> Vector a
V.singleton (Expr -> Expr) -> [Expr] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
x) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [Expr
x]
      Maybe (Expr, Vector Expr)
_ ->
        Vector Expr -> Expr
ListE (Vector Expr -> Expr) -> ([Expr] -> Vector Expr) -> [Expr] -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Expr] -> Vector Expr
forall a. [a] -> Vector a
V.fromList ([Expr] -> Expr) -> [[Expr]] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Expr] -> [[Expr]]
forall a. Arbitrary a => a -> [a]
shrink (Vector Expr -> [Expr]
forall a. Vector a -> [a]
V.toList Vector Expr
v)
  shrink (DictE [(Expr, Expr)]
xs) = [(Expr, Expr)] -> Expr
DictE ([(Expr, Expr)] -> Expr) -> [[(Expr, Expr)]] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Expr, Expr)] -> [[(Expr, Expr)]]
forall a. Arbitrary a => a -> [a]
shrink [(Expr, Expr)]
xs
  shrink (UnaryE UnaryOperator
op Expr
e) =
    (UnaryOperator -> Expr -> Expr
UnaryE (UnaryOperator -> Expr -> Expr)
-> [UnaryOperator] -> [Expr -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> UnaryOperator -> [UnaryOperator]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure UnaryOperator
op [Expr -> Expr] -> [Expr] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
e) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    [Expr
e]
  shrink (DotE Expr
a Identifier
b) =
    (Expr -> Identifier -> Expr
DotE (Expr -> Identifier -> Expr) -> [Expr] -> [Identifier -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Identifier -> Expr] -> [Identifier] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Identifier -> [Identifier]
forall a. Arbitrary a => a -> [a]
shrink Identifier
b) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Identifier -> Expr
DotE (Expr -> Identifier -> Expr) -> [Expr] -> [Identifier -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
a [Identifier -> Expr] -> [Identifier] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Identifier -> [Identifier]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Identifier
b) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    [Expr
a]
  shrink (BinaryE BinaryOperator
op Expr
a Expr
b) =
    (BinaryOperator -> Expr -> Expr -> Expr
BinaryE (BinaryOperator -> Expr -> Expr -> Expr)
-> [BinaryOperator] -> [Expr -> Expr -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> BinaryOperator -> [BinaryOperator]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure BinaryOperator
op [Expr -> Expr -> Expr] -> [Expr] -> [Expr -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
a [Expr -> Expr] -> [Expr] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
b) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (BinaryOperator -> Expr -> Expr -> Expr
BinaryE (BinaryOperator -> Expr -> Expr -> Expr)
-> [BinaryOperator] -> [Expr -> Expr -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> BinaryOperator -> [BinaryOperator]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure BinaryOperator
op [Expr -> Expr -> Expr] -> [Expr] -> [Expr -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Expr -> Expr] -> [Expr] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
b) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    [Expr
a, Expr
b]
  shrink (SliceE Expr
slicee Maybe Expr
startMay Maybe Expr
endMay) =
    (Expr -> Maybe Expr -> Maybe Expr -> Expr
SliceE (Expr -> Maybe Expr -> Maybe Expr -> Expr)
-> [Expr] -> [Maybe Expr -> Maybe Expr -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
slicee [Maybe Expr -> Maybe Expr -> Expr]
-> [Maybe Expr] -> [Maybe Expr -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
startMay [Maybe Expr -> Expr] -> [Maybe Expr] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. Arbitrary a => a -> [a]
shrink Maybe Expr
endMay) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ 
    (Expr -> Maybe Expr -> Maybe Expr -> Expr
SliceE (Expr -> Maybe Expr -> Maybe Expr -> Expr)
-> [Expr] -> [Maybe Expr -> Maybe Expr -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
slicee [Maybe Expr -> Maybe Expr -> Expr]
-> [Maybe Expr] -> [Maybe Expr -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. Arbitrary a => a -> [a]
shrink Maybe Expr
startMay [Maybe Expr -> Expr] -> [Maybe Expr] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
endMay) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ 
    (Expr -> Maybe Expr -> Maybe Expr -> Expr
SliceE (Expr -> Maybe Expr -> Maybe Expr -> Expr)
-> [Expr] -> [Maybe Expr -> Maybe Expr -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
slicee [Maybe Expr -> Maybe Expr -> Expr]
-> [Maybe Expr] -> [Maybe Expr -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
startMay [Maybe Expr -> Expr] -> [Maybe Expr] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Expr -> [Maybe Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Expr
endMay) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ 
    Maybe Expr -> [Expr]
forall a. Maybe a -> [a]
maybeToList Maybe Expr
startMay [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    Maybe Expr -> [Expr]
forall a. Maybe a -> [a]
maybeToList Maybe Expr
endMay [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    [Expr
slicee]
  shrink (IsE Expr
a Expr
b [Expr]
args [(Identifier, Expr)]
kwargs) =
    (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
IsE (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
b [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. Arbitrary a => a -> [a]
shrink [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
IsE (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
b [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. Arbitrary a => a -> [a]
shrink [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
IsE (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
b [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
IsE (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
a [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
b [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    [Expr
a, Expr
b] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [Expr]
args [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ ((Identifier, Expr) -> Expr) -> [(Identifier, Expr)] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (Identifier, Expr) -> Expr
forall a b. (a, b) -> b
snd [(Identifier, Expr)]
kwargs
  shrink (CallE Expr
f [Expr]
args [(Identifier, Expr)]
kwargs) =
    (Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
CallE (Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
f [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. Arbitrary a => a -> [a]
shrink [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
CallE (Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
f [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. Arbitrary a => a -> [a]
shrink [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
CallE (Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
f [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    [Expr
f] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [Expr]
args [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ ((Identifier, Expr) -> Expr) -> [(Identifier, Expr)] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (Identifier, Expr) -> Expr
forall a b. (a, b) -> b
snd [(Identifier, Expr)]
kwargs
  shrink (FilterE Expr
a Expr
f [Expr]
args [(Identifier, Expr)]
kwargs) =
    (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
FilterE (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
f [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. Arbitrary a => a -> [a]
shrink [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
FilterE (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
f [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. Arbitrary a => a -> [a]
shrink [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
FilterE (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
f [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
FilterE (Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> [Expr] -> [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
a [Expr -> [Expr] -> [(Identifier, Expr)] -> Expr]
-> [Expr] -> [[Expr] -> [(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
f [[Expr] -> [(Identifier, Expr)] -> Expr]
-> [[Expr]] -> [[(Identifier, Expr)] -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Expr] -> [[Expr]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Expr]
args [[(Identifier, Expr)] -> Expr] -> [[(Identifier, Expr)]] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Identifier, Expr)] -> [[(Identifier, Expr)]]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [(Identifier, Expr)]
kwargs) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    [Expr
a, Expr
f] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [Expr]
args [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ ((Identifier, Expr) -> Expr) -> [(Identifier, Expr)] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (Identifier, Expr) -> Expr
forall a b. (a, b) -> b
snd [(Identifier, Expr)]
kwargs
  shrink (TernaryE Expr
a Expr
b Expr
c) =
    (Expr -> Expr -> Expr -> Expr
TernaryE (Expr -> Expr -> Expr -> Expr) -> [Expr] -> [Expr -> Expr -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Expr -> Expr -> Expr] -> [Expr] -> [Expr -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
b [Expr -> Expr] -> [Expr] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
c) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Expr -> Expr -> Expr
TernaryE (Expr -> Expr -> Expr -> Expr) -> [Expr] -> [Expr -> Expr -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
a [Expr -> Expr -> Expr] -> [Expr] -> [Expr -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
b [Expr -> Expr] -> [Expr] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
c) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    (Expr -> Expr -> Expr -> Expr
TernaryE (Expr -> Expr -> Expr -> Expr) -> [Expr] -> [Expr -> Expr -> Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> [Expr]
forall a. Arbitrary a => a -> [a]
shrink Expr
a [Expr -> Expr -> Expr] -> [Expr] -> [Expr -> Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
b [Expr -> Expr] -> [Expr] -> [Expr]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Expr -> [Expr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
c) [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++
    [Expr
a, Expr
b, Expr
c]
  shrink Expr
_ = []

arbitraryExpr :: Set Identifier -> QC.Gen Expr
arbitraryExpr :: Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined = do
  Int
fuel <- Gen Int
QC.getSize
  if Int
fuel Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
1 then
    Expr -> Gen Expr
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
NoneE
  else do
    let baseOptions :: [(Int, Gen Expr)]
baseOptions =
          [ (Int
10, Expr -> Gen Expr
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Expr
NoneE)
          , (Int
100, Bool -> Expr
BoolE (Bool -> Expr) -> Gen Bool -> Gen Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Bool
forall a. Arbitrary a => Gen a
arbitrary)
          , (Int
100, Text -> Expr
StringLitE (Text -> Expr) -> Gen Text -> Gen Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen Text -> Gen Text
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (String -> Text
Text.pack (String -> Text) -> Gen String -> Gen Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Char -> Gen String
forall a. Gen a -> Gen [a]
QC.listOf Gen Char
forall a. Arbitrary a => Gen a
arbitrary))
          , (Int
100, Integer -> Expr
IntLitE (Integer -> Expr) -> Gen Integer -> Gen Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen Integer -> Gen Integer
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Gen Integer
forall a. Arbitrary a => Gen a
arbitrary)
          , (Int
100, Double -> Expr
FloatLitE (Double -> Expr) -> Gen Double -> Gen Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen Double -> Gen Double
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Gen Double
forall a. Arbitrary a => Gen a
arbitrary)
          , (Int
100, Vector Expr -> Expr
ListE (Vector Expr -> Expr) -> ([Expr] -> Vector Expr) -> [Expr] -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Expr] -> Vector Expr
forall a. [a] -> Vector a
V.fromList ([Expr] -> Expr) -> Gen [Expr] -> Gen Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Expr -> Gen [Expr]
forall a. Gen a -> Gen [a]
fuelledList (Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined))
          , (Int
100, [(Expr, Expr)] -> Expr
DictE ([(Expr, Expr)] -> Expr) -> Gen [(Expr, Expr)] -> Gen Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Expr, Expr) -> Gen [(Expr, Expr)]
forall a. Gen a -> Gen [a]
fuelledList ((,) (Expr -> Expr -> (Expr, Expr))
-> Gen Expr -> Gen (Expr -> (Expr, Expr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined Gen (Expr -> (Expr, Expr)) -> Gen Expr -> Gen (Expr, Expr)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined))
          , (Int
90, Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (Gen Expr -> Gen Expr) -> Gen Expr -> Gen Expr
forall a b. (a -> b) -> a -> b
$
              BinaryOperator -> Expr -> Expr -> Expr
BinaryE (BinaryOperator -> Expr -> Expr -> Expr)
-> Gen BinaryOperator -> Gen (Expr -> Expr -> Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen BinaryOperator
forall a. Arbitrary a => Gen a
arbitrary
                      Gen (Expr -> Expr -> Expr) -> Gen Expr -> Gen (Expr -> Expr)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
                      Gen (Expr -> Expr) -> Gen Expr -> Gen Expr
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
            )

          , (Int
10, Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (Gen Expr -> Gen Expr) -> Gen Expr -> Gen Expr
forall a b. (a -> b) -> a -> b
$
              Expr -> Maybe Expr -> Maybe Expr -> Expr
SliceE (Expr -> Maybe Expr -> Maybe Expr -> Expr)
-> Gen Expr -> Gen (Maybe Expr -> Maybe Expr -> Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
                     Gen (Maybe Expr -> Maybe Expr -> Expr)
-> Gen (Maybe Expr) -> Gen (Maybe Expr -> Expr)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Integer -> Expr) -> Maybe Integer -> Maybe Expr
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> Expr
IntLitE (Maybe Integer -> Maybe Expr)
-> Gen (Maybe Integer) -> Gen (Maybe Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Integer)
forall a. Arbitrary a => Gen a
arbitrary)
                     Gen (Maybe Expr -> Expr) -> Gen (Maybe Expr) -> Gen Expr
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Integer -> Expr) -> Maybe Integer -> Maybe Expr
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> Expr
IntLitE (Maybe Integer -> Maybe Expr)
-> Gen (Maybe Integer) -> Gen (Maybe Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Integer)
forall a. Arbitrary a => Gen a
arbitrary)
            )
          , (Int
10, Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (Gen Expr -> Gen Expr) -> Gen Expr -> Gen Expr
forall a b. (a -> b) -> a -> b
$
              Expr -> Identifier -> Expr
DotE (Expr -> Identifier -> Expr)
-> Gen Expr -> Gen (Identifier -> Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
                   Gen (Identifier -> Expr) -> Gen Identifier -> Gen Expr
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary
            )

          , (Int
100, Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
3) (Gen Expr -> Gen Expr) -> Gen Expr -> Gen Expr
forall a b. (a -> b) -> a -> b
$
              Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
CallE (Expr -> [Expr] -> [(Identifier, Expr)] -> Expr)
-> Gen Expr -> Gen ([Expr] -> [(Identifier, Expr)] -> Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
                    Gen ([Expr] -> [(Identifier, Expr)] -> Expr)
-> Gen [Expr] -> Gen ([(Identifier, Expr)] -> Expr)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Expr -> Gen [Expr]
forall a. Gen a -> Gen [a]
fuelledList (Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined)
                    Gen ([(Identifier, Expr)] -> Expr)
-> Gen [(Identifier, Expr)] -> Gen Expr
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Identifier, Expr) -> Gen [(Identifier, Expr)]
forall a. Gen a -> Gen [a]
fuelledList ((,) (Identifier -> Expr -> (Identifier, Expr))
-> Gen Identifier -> Gen (Expr -> (Identifier, Expr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary Gen (Expr -> (Identifier, Expr))
-> Gen Expr -> Gen (Identifier, Expr)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined)
            )

          , (Int
100, Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
3) (Gen Expr -> Gen Expr) -> Gen Expr -> Gen Expr
forall a b. (a -> b) -> a -> b
$
              Expr -> Expr -> Expr -> Expr
TernaryE (Expr -> Expr -> Expr -> Expr)
-> Gen Expr -> Gen (Expr -> Expr -> Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
                       Gen (Expr -> Expr -> Expr) -> Gen Expr -> Gen (Expr -> Expr)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
                       Gen (Expr -> Expr) -> Gen Expr -> Gen Expr
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Identifier -> Gen Expr
arbitraryExpr Set Identifier
defined
            )

          , (Int
10, Int -> Gen Expr -> Gen Expr
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int
fuel Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (Gen Expr -> Gen Expr) -> Gen Expr -> Gen Expr
forall a b. (a -> b) -> a -> b
$
              Identifier -> Expr
VarE (Identifier -> Expr) -> Gen Identifier -> Gen Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Identifier
forall a. Arbitrary a => Gen a
arbitrary
            )
          ]
        extraOptions :: [(Int, Gen Expr)]
extraOptions =
          if Set Identifier -> Bool
forall a. Set a -> Bool
Set.null Set Identifier
defined then
            []
          else
            [ (Int
100, Identifier -> Expr
VarE (Identifier -> Expr) -> Gen Identifier -> Gen Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Gen Identifier] -> Gen Identifier
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof ((Identifier -> Gen Identifier) -> [Identifier] -> [Gen Identifier]
forall a b. (a -> b) -> [a] -> [b]
map Identifier -> Gen Identifier
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Identifier] -> [Gen Identifier])
-> [Identifier] -> [Gen Identifier]
forall a b. (a -> b) -> a -> b
$ Set Identifier -> [Identifier]
forall a. Set a -> [a]
Set.toList Set Identifier
defined))
            ]
        options :: [(Int, Gen Expr)]
options = [(Int, Gen Expr)]
baseOptions [(Int, Gen Expr)] -> [(Int, Gen Expr)] -> [(Int, Gen Expr)]
forall a. Semigroup a => a -> a -> a
<> [(Int, Gen Expr)]
extraOptions
    [(Int, Gen Expr)] -> Gen Expr
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
QC.frequency [(Int, Gen Expr)]
options

data UnaryOperator
  = UnopNot
  | UnopNegate
  deriving (Int -> UnaryOperator -> ShowS
[UnaryOperator] -> ShowS
UnaryOperator -> String
(Int -> UnaryOperator -> ShowS)
-> (UnaryOperator -> String)
-> ([UnaryOperator] -> ShowS)
-> Show UnaryOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnaryOperator -> ShowS
showsPrec :: Int -> UnaryOperator -> ShowS
$cshow :: UnaryOperator -> String
show :: UnaryOperator -> String
$cshowList :: [UnaryOperator] -> ShowS
showList :: [UnaryOperator] -> ShowS
Show, UnaryOperator -> UnaryOperator -> Bool
(UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> Bool) -> Eq UnaryOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnaryOperator -> UnaryOperator -> Bool
== :: UnaryOperator -> UnaryOperator -> Bool
$c/= :: UnaryOperator -> UnaryOperator -> Bool
/= :: UnaryOperator -> UnaryOperator -> Bool
Eq, Int -> UnaryOperator
UnaryOperator -> Int
UnaryOperator -> [UnaryOperator]
UnaryOperator -> UnaryOperator
UnaryOperator -> UnaryOperator -> [UnaryOperator]
UnaryOperator -> UnaryOperator -> UnaryOperator -> [UnaryOperator]
(UnaryOperator -> UnaryOperator)
-> (UnaryOperator -> UnaryOperator)
-> (Int -> UnaryOperator)
-> (UnaryOperator -> Int)
-> (UnaryOperator -> [UnaryOperator])
-> (UnaryOperator -> UnaryOperator -> [UnaryOperator])
-> (UnaryOperator -> UnaryOperator -> [UnaryOperator])
-> (UnaryOperator
    -> UnaryOperator -> UnaryOperator -> [UnaryOperator])
-> Enum UnaryOperator
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: UnaryOperator -> UnaryOperator
succ :: UnaryOperator -> UnaryOperator
$cpred :: UnaryOperator -> UnaryOperator
pred :: UnaryOperator -> UnaryOperator
$ctoEnum :: Int -> UnaryOperator
toEnum :: Int -> UnaryOperator
$cfromEnum :: UnaryOperator -> Int
fromEnum :: UnaryOperator -> Int
$cenumFrom :: UnaryOperator -> [UnaryOperator]
enumFrom :: UnaryOperator -> [UnaryOperator]
$cenumFromThen :: UnaryOperator -> UnaryOperator -> [UnaryOperator]
enumFromThen :: UnaryOperator -> UnaryOperator -> [UnaryOperator]
$cenumFromTo :: UnaryOperator -> UnaryOperator -> [UnaryOperator]
enumFromTo :: UnaryOperator -> UnaryOperator -> [UnaryOperator]
$cenumFromThenTo :: UnaryOperator -> UnaryOperator -> UnaryOperator -> [UnaryOperator]
enumFromThenTo :: UnaryOperator -> UnaryOperator -> UnaryOperator -> [UnaryOperator]
Enum, Eq UnaryOperator
Eq UnaryOperator =>
(UnaryOperator -> UnaryOperator -> Ordering)
-> (UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> UnaryOperator)
-> (UnaryOperator -> UnaryOperator -> UnaryOperator)
-> Ord UnaryOperator
UnaryOperator -> UnaryOperator -> Bool
UnaryOperator -> UnaryOperator -> Ordering
UnaryOperator -> UnaryOperator -> UnaryOperator
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
$ccompare :: UnaryOperator -> UnaryOperator -> Ordering
compare :: UnaryOperator -> UnaryOperator -> Ordering
$c< :: UnaryOperator -> UnaryOperator -> Bool
< :: UnaryOperator -> UnaryOperator -> Bool
$c<= :: UnaryOperator -> UnaryOperator -> Bool
<= :: UnaryOperator -> UnaryOperator -> Bool
$c> :: UnaryOperator -> UnaryOperator -> Bool
> :: UnaryOperator -> UnaryOperator -> Bool
$c>= :: UnaryOperator -> UnaryOperator -> Bool
>= :: UnaryOperator -> UnaryOperator -> Bool
$cmax :: UnaryOperator -> UnaryOperator -> UnaryOperator
max :: UnaryOperator -> UnaryOperator -> UnaryOperator
$cmin :: UnaryOperator -> UnaryOperator -> UnaryOperator
min :: UnaryOperator -> UnaryOperator -> UnaryOperator
Ord, UnaryOperator
UnaryOperator -> UnaryOperator -> Bounded UnaryOperator
forall a. a -> a -> Bounded a
$cminBound :: UnaryOperator
minBound :: UnaryOperator
$cmaxBound :: UnaryOperator
maxBound :: UnaryOperator
Bounded)

pattern NotE :: Expr -> Expr
pattern $mNotE :: forall {r}. Expr -> (Expr -> r) -> ((# #) -> r) -> r
$bNotE :: Expr -> Expr
NotE a = UnaryE UnopNot a

pattern NegateE :: Expr -> Expr
pattern $mNegateE :: forall {r}. Expr -> (Expr -> r) -> ((# #) -> r) -> r
$bNegateE :: Expr -> Expr
NegateE a = UnaryE UnopNegate a

data BinaryOperator
    -- Math
  = BinopPlus
  | BinopMinus
  | BinopDiv
  | BinopIntDiv
  | BinopMod
  | BinopMul
  | BinopPower
    -- Comparison
  | BinopEqual
  | BinopNotEqual
  | BinopGT
  | BinopGTE
  | BinopLT
  | BinopLTE
    -- Boolean
  | BinopAnd
  | BinopOr

    -- List / dict membership
  | BinopIn
    -- List / dict indexing (@[]@)
  | BinopIndex
    -- String concatenation
  | BinopConcat
    -- Test
  deriving (Int -> BinaryOperator -> ShowS
[BinaryOperator] -> ShowS
BinaryOperator -> String
(Int -> BinaryOperator -> ShowS)
-> (BinaryOperator -> String)
-> ([BinaryOperator] -> ShowS)
-> Show BinaryOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BinaryOperator -> ShowS
showsPrec :: Int -> BinaryOperator -> ShowS
$cshow :: BinaryOperator -> String
show :: BinaryOperator -> String
$cshowList :: [BinaryOperator] -> ShowS
showList :: [BinaryOperator] -> ShowS
Show, BinaryOperator -> BinaryOperator -> Bool
(BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> Bool) -> Eq BinaryOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryOperator -> BinaryOperator -> Bool
== :: BinaryOperator -> BinaryOperator -> Bool
$c/= :: BinaryOperator -> BinaryOperator -> Bool
/= :: BinaryOperator -> BinaryOperator -> Bool
Eq, Int -> BinaryOperator
BinaryOperator -> Int
BinaryOperator -> [BinaryOperator]
BinaryOperator -> BinaryOperator
BinaryOperator -> BinaryOperator -> [BinaryOperator]
BinaryOperator
-> BinaryOperator -> BinaryOperator -> [BinaryOperator]
(BinaryOperator -> BinaryOperator)
-> (BinaryOperator -> BinaryOperator)
-> (Int -> BinaryOperator)
-> (BinaryOperator -> Int)
-> (BinaryOperator -> [BinaryOperator])
-> (BinaryOperator -> BinaryOperator -> [BinaryOperator])
-> (BinaryOperator -> BinaryOperator -> [BinaryOperator])
-> (BinaryOperator
    -> BinaryOperator -> BinaryOperator -> [BinaryOperator])
-> Enum BinaryOperator
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: BinaryOperator -> BinaryOperator
succ :: BinaryOperator -> BinaryOperator
$cpred :: BinaryOperator -> BinaryOperator
pred :: BinaryOperator -> BinaryOperator
$ctoEnum :: Int -> BinaryOperator
toEnum :: Int -> BinaryOperator
$cfromEnum :: BinaryOperator -> Int
fromEnum :: BinaryOperator -> Int
$cenumFrom :: BinaryOperator -> [BinaryOperator]
enumFrom :: BinaryOperator -> [BinaryOperator]
$cenumFromThen :: BinaryOperator -> BinaryOperator -> [BinaryOperator]
enumFromThen :: BinaryOperator -> BinaryOperator -> [BinaryOperator]
$cenumFromTo :: BinaryOperator -> BinaryOperator -> [BinaryOperator]
enumFromTo :: BinaryOperator -> BinaryOperator -> [BinaryOperator]
$cenumFromThenTo :: BinaryOperator
-> BinaryOperator -> BinaryOperator -> [BinaryOperator]
enumFromThenTo :: BinaryOperator
-> BinaryOperator -> BinaryOperator -> [BinaryOperator]
Enum, Eq BinaryOperator
Eq BinaryOperator =>
(BinaryOperator -> BinaryOperator -> Ordering)
-> (BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> BinaryOperator)
-> (BinaryOperator -> BinaryOperator -> BinaryOperator)
-> Ord BinaryOperator
BinaryOperator -> BinaryOperator -> Bool
BinaryOperator -> BinaryOperator -> Ordering
BinaryOperator -> BinaryOperator -> BinaryOperator
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
$ccompare :: BinaryOperator -> BinaryOperator -> Ordering
compare :: BinaryOperator -> BinaryOperator -> Ordering
$c< :: BinaryOperator -> BinaryOperator -> Bool
< :: BinaryOperator -> BinaryOperator -> Bool
$c<= :: BinaryOperator -> BinaryOperator -> Bool
<= :: BinaryOperator -> BinaryOperator -> Bool
$c> :: BinaryOperator -> BinaryOperator -> Bool
> :: BinaryOperator -> BinaryOperator -> Bool
$c>= :: BinaryOperator -> BinaryOperator -> Bool
>= :: BinaryOperator -> BinaryOperator -> Bool
$cmax :: BinaryOperator -> BinaryOperator -> BinaryOperator
max :: BinaryOperator -> BinaryOperator -> BinaryOperator
$cmin :: BinaryOperator -> BinaryOperator -> BinaryOperator
min :: BinaryOperator -> BinaryOperator -> BinaryOperator
Ord, BinaryOperator
BinaryOperator -> BinaryOperator -> Bounded BinaryOperator
forall a. a -> a -> Bounded a
$cminBound :: BinaryOperator
minBound :: BinaryOperator
$cmaxBound :: BinaryOperator
maxBound :: BinaryOperator
Bounded)

pattern PlusE :: Expr -> Expr -> Expr
pattern $mPlusE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bPlusE :: Expr -> Expr -> Expr
PlusE a b = BinaryE BinopPlus a b

pattern MinusE :: Expr -> Expr -> Expr
pattern $mMinusE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bMinusE :: Expr -> Expr -> Expr
MinusE a b = BinaryE BinopMinus a b

pattern DivE :: Expr -> Expr -> Expr
pattern $mDivE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bDivE :: Expr -> Expr -> Expr
DivE a b = BinaryE BinopDiv a b

pattern IntDivE :: Expr -> Expr -> Expr
pattern $mIntDivE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bIntDivE :: Expr -> Expr -> Expr
IntDivE a b = BinaryE BinopIntDiv a b

pattern ModE :: Expr -> Expr -> Expr
pattern $mModE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bModE :: Expr -> Expr -> Expr
ModE a b = BinaryE BinopMod a b

pattern MulE :: Expr -> Expr -> Expr
pattern $mMulE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bMulE :: Expr -> Expr -> Expr
MulE a b = BinaryE BinopMul a b

pattern PowerE :: Expr -> Expr -> Expr
pattern $mPowerE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bPowerE :: Expr -> Expr -> Expr
PowerE a b = BinaryE BinopPower a b

pattern EqualE :: Expr -> Expr -> Expr
pattern $mEqualE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bEqualE :: Expr -> Expr -> Expr
EqualE a b = BinaryE BinopEqual a b

pattern NotEqualE :: Expr -> Expr -> Expr
pattern $mNotEqualE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bNotEqualE :: Expr -> Expr -> Expr
NotEqualE a b = BinaryE BinopNotEqual a b

pattern GT_E :: Expr -> Expr -> Expr
pattern $mGT_E :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bGT_E :: Expr -> Expr -> Expr
GT_E a b = BinaryE BinopGT a b

pattern GTE_E :: Expr -> Expr -> Expr
pattern $mGTE_E :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bGTE_E :: Expr -> Expr -> Expr
GTE_E a b = BinaryE BinopGTE a b

pattern LT_E :: Expr -> Expr -> Expr
pattern $mLT_E :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bLT_E :: Expr -> Expr -> Expr
LT_E a b = BinaryE BinopLT a b

pattern LTE_E :: Expr -> Expr -> Expr
pattern $mLTE_E :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bLTE_E :: Expr -> Expr -> Expr
LTE_E a b = BinaryE BinopLTE a b

pattern AndE :: Expr -> Expr -> Expr
pattern $mAndE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bAndE :: Expr -> Expr -> Expr
AndE a b = BinaryE BinopAnd a b

pattern OrE :: Expr -> Expr -> Expr
pattern $mOrE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bOrE :: Expr -> Expr -> Expr
OrE a b = BinaryE BinopOr a b

pattern InE :: Expr -> Expr -> Expr
pattern $mInE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bInE :: Expr -> Expr -> Expr
InE a b = BinaryE BinopIn a b

pattern IndexE :: Expr -> Expr -> Expr
pattern $mIndexE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bIndexE :: Expr -> Expr -> Expr
IndexE a b = BinaryE BinopIndex a b

pattern ConcatE :: Expr -> Expr -> Expr
pattern $mConcatE :: forall {r}. Expr -> (Expr -> Expr -> r) -> ((# #) -> r) -> r
$bConcatE :: Expr -> Expr -> Expr
ConcatE a b = BinaryE BinopConcat a b

instance Arbitrary BinaryOperator where
  arbitrary :: Gen BinaryOperator
arbitrary = [Gen BinaryOperator] -> Gen BinaryOperator
forall a. HasCallStack => [Gen a] -> Gen a
QC.oneof ((BinaryOperator -> Gen BinaryOperator)
-> [BinaryOperator] -> [Gen BinaryOperator]
forall a b. (a -> b) -> [a] -> [b]
map BinaryOperator -> Gen BinaryOperator
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [BinaryOperator
forall a. Bounded a => a
minBound .. BinaryOperator
forall a. Bounded a => a
maxBound])

fuelledList :: QC.Gen a -> QC.Gen [a]
fuelledList :: forall a. Gen a -> Gen [a]
fuelledList Gen a
subGen = do
  Int
fuel <- Gen Int
QC.getSize
  if Int
fuel Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1 then
    [a] -> Gen [a]
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
  else do
    Int
s <- (Int, Int) -> Gen Int
QC.chooseInt (Int
1, Int
fuel)
    a
x <- Int -> Gen a -> Gen a
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize Int
s Gen a
subGen
    [a]
xs <- Int -> Gen [a] -> Gen [a]
forall a. HasCallStack => Int -> Gen a -> Gen a
QC.resize (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int
fuel Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
10) (Gen a -> Gen [a]
forall a. Gen a -> Gen [a]
fuelledList Gen a
subGen)
    [a] -> Gen [a]
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([a] -> Gen [a]) -> [a] -> Gen [a]
forall a b. (a -> b) -> a -> b
$ a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
xs


traverseS :: (Statement -> Statement) -> (Expr -> Expr) -> Statement -> Statement
traverseS :: (Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
stmt = Statement -> Statement
go (Statement -> Statement
fS Statement
stmt)
  where
    go :: Statement -> Statement
go (PositionedS SourcePosition
pos Statement
s) = SourcePosition -> Statement -> Statement
PositionedS SourcePosition
pos (Statement -> Statement) -> Statement -> Statement
forall a b. (a -> b) -> a -> b
$ (Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
s
    go (GroupS [Statement]
xs) = [Statement] -> Statement
GroupS ((Statement -> Statement) -> [Statement] -> [Statement]
forall a b. (a -> b) -> [a] -> [b]
map ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE) [Statement]
xs)
    go (InterpolationS Expr
e) = Expr -> Statement
InterpolationS ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
e)
    go (ForS Maybe Identifier
k Identifier
v Expr
i Maybe Expr
condMay Recursivity
rec Statement
body Maybe Statement
elseMay) =
      Maybe Identifier
-> Identifier
-> Expr
-> Maybe Expr
-> Recursivity
-> Statement
-> Maybe Statement
-> Statement
ForS
        Maybe Identifier
k Identifier
v
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
i)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> Maybe Expr -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
condMay)
        Recursivity
rec
        ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
body)
        ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE (Statement -> Statement) -> Maybe Statement -> Maybe Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Statement
elseMay)
    go (IfS Expr
cond Statement
yes Maybe Statement
noMay) =
      Expr -> Statement -> Maybe Statement -> Statement
IfS ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
cond) ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
yes) ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE (Statement -> Statement) -> Maybe Statement -> Maybe Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Statement
noMay)
    go (MacroS Identifier
name [MacroArg]
args Statement
body) =
      Identifier -> [MacroArg] -> Statement -> Statement
MacroS Identifier
name [(Identifier
n, (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> Maybe Expr -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
d) | (Identifier
n, Maybe Expr
d) <- [MacroArg]
args] ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
body)
    go (CallS Identifier
name [Expr]
args [(Identifier, Expr)]
kwargs Statement
body) =
      Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
CallS
        Identifier
name
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> [Expr] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Expr]
args)
        [(Identifier
n, (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
v) | (Identifier
n, Expr
v) <- [(Identifier, Expr)]
kwargs]
        ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
body)
    go (FilterS Identifier
name [Expr]
args [(Identifier, Expr)]
kwargs Statement
body) =
      Identifier
-> [Expr] -> [(Identifier, Expr)] -> Statement -> Statement
FilterS
        Identifier
name
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> [Expr] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Expr]
args)
        [(Identifier
n, (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
v) | (Identifier
n, Expr
v) <- [(Identifier, Expr)]
kwargs]
        ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
body)
    go (SetS SetTarget
name Expr
val) =
      SetTarget -> Expr -> Statement
SetS SetTarget
name ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
val)
    go (SetBlockS SetTarget
name Statement
body Maybe Expr
filterMay) =
      SetTarget -> Statement -> Maybe Expr -> Statement
SetBlockS SetTarget
name ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
body) ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> Maybe Expr -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
filterMay)
    go (IncludeS Expr
includee IncludeMissingPolicy
mp IncludeContextPolicy
cp) =
      Expr -> IncludeMissingPolicy -> IncludeContextPolicy -> Statement
IncludeS ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
includee) IncludeMissingPolicy
mp IncludeContextPolicy
cp
    go (ImportS Expr
importee Maybe Identifier
lname Maybe [(Identifier, Maybe Identifier)]
imports IncludeMissingPolicy
mp IncludeContextPolicy
cp) =
      Expr
-> Maybe Identifier
-> Maybe [(Identifier, Maybe Identifier)]
-> IncludeMissingPolicy
-> IncludeContextPolicy
-> Statement
ImportS ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
importee) Maybe Identifier
lname Maybe [(Identifier, Maybe Identifier)]
imports IncludeMissingPolicy
mp IncludeContextPolicy
cp
    go (BlockS Identifier
name (Block Statement
body Scoped
s Required
r)) =
      Identifier -> Block -> Statement
BlockS Identifier
name (Statement -> Scoped -> Required -> Block
Block ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
body) Scoped
s Required
r)
    go (WithS [(Identifier, Expr)]
defs Statement
body) =
      [(Identifier, Expr)] -> Statement -> Statement
WithS [ (Identifier
n, (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
e) | (Identifier
n, Expr
e) <- [(Identifier, Expr)]
defs ] ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
body)
    go Statement
s = Statement
s

traverseE :: (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE :: (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
expr = Expr -> Expr
go (Expr -> Expr
fE Expr
expr)
  where
    go :: Expr -> Expr
go (StatementE Statement
s) = Statement -> Expr
StatementE ((Statement -> Statement)
-> (Expr -> Expr) -> Statement -> Statement
traverseS Statement -> Statement
fS Expr -> Expr
fE Statement
s)
    go (ListE Vector Expr
xs) = Vector Expr -> Expr
ListE ((Expr -> Expr) -> Vector Expr -> Vector Expr
forall a b. (a -> b) -> Vector a -> Vector b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS) Vector Expr
xs)
    go (DictE [(Expr, Expr)]
items) =
      [(Expr, Expr)] -> Expr
DictE [ ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
k, (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
v) | (Expr
k, Expr
v) <- [(Expr, Expr)]
items ]
    go (UnaryE UnaryOperator
op Expr
e) = UnaryOperator -> Expr -> Expr
UnaryE UnaryOperator
op ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
e)
    go (BinaryE BinaryOperator
op Expr
a Expr
b) = BinaryOperator -> Expr -> Expr -> Expr
BinaryE BinaryOperator
op ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
a) ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
b)
    go (SliceE Expr
slicee Maybe Expr
startMay Maybe Expr
lengthMay) =
      Expr -> Maybe Expr -> Maybe Expr -> Expr
SliceE
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
slicee)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> Maybe Expr -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
startMay)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> Maybe Expr -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Expr
lengthMay)
    go (DotE Expr
e Identifier
i) = Expr -> Identifier -> Expr
DotE ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
e) Identifier
i
    go (IsE Expr
scrutinee Expr
test [Expr]
args [(Identifier, Expr)]
kwargs) =
      Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
IsE
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
scrutinee)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
test)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> [Expr] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Expr]
args)
        [ (Identifier
n, (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
e) | (Identifier
n, Expr
e) <- [(Identifier, Expr)]
kwargs ]
    go (CallE Expr
callee [Expr]
args [(Identifier, Expr)]
kwargs) =
      Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
CallE
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
callee)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> [Expr] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Expr]
args)
        [ (Identifier
n, (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
e) | (Identifier
n, Expr
e) <- [(Identifier, Expr)]
kwargs ]
    go (FilterE Expr
arg0 Expr
f [Expr]
args [(Identifier, Expr)]
kwargs) =
      Expr -> Expr -> [Expr] -> [(Identifier, Expr)] -> Expr
FilterE
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
arg0)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
f)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS (Expr -> Expr) -> [Expr] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Expr]
args)
        [ (Identifier
n, (Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
e) | (Identifier
n, Expr
e) <- [(Identifier, Expr)]
kwargs ]
    go (TernaryE Expr
cond Expr
yes Expr
no) =
      Expr -> Expr -> Expr -> Expr
TernaryE
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
cond)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
yes)
        ((Expr -> Expr) -> (Statement -> Statement) -> Expr -> Expr
traverseE Expr -> Expr
fE Statement -> Statement
fS Expr
no)
    go Expr
e = Expr
e