Copyright	(C) CSIRO 2017-2019
License	BSD3
Maintainer	Isaac Elliott <isaace71295@gmail.com>
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Language.Python.Syntax.Expr

Contents

Expressions
Parameters and arguments
Comprehension expressions
Collection items
Subscripts

Description

Synopsis

data Expr (v :: [*]) a
- = Unit {
  - _unsafeExprAnn :: Ann a
  - _unsafeUnitWhitespaceInner :: [Whitespace]
  - _unsafeUnitWhitespaceRight :: [Whitespace]
  }
- | Lambda {
  - _unsafeExprAnn :: Ann a
  - _unsafeLambdaWhitespace :: [Whitespace]
  - _unsafeLambdaArgs :: CommaSep (Param v a)
  - _unsafeLambdaColon :: Colon
  - _unsafeLambdaBody :: Expr v a
  }
- | Yield {
  - _unsafeExprAnn :: Ann a
  - _unsafeYieldWhitespace :: [Whitespace]
  - _unsafeYieldValue :: CommaSep (Expr v a)
  }
- | YieldFrom {
  - _unsafeExprAnn :: Ann a
  - _unsafeYieldWhitespace :: [Whitespace]
  - _unsafeFromWhitespace :: [Whitespace]
  - _unsafeYieldFromValue :: Expr v a
  }
- | Ternary {
  - _unsafeExprAnn :: Ann a
  - _unsafeTernaryValue :: Expr v a
  - _unsafeTernaryWhitespaceIf :: [Whitespace]
  - _unsafeTernaryCond :: Expr v a
  - _unsafeTernaryWhitespaceElse :: [Whitespace]
  - _unsafeTernaryElse :: Expr v a
  }
- | ListComp {
  - _unsafeExprAnn :: Ann a
  - _unsafeListCompWhitespaceLeft :: [Whitespace]
  - _unsafeListCompValue :: Comprehension Expr v a
  - _unsafeListCompWhitespaceRight :: [Whitespace]
  }
- | List {
  - _unsafeExprAnn :: Ann a
  - _unsafeListWhitespaceLeft :: [Whitespace]
  - _unsafeListValues :: Maybe (CommaSep1' (ListItem v a))
  - _unsafeListWhitespaceRight :: [Whitespace]
  }
- | DictComp {
  - _unsafeExprAnn :: Ann a
  - _unsafeDictCompWhitespaceLeft :: [Whitespace]
  - _unsafeDictCompValue :: Comprehension DictItem v a
  - _unsafeDictCompWhitespaceRight :: [Whitespace]
  }
- | Dict {
  - _unsafeExprAnn :: Ann a
  - _unsafeDictWhitespaceLeft :: [Whitespace]
  - _unsafeDictValues :: Maybe (CommaSep1' (DictItem v a))
  - _unsafeDictWhitespaceRight :: [Whitespace]
  }
- | SetComp {
  - _unsafeExprAnn :: Ann a
  - _unsafeSetCompWhitespaceLeft :: [Whitespace]
  - _unsafeSetCompValue :: Comprehension SetItem v a
  - _unsafeSetCompWhitespaceRight :: [Whitespace]
  }
- | Set {
  - _unsafeExprAnn :: Ann a
  - _unsafeSetWhitespaceLeft :: [Whitespace]
  - _unsafeSetValues :: CommaSep1' (SetItem v a)
  - _unsafeSetWhitespaceRight :: [Whitespace]
  }
- | Deref {
  - _unsafeExprAnn :: Ann a
  - _unsafeDerefValueLeft :: Expr v a
  - _unsafeDerefWhitespaceLeft :: [Whitespace]
  - _unsafeDerefValueRight :: Ident v a
  }
- | Subscript {
  - _unsafeExprAnn :: Ann a
  - _unsafeSubscriptValueLeft :: Expr v a
  - _unsafeSubscriptWhitespaceLeft :: [Whitespace]
  - _unsafeSubscriptValueRight :: CommaSep1' (Subscript v a)
  - _unsafeSubscriptWhitespaceRight :: [Whitespace]
  }
- | Call {
  - _unsafeExprAnn :: Ann a
  - _unsafeCallFunction :: Expr v a
  - _unsafeCallWhitespaceLeft :: [Whitespace]
  - _unsafeCallArguments :: Maybe (CommaSep1' (Arg v a))
  - _unsafeCallWhitespaceRight :: [Whitespace]
  }
- | None {
  - _unsafeExprAnn :: Ann a
  - _unsafeNoneWhitespace :: [Whitespace]
  }
- | Ellipsis {
  - _unsafeExprAnn :: Ann a
  - _unsafeEllipsisWhitespace :: [Whitespace]
  }
- | BinOp {
  - _unsafeExprAnn :: Ann a
  - _unsafeBinOpExprLeft :: Expr v a
  - _unsafeBinOpOp :: BinOp a
  - _unsafeBinOpExprRight :: Expr v a
  }
- | UnOp {
  - _exprAnn :: Ann a
  - _unsafeUnOpOp :: UnOp a
  - _unsafeUnOpValue :: Expr v a
  }
- | Parens {
  - _exprAnn :: Ann a
  - _unsafeParensWhitespaceLeft :: [Whitespace]
  - _unsafeParensValue :: Expr v a
  - _unsafeParensWhitespaceAfter :: [Whitespace]
  }
- | Ident {
  - _exprAnn :: Ann a
  - _unsafeIdentValue :: Ident v a
  }
- | Int {
  - _exprAnn :: Ann a
  - _unsafeIntValue :: IntLiteral a
  - _unsafeIntWhitespace :: [Whitespace]
  }
- | Float {
  - _exprAnn :: Ann a
  - _unsafeFloatValue :: FloatLiteral a
  - _unsafeFloatWhitespace :: [Whitespace]
  }
- | Imag {
  - _exprAnn :: Ann a
  - _unsafeImagValue :: ImagLiteral a
  - _unsafeImagWhitespace :: [Whitespace]
  }
- | Bool {
  - _exprAnn :: Ann a
  - _unsafeBoolValue :: Bool
  - _unsafeBoolWhitespace :: [Whitespace]
  }
- | String {
  - _exprAnn :: Ann a
  - _unsafeStringValue :: NonEmpty (StringLiteral a)
  }
- | Tuple {
  - _exprAnn :: Ann a
  - _unsafeTupleHead :: TupleItem v a
  - _unsafeTupleWhitespace :: Comma
  - _unsafeTupleTail :: Maybe (CommaSep1' (TupleItem v a))
  }
- | Not {
  - _exprAnn :: Ann a
  - _unsafeNotWhitespace :: [Whitespace]
  - _unsafeNotValue :: Expr v a
  }
- | Generator {
  - _exprAnn :: Ann a
  - _generatorValue :: Comprehension Expr v a
  }
- | Await {
  - _exprAnn :: Ann a
  - _unsafeAwaitWhitespace :: [Whitespace]
  - _unsafeAwaitValue :: Expr v a
  }
class HasExprs s where
shouldGroupLeft :: BinOp a -> Expr v a -> Bool
shouldGroupRight :: BinOp a -> Expr v a -> Bool
data Param (v :: [*]) a
- = PositionalParam {
  - _paramAnn :: Ann a
  - _paramName :: Ident v a
  - _paramType :: Maybe (Colon, Expr v a)
  }
- | KeywordParam {
  - _paramAnn :: Ann a
  - _paramName :: Ident v a
  - _paramType :: Maybe (Colon, Expr v a)
  - _unsafeKeywordParamWhitespaceRight :: [Whitespace]
  - _unsafeKeywordParamExpr :: Expr v a
  }
- | StarParam {
  - _paramAnn :: Ann a
  - _unsafeStarParamWhitespace :: [Whitespace]
  - _unsafeStarParamName :: Ident v a
  - _paramType :: Maybe (Colon, Expr v a)
  }
- | UnnamedStarParam {
  - _paramAnn :: Ann a
  - _unsafeUnnamedStarParamWhitespace :: [Whitespace]
  }
- | DoubleStarParam {
  - _paramAnn :: Ann a
  - _unsafeDoubleStarParamWhitespace :: [Whitespace]
  - _paramName :: Ident v a
  - _paramType :: Maybe (Colon, Expr v a)
  }
paramAnn :: Lens' (Param v a) a
paramType_ :: Functor f => (Maybe (Colon, Expr v a) -> f (Maybe (Colon, Expr '[] a))) -> Param v a -> f (Param '[] a)
paramType :: Traversal (Param v a) (Param '[] a) (Colon, Expr v a) (Colon, Expr '[] a)
paramName :: Traversal (Param v a) (Param '[] a) (Ident v a) (Ident '[] a)
data Arg (v :: [*]) a
- = PositionalArg {
  - _argAnn :: Ann a
  - _argExpr :: Expr v a
  }
- | KeywordArg {
  - _argAnn :: Ann a
  - _unsafeKeywordArgName :: Ident v a
  - _unsafeKeywordArgWhitespaceRight :: [Whitespace]
  - _argExpr :: Expr v a
  }
- | StarArg {
  - _argAnn :: Ann a
  - _unsafeStarArgWhitespace :: [Whitespace]
  - _argExpr :: Expr v a
  }
- | DoubleStarArg {
  - _argAnn :: Ann a
  - _unsafeDoubleStarArgWhitespace :: [Whitespace]
  - _argExpr :: Expr v a
  }
argExpr :: Lens (Arg v a) (Arg '[] a) (Expr v a) (Expr '[] a)
data Comprehension e (v :: [*]) a = Comprehension (Ann a) (e v a) (CompFor v a) [Either (CompFor v a) (CompIf v a)]
data CompIf (v :: [*]) a = CompIf (Ann a) [Whitespace] (Expr v a)
data CompFor (v :: [*]) a = CompFor (Ann a) [Whitespace] (Expr v a) [Whitespace] (Expr v a)
data DictItem (v :: [*]) a
- = DictItem {
  - _dictItemAnn :: Ann a
  - _unsafeDictItemKey :: Expr v a
  - _unsafeDictItemColon :: Colon
  - _unsafeDictItemValue :: Expr v a
  }
- | DictUnpack {
  - _dictItemAnn :: Ann a
  - _unsafeDictItemUnpackWhitespace :: [Whitespace]
  - _unsafeDictItemUnpackValue :: Expr v a
  }
data ListItem (v :: [*]) a
- = ListItem {
  - _listItemAnn :: Ann a
  - _unsafeListItemValue :: Expr v a
  }
- | ListUnpack {
  - _listItemAnn :: Ann a
  - _unsafeListUnpackParens :: [([Whitespace], [Whitespace])]
  - _unsafeListUnpackWhitespace :: [Whitespace]
  - _unsafeListUnpackValue :: Expr v a
  }
data SetItem (v :: [*]) a
- = SetItem {
  - _setItemAnn :: Ann a
  - _unsafeSetItemValue :: Expr v a
  }
- | SetUnpack {
  - _setItemAnn :: Ann a
  - _unsafeSetUnpackParens :: [([Whitespace], [Whitespace])]
  - _unsafeSetUnpackWhitespace :: [Whitespace]
  - _unsafeSetUnpackValue :: Expr v a
  }
data TupleItem (v :: [*]) a
- = TupleItem {
  - _tupleItemAnn :: Ann a
  - _unsafeTupleItemValue :: Expr v a
  }
- | TupleUnpack {
  - _tupleItemAnn :: Ann a
  - _unsafeTupleUnpackParens :: [([Whitespace], [Whitespace])]
  - _unsafeTupleUnpackWhitespace :: [Whitespace]
  - _unsafeTupleUnpackValue :: Expr v a
  }
data Subscript (v :: [*]) a
- = SubscriptExpr (Expr v a)
- | SubscriptSlice (Maybe (Expr v a)) Colon (Maybe (Expr v a)) (Maybe (Colon, Maybe (Expr v a)))

Expressions

data Expr (v :: [*]) a #

This large sum type covers all valid Python expressions

Constructors

Unit	() https://docs.python.org/3/reference/expressions.html#parenthesized-forms
Fields _unsafeExprAnn :: Ann a _unsafeUnitWhitespaceInner :: [Whitespace] _unsafeUnitWhitespaceRight :: [Whitespace]
Lambda	lambda x, y: x https://docs.python.org/3/reference/expressions.html#lambda
Fields _unsafeExprAnn :: Ann a _unsafeLambdaWhitespace :: [Whitespace] _unsafeLambdaArgs :: CommaSep (Param v a) _unsafeLambdaColon :: Colon _unsafeLambdaBody :: Expr v a
Yield	yield yield a yield a, b https://docs.python.org/3/reference/expressions.html#yield-expressions
Fields _unsafeExprAnn :: Ann a _unsafeYieldWhitespace :: [Whitespace] _unsafeYieldValue :: CommaSep (Expr v a)
YieldFrom	yield from a https://docs.python.org/3/reference/expressions.html#yield-expressions
Fields _unsafeExprAnn :: Ann a _unsafeYieldWhitespace :: [Whitespace] _unsafeFromWhitespace :: [Whitespace] _unsafeYieldFromValue :: Expr v a
Ternary	a if b else c https://docs.python.org/3/reference/expressions.html#conditional-expressions
Fields _unsafeExprAnn :: Ann a _unsafeTernaryValue :: Expr v a _unsafeTernaryWhitespaceIf :: [Whitespace] _unsafeTernaryCond :: Expr v a _unsafeTernaryWhitespaceElse :: [Whitespace] _unsafeTernaryElse :: Expr v a
ListComp	[a for b in c if d] https://docs.python.org/3/reference/expressions.html#list-displays
Fields _unsafeExprAnn :: Ann a _unsafeListCompWhitespaceLeft :: [Whitespace] _unsafeListCompValue :: Comprehension Expr v a _unsafeListCompWhitespaceRight :: [Whitespace]
List	[a, b, c] https://docs.python.org/3/reference/expressions.html#list-displays
Fields _unsafeExprAnn :: Ann a _unsafeListWhitespaceLeft :: [Whitespace] _unsafeListValues :: Maybe (CommaSep1' (ListItem v a)) _unsafeListWhitespaceRight :: [Whitespace]
DictComp	{a: b for c in d if e} https://docs.python.org/3/reference/expressions.html#dictionary-displays
Fields _unsafeExprAnn :: Ann a _unsafeDictCompWhitespaceLeft :: [Whitespace] _unsafeDictCompValue :: Comprehension DictItem v a _unsafeDictCompWhitespaceRight :: [Whitespace]
Dict	{} {a: 1, b: 2, c: 3} https://docs.python.org/3/reference/expressions.html#dictionary-displays
Fields _unsafeExprAnn :: Ann a _unsafeDictWhitespaceLeft :: [Whitespace] _unsafeDictValues :: Maybe (CommaSep1' (DictItem v a)) _unsafeDictWhitespaceRight :: [Whitespace]
SetComp	{a for b in c if d} https://docs.python.org/3/reference/expressions.html#set-displays
Fields _unsafeExprAnn :: Ann a _unsafeSetCompWhitespaceLeft :: [Whitespace] _unsafeSetCompValue :: Comprehension SetItem v a _unsafeSetCompWhitespaceRight :: [Whitespace]
Set	{a, b, c} https://docs.python.org/3/reference/expressions.html#set-displays
Fields _unsafeExprAnn :: Ann a _unsafeSetWhitespaceLeft :: [Whitespace] _unsafeSetValues :: CommaSep1' (SetItem v a) _unsafeSetWhitespaceRight :: [Whitespace]
Deref	a.b https://docs.python.org/3/reference/expressions.html#attribute-references
Fields _unsafeExprAnn :: Ann a _unsafeDerefValueLeft :: Expr v a _unsafeDerefWhitespaceLeft :: [Whitespace] _unsafeDerefValueRight :: Ident v a
Subscript	a[b] a[:] a[:, b:] etc. https://docs.python.org/3/reference/expressions.html#subscriptions
Fields _unsafeExprAnn :: Ann a _unsafeSubscriptValueLeft :: Expr v a _unsafeSubscriptWhitespaceLeft :: [Whitespace] _unsafeSubscriptValueRight :: CommaSep1' (Subscript v a) _unsafeSubscriptWhitespaceRight :: [Whitespace]
Call	f(x) https://docs.python.org/3/reference/expressions.html#calls
Fields _unsafeExprAnn :: Ann a _unsafeCallFunction :: Expr v a _unsafeCallWhitespaceLeft :: [Whitespace] _unsafeCallArguments :: Maybe (CommaSep1' (Arg v a)) _unsafeCallWhitespaceRight :: [Whitespace]
None	None https://docs.python.org/3/library/constants.html#None
Fields _unsafeExprAnn :: Ann a _unsafeNoneWhitespace :: [Whitespace]
Ellipsis	... https://docs.python.org/3/library/constants.html#Ellipsis
Fields _unsafeExprAnn :: Ann a _unsafeEllipsisWhitespace :: [Whitespace]
BinOp	a + b https://docs.python.org/3/reference/expressions.html#the-power-operator https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations https://docs.python.org/3/reference/expressions.html#shifting-operations https://docs.python.org/3/reference/expressions.html#binary-bitwise-operations https://docs.python.org/3/reference/expressions.html#comparisons https://docs.python.org/3/reference/expressions.html#membership-test-operations https://docs.python.org/3/reference/expressions.html#is-not https://docs.python.org/3/reference/expressions.html#boolean-operations
Fields _unsafeExprAnn :: Ann a _unsafeBinOpExprLeft :: Expr v a _unsafeBinOpOp :: BinOp a _unsafeBinOpExprRight :: Expr v a
UnOp	-a ~a +a https://docs.python.org/3/reference/expressions.html#unary-arithmetic-and-bitwise-operations
Fields _exprAnn :: Ann a _unsafeUnOpOp :: UnOp a _unsafeUnOpValue :: Expr v a
Parens
Fields _exprAnn :: Ann a _unsafeParensWhitespaceLeft :: [Whitespace] _unsafeParensValue :: Expr v a _unsafeParensWhitespaceAfter :: [Whitespace]
Ident	a https://docs.python.org/3/reference/expressions.html#atom-identifiers
Fields _exprAnn :: Ann a _unsafeIdentValue :: Ident v a
Int	1 @0xF3A @0o177 0b1011 https://docs.python.org/3/reference/lexical_analysis.html#grammar-token-integer
Fields _exprAnn :: Ann a _unsafeIntValue :: IntLiteral a _unsafeIntWhitespace :: [Whitespace]
Float	1. 3.14 10e100 https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals
Fields _exprAnn :: Ann a _unsafeFloatValue :: FloatLiteral a _unsafeFloatWhitespace :: [Whitespace]
Imag	10j 5.j https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals
Fields _exprAnn :: Ann a _unsafeImagValue :: ImagLiteral a _unsafeImagWhitespace :: [Whitespace]
Bool	True False https://docs.python.org/3/library/constants.html#True https://docs.python.org/3/library/constants.html#False
Fields _exprAnn :: Ann a _unsafeBoolValue :: Bool _unsafeBoolWhitespace :: [Whitespace]
String	"asdf" b"asdf" "asdf" 'asdf' '''asdf''' https://docs.python.org/3/reference/lexical_analysis.html#grammar-token-stringliteral
Fields _exprAnn :: Ann a _unsafeStringValue :: NonEmpty (StringLiteral a)
Tuple	a, b, c (a, b) (a,) https://docs.python.org/3/reference/expressions.html#expression-lists
Fields _exprAnn :: Ann a _unsafeTupleHead :: TupleItem v a _unsafeTupleWhitespace :: Comma _unsafeTupleTail :: Maybe (CommaSep1' (TupleItem v a))
Not	not a https://docs.python.org/3/reference/expressions.html#boolean-operations
Fields _exprAnn :: Ann a _unsafeNotWhitespace :: [Whitespace] _unsafeNotValue :: Expr v a
Generator	(a for b in c) https://docs.python.org/3/reference/expressions.html#generator-expressions
Fields _exprAnn :: Ann a _generatorValue :: Comprehension Expr v a
Await	await a https://docs.python.org/3/reference/expressions.html#await
Fields _exprAnn :: Ann a _unsafeAwaitWhitespace :: [Whitespace] _unsafeAwaitValue :: Expr v a

Instances

Validated Expr #
Instance details Defined in Language.Python.Syntax.Expr Methods unvalidated :: (Contravariant f, Functor f) => (Expr [] a -> f (Expr [] a)) -> Expr v a -> f (Expr v a) #
HasExprs Expr #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Expr v a -> f (Expr [] a) #
HasIdents Expr #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> Expr v a -> f (Expr [] a) #
AsTupleItem Expr #
Instance details Defined in Language.Python.DSL Methods ti_ :: Raw Expr -> Raw TupleItem #
AsWithItem Expr #
Instance details Defined in Language.Python.DSL Methods toWithItem :: Raw Expr -> Raw WithItem #
AsExceptAs Expr #
Instance details Defined in Language.Python.DSL Methods toExceptAs :: Raw Expr -> Raw ExceptAs #
AsSetItem Expr #
Instance details Defined in Language.Python.DSL Methods si_ :: Raw Expr -> Raw SetItem #
AsListItem Expr #
Instance details Defined in Language.Python.DSL Methods li_ :: Raw Expr -> Raw ListItem #
AsLine Expr #
Instance details Defined in Language.Python.DSL Methods line_ :: Raw Expr -> Raw Line #
DoubleStarSyntax Expr DictItem #	See `dict_`
Instance details Defined in Language.Python.DSL Methods ss_ :: Raw Expr -> Raw DictItem #
DoubleStarSyntax Expr Arg #	See `call_`
Instance details Defined in Language.Python.DSL Methods ss_ :: Raw Expr -> Raw Arg #
StarSyntax Expr TupleItem #	See `tuple_`
Instance details Defined in Language.Python.DSL Methods s_ :: Raw Expr -> Raw TupleItem #
StarSyntax Expr SetItem #	See `set_`
Instance details Defined in Language.Python.DSL Methods s_ :: Raw Expr -> Raw SetItem #
StarSyntax Expr ListItem #	See `list_`
Instance details Defined in Language.Python.DSL Methods s_ :: Raw Expr -> Raw ListItem #
StarSyntax Expr Arg #	See `call_`
Instance details Defined in Language.Python.DSL Methods s_ :: Raw Expr -> Raw Arg #
PositionalSyntax Arg Expr #	See `call_`
Instance details Defined in Language.Python.DSL Methods p_ :: Raw Expr -> Raw Arg #
ColonSyntax Expr DictItem #	Constructing dictionary items (`.:`) :: `Raw` `Expr` -> `Raw` `Expr` -> `Raw` `DictItem`
Instance details Defined in Language.Python.DSL Methods (.:) :: Raw Expr -> Raw Expr -> Raw DictItem #
As Expr Ident ExceptAs #	See `exceptAs_`
Instance details Defined in Language.Python.DSL Methods as_ :: Raw Expr -> Raw Ident -> Raw ExceptAs #
As Expr Expr WithItem #	See `with_`
Instance details Defined in Language.Python.DSL Methods as_ :: Raw Expr -> Raw Expr -> Raw WithItem #
InSyntax Expr (Raw Expr) #	`>>>` var_ "a" `in_` var_ "b"a in b
Instance details Defined in Language.Python.DSL Methods in_ :: Raw Expr -> Raw Expr -> Raw Expr #
Functor (Expr v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> Expr v a -> Expr v b # (<$) :: a -> Expr v b -> Expr v a #
Foldable (Expr v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => Expr v m -> m # foldMap :: Monoid m => (a -> m) -> Expr v a -> m # foldr :: (a -> b -> b) -> b -> Expr v a -> b # foldr' :: (a -> b -> b) -> b -> Expr v a -> b # foldl :: (b -> a -> b) -> b -> Expr v a -> b # foldl' :: (b -> a -> b) -> b -> Expr v a -> b # foldr1 :: (a -> a -> a) -> Expr v a -> a # foldl1 :: (a -> a -> a) -> Expr v a -> a # toList :: Expr v a -> [a] # null :: Expr v a -> Bool # length :: Expr v a -> Int # elem :: Eq a => a -> Expr v a -> Bool # maximum :: Ord a => Expr v a -> a # minimum :: Ord a => Expr v a -> a # sum :: Num a => Expr v a -> a # product :: Num a => Expr v a -> a #
Traversable (Expr v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> Expr v a -> f (Expr v b) # sequenceA :: Applicative f => Expr v (f a) -> f (Expr v a) # mapM :: Monad m => (a -> m b) -> Expr v a -> m (Expr v b) # sequence :: Monad m => Expr v (m a) -> m (Expr v a) #
HasAnn (Expr v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> Expr v a -> f (Expr v a) #
Eq a => Eq (Expr v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: Expr v a -> Expr v a -> Bool # (/=) :: Expr v a -> Expr v a -> Bool #
Num (Expr ([] :: [*]) ()) #
Instance details Defined in Language.Python.Syntax.Expr Methods (+) :: Expr [] () -> Expr [] () -> Expr [] () # (-) :: Expr [] () -> Expr [] () -> Expr [] () # (*) :: Expr [] () -> Expr [] () -> Expr [] () # negate :: Expr [] () -> Expr [] () # abs :: Expr [] () -> Expr [] () # signum :: Expr [] () -> Expr [] () # fromInteger :: Integer -> Expr [] () #
Show a => Show (Expr v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> Expr v a -> ShowS # show :: Expr v a -> String # showList :: [Expr v a] -> ShowS #
IsString (Expr ([] :: [*]) ()) #
Instance details Defined in Language.Python.Syntax.Expr Methods fromString :: String -> Expr [] () #
Generic (Expr v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (Expr v a) :: * -> * # Methods from :: Expr v a -> Rep (Expr v a) x # to :: Rep (Expr v a) x -> Expr v a #
Plated (Expr ([] :: [*]) a) #
Instance details Defined in Language.Python.Syntax.Expr Methods plate :: Traversal' (Expr [] a) (Expr [] a) #
HasTrailingWhitespace (Expr v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (Expr v a) [Whitespace] #
HasNewlines (Expr v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (Expr v a) Newline #
type Rep (Expr v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (Expr v a) = D1 (MetaData "Expr" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) ((((C1 (MetaCons "Unit" PrefixI True) (S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeUnitWhitespaceInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeUnitWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]))) :+: (C1 (MetaCons "Lambda" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeLambdaWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeLambdaArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CommaSep (Param v a))) :: (S1 (MetaSel (Just "_unsafeLambdaColon") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Colon) :: S1 (MetaSel (Just "_unsafeLambdaBody") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))))) :+: C1 (MetaCons "Yield" PrefixI True) (S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeYieldWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeYieldValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CommaSep (Expr v a))))))) :+: ((C1 (MetaCons "YieldFrom" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeYieldWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeFromWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeYieldFromValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))) :+: C1 (MetaCons "Ternary" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeTernaryValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)) :: S1 (MetaSel (Just "_unsafeTernaryWhitespaceIf") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]))) :: (S1 (MetaSel (Just "_unsafeTernaryCond") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)) :: (S1 (MetaSel (Just "_unsafeTernaryWhitespaceElse") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeTernaryElse") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))))) :+: (C1 (MetaCons "ListComp" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeListCompWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeListCompValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Comprehension Expr v a)) :: S1 (MetaSel (Just "_unsafeListCompWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]))) :+: C1 (MetaCons "List" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeListWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeListValues") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (CommaSep1' (ListItem v a)))) :: S1 (MetaSel (Just "_unsafeListWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])))))) :+: ((C1 (MetaCons "DictComp" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeDictCompWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeDictCompValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Comprehension DictItem v a)) :: S1 (MetaSel (Just "_unsafeDictCompWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]))) :+: (C1 (MetaCons "Dict" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeDictWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeDictValues") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (CommaSep1' (DictItem v a)))) :: S1 (MetaSel (Just "_unsafeDictWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]))) :+: C1 (MetaCons "SetComp" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeSetCompWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeSetCompValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Comprehension SetItem v a)) :: S1 (MetaSel (Just "_unsafeSetCompWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]))))) :+: ((C1 (MetaCons "Set" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeSetWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeSetValues") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CommaSep1' (SetItem v a))) :: S1 (MetaSel (Just "_unsafeSetWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]))) :+: C1 (MetaCons "Deref" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeDerefValueLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :: (S1 (MetaSel (Just "_unsafeDerefWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeDerefValueRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ident v a))))) :+: (C1 (MetaCons "Subscript" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeSubscriptValueLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :: (S1 (MetaSel (Just "_unsafeSubscriptWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: (S1 (MetaSel (Just "_unsafeSubscriptValueRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CommaSep1' (Subscript v a))) :: S1 (MetaSel (Just "_unsafeSubscriptWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])))) :+: C1 (MetaCons "Call" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeCallFunction") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :: (S1 (MetaSel (Just "_unsafeCallWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: (S1 (MetaSel (Just "_unsafeCallArguments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (CommaSep1' (Arg v a)))) :: S1 (MetaSel (Just "_unsafeCallWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])))))))) :+: (((C1 (MetaCons "None" PrefixI True) (S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeNoneWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :+: (C1 (MetaCons "Ellipsis" PrefixI True) (S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeEllipsisWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :+: C1 (MetaCons "BinOp" PrefixI True) ((S1 (MetaSel (Just "_unsafeExprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeBinOpExprLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :: (S1 (MetaSel (Just "_unsafeBinOpOp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (BinOp a)) :: S1 (MetaSel (Just "_unsafeBinOpExprRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))))) :+: ((C1 (MetaCons "UnOp" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeUnOpOp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (UnOp a)) :: S1 (MetaSel (Just "_unsafeUnOpValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))) :+: C1 (MetaCons "Parens" PrefixI True) ((S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeParensWhitespaceLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeParensValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)) :: S1 (MetaSel (Just "_unsafeParensWhitespaceAfter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])))) :+: (C1 (MetaCons "Ident" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeIdentValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ident v a))) :+: C1 (MetaCons "Int" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeIntValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (IntLiteral a)) :: S1 (MetaSel (Just "_unsafeIntWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])))))) :+: (((C1 (MetaCons "Float" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeFloatValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (FloatLiteral a)) :: S1 (MetaSel (Just "_unsafeFloatWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]))) :+: C1 (MetaCons "Imag" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeImagValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ImagLiteral a)) :: S1 (MetaSel (Just "_unsafeImagWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])))) :+: (C1 (MetaCons "Bool" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeBoolValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :: S1 (MetaSel (Just "_unsafeBoolWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]))) :+: C1 (MetaCons "String" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeStringValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (StringLiteral a)))))) :+: ((C1 (MetaCons "Tuple" PrefixI True) ((S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeTupleHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (TupleItem v a))) :: (S1 (MetaSel (Just "_unsafeTupleWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Comma) :: S1 (MetaSel (Just "_unsafeTupleTail") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (CommaSep1' (TupleItem v a)))))) :+: C1 (MetaCons "Not" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeNotWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeNotValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))))) :+: (C1 (MetaCons "Generator" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_generatorValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Comprehension Expr v a))) :+: C1 (MetaCons "Await" PrefixI True) (S1 (MetaSel (Just "_exprAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeAwaitWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :*: S1 (MetaSel (Just "_unsafeAwaitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))))))))

class HasExprs s where #

Traversal over all the expressions in a term

Minimal complete definition

_Exprs

Methods

_Exprs :: Traversal (s v a) (s '[] a) (Expr v a) (Expr '[] a) #

Instances

HasExprs Expr #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Expr v a -> f (Expr [] a) #
HasExprs TupleItem #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> TupleItem v a -> f (TupleItem [] a) #
HasExprs SetItem #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> SetItem v a -> f (SetItem [] a) #
HasExprs ListItem #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> ListItem v a -> f (ListItem [] a) #
HasExprs Arg #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Arg v a -> f (Arg [] a) #
HasExprs Param #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Param v a -> f (Param [] a) #
HasExprs CompoundStatement #
Instance details Defined in Language.Python.Syntax.Statement Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> CompoundStatement v a -> f (CompoundStatement [] a) #
HasExprs Decorator #
Instance details Defined in Language.Python.Syntax.Statement Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Decorator v a -> f (Decorator [] a) #
HasExprs WithItem #
Instance details Defined in Language.Python.Syntax.Statement Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> WithItem v a -> f (WithItem [] a) #
HasExprs Suite #
Instance details Defined in Language.Python.Syntax.Statement Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Suite v a -> f (Suite [] a) #
HasExprs ExceptAs #
Instance details Defined in Language.Python.Syntax.Statement Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> ExceptAs v a -> f (ExceptAs [] a) #
HasExprs SimpleStatement #
Instance details Defined in Language.Python.Syntax.Statement Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> SimpleStatement v a -> f (SimpleStatement [] a) #
HasExprs Statement #
Instance details Defined in Language.Python.Syntax.Statement Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Statement v a -> f (Statement [] a) #
HasExprs SmallStatement #
Instance details Defined in Language.Python.Syntax.Statement Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> SmallStatement v a -> f (SmallStatement [] a) #
HasExprs Block #
Instance details Defined in Language.Python.Syntax.Statement Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Block v a -> f (Block [] a) #
HasExprs Module #
Instance details Defined in Language.Python.Syntax.Module Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Module v a -> f (Module [] a) #
HasExprs Line #
Instance details Defined in Language.Python.DSL Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Line v a -> f (Line [] a) #

shouldGroupLeft :: BinOp a -> Expr v a -> Bool #

shouldGroupLeft op left returns true if left needs to be parenthesised when it is the left argument of op

shouldGroupRight :: BinOp a -> Expr v a -> Bool #

shouldGroupRight op right returns true if right needs to be parenthesised when it is the right argument of op

Parameters and arguments

data Param (v :: [*]) a #

Formal parameters for functions

See https://docs.python.org/3.5/reference/compound_stmts.html#function-definitions

Constructors

PositionalParam	def foo(a):
Fields _paramAnn :: Ann a _paramName :: Ident v a _paramType :: Maybe (Colon, Expr v a)
KeywordParam	def foo(bar=None):
Fields _paramAnn :: Ann a _paramName :: Ident v a _paramType :: Maybe (Colon, Expr v a) _unsafeKeywordParamWhitespaceRight :: [Whitespace] _unsafeKeywordParamExpr :: Expr v a
StarParam	def foo(*xs):
Fields _paramAnn :: Ann a _unsafeStarParamWhitespace :: [Whitespace] _unsafeStarParamName :: Ident v a _paramType :: Maybe (Colon, Expr v a)
UnnamedStarParam	def foo(*):
Fields _paramAnn :: Ann a _unsafeUnnamedStarParamWhitespace :: [Whitespace]
DoubleStarParam	def foo(**dict):
Fields _paramAnn :: Ann a _unsafeDoubleStarParamWhitespace :: [Whitespace] _paramName :: Ident v a _paramType :: Maybe (Colon, Expr v a)

Instances

Validated Param #
Instance details Defined in Language.Python.Syntax.Expr Methods unvalidated :: (Contravariant f, Functor f) => (Param [] a -> f (Param [] a)) -> Param v a -> f (Param v a) #
HasExprs Param #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Param v a -> f (Param [] a) #
HasIdents Param #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> Param v a -> f (Param [] a) #
KeywordSyntax Param #	See `def_`
Instance details Defined in Language.Python.DSL Methods k_ :: Raw Ident -> Raw Expr -> Raw Param #
DoubleStarSyntax Ident Param #	See `def_`
Instance details Defined in Language.Python.DSL Methods ss_ :: Raw Ident -> Raw Param #
StarSyntax Ident Param #	See `def_`
Instance details Defined in Language.Python.DSL Methods s_ :: Raw Ident -> Raw Param #
PositionalSyntax Param Ident #	See `def_`
Instance details Defined in Language.Python.DSL Methods p_ :: Raw Ident -> Raw Param #
ColonSyntax Param Param #	Function parameter type annotations (`.:`) :: `Raw` `Param` -> `Raw` `Expr` -> `Raw` `Param` `star_` can be annotated using `.:`, but it will have no effect on the output program, as unnamed starred parameters cannot have type annotations. See `def_`
Instance details Defined in Language.Python.DSL Methods (.:) :: Raw Param -> Raw Expr -> Raw Param #
Functor (Param v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> Param v a -> Param v b # (<$) :: a -> Param v b -> Param v a #
Foldable (Param v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => Param v m -> m # foldMap :: Monoid m => (a -> m) -> Param v a -> m # foldr :: (a -> b -> b) -> b -> Param v a -> b # foldr' :: (a -> b -> b) -> b -> Param v a -> b # foldl :: (b -> a -> b) -> b -> Param v a -> b # foldl' :: (b -> a -> b) -> b -> Param v a -> b # foldr1 :: (a -> a -> a) -> Param v a -> a # foldl1 :: (a -> a -> a) -> Param v a -> a # toList :: Param v a -> [a] # null :: Param v a -> Bool # length :: Param v a -> Int # elem :: Eq a => a -> Param v a -> Bool # maximum :: Ord a => Param v a -> a # minimum :: Ord a => Param v a -> a # sum :: Num a => Param v a -> a # product :: Num a => Param v a -> a #
Traversable (Param v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> Param v a -> f (Param v b) # sequenceA :: Applicative f => Param v (f a) -> f (Param v a) # mapM :: Monad m => (a -> m b) -> Param v a -> m (Param v b) # sequence :: Monad m => Param v (m a) -> m (Param v a) #
HasAnn (Param v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> Param v a -> f (Param v a) #
Eq a => Eq (Param v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: Param v a -> Param v a -> Bool # (/=) :: Param v a -> Param v a -> Bool #
Show a => Show (Param v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> Param v a -> ShowS # show :: Param v a -> String # showList :: [Param v a] -> ShowS #
IsString (Param ([] :: [*]) ()) #
Instance details Defined in Language.Python.Syntax.Expr Methods fromString :: String -> Param [] () #
Generic (Param v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (Param v a) :: * -> * # Methods from :: Param v a -> Rep (Param v a) x # to :: Rep (Param v a) x -> Param v a #
HasTrailingWhitespace (Param v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (Param v a) [Whitespace] #
HasNewlines (Param v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (Param v a) Newline #
type Rep (Param v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (Param v a) = D1 (MetaData "Param" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) ((C1 (MetaCons "PositionalParam" PrefixI True) (S1 (MetaSel (Just "_paramAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_paramName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ident v a)) :: S1 (MetaSel (Just "_paramType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Colon, Expr v a))))) :+: C1 (MetaCons "KeywordParam" PrefixI True) ((S1 (MetaSel (Just "_paramAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_paramName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ident v a))) :: (S1 (MetaSel (Just "_paramType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Colon, Expr v a))) :: (S1 (MetaSel (Just "_unsafeKeywordParamWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeKeywordParamExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))))) :+: (C1 (MetaCons "StarParam" PrefixI True) ((S1 (MetaSel (Just "_paramAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeStarParamWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_unsafeStarParamName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ident v a)) :: S1 (MetaSel (Just "_paramType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Colon, Expr v a))))) :+: (C1 (MetaCons "UnnamedStarParam" PrefixI True) (S1 (MetaSel (Just "_paramAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeUnnamedStarParamWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :+: C1 (MetaCons "DoubleStarParam" PrefixI True) ((S1 (MetaSel (Just "_paramAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeDoubleStarParamWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Just "_paramName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ident v a)) :*: S1 (MetaSel (Just "_paramType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Colon, Expr v a))))))))

paramAnn :: Lens' (Param v a) a #

Lens on the syntrax tree annotation on a parameter

paramType_ :: Functor f => (Maybe (Colon, Expr v a) -> f (Maybe (Colon, Expr '[] a))) -> Param v a -> f (Param '[] a) #

A faux-lens on the optional Python type annotation which may follow a parameter

This is not a lawful Lens because setting an UnnamedStarParam's type won't have any effect.

This optic, like many others in hpython, loses validation information (the v type parameter)

The following is an example, where int is the paramtype:

def foo(x: int):

paramType :: Traversal (Param v a) (Param '[] a) (Colon, Expr v a) (Colon, Expr '[] a) #

Traversal targeting the Python type annotations which may follow a parameter

paramName :: Traversal (Param v a) (Param '[] a) (Ident v a) (Ident '[] a) #

(affine) Traversal on the name of a parameter

The name is x in the following examples:

def foo(x):
def foo(x=None):
def foo(*x):
def foo(**x):

But the following example does not have a paramName:

def foo(*):

data Arg (v :: [*]) a #

Actual parameters for functions

In the following examples, x is an actual parameter.

y = foo(x)
y = bar(quux=x)
y = baz(*x)
y = flux(**x)

Constructors

PositionalArg
Fields _argAnn :: Ann a _argExpr :: Expr v a
KeywordArg
Fields _argAnn :: Ann a _unsafeKeywordArgName :: Ident v a _unsafeKeywordArgWhitespaceRight :: [Whitespace] _argExpr :: Expr v a
StarArg
Fields _argAnn :: Ann a _unsafeStarArgWhitespace :: [Whitespace] _argExpr :: Expr v a
DoubleStarArg
Fields _argAnn :: Ann a _unsafeDoubleStarArgWhitespace :: [Whitespace] _argExpr :: Expr v a

Instances

Validated Arg #
Instance details Defined in Language.Python.Syntax.Expr Methods unvalidated :: (Contravariant f, Functor f) => (Arg [] a -> f (Arg [] a)) -> Arg v a -> f (Arg v a) #
HasExprs Arg #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> Arg v a -> f (Arg [] a) #
HasIdents Arg #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> Arg v a -> f (Arg [] a) #
KeywordSyntax Arg #	See `call_`
Instance details Defined in Language.Python.DSL Methods k_ :: Raw Ident -> Raw Expr -> Raw Arg #
DoubleStarSyntax Expr Arg #	See `call_`
Instance details Defined in Language.Python.DSL Methods ss_ :: Raw Expr -> Raw Arg #
StarSyntax Expr Arg #	See `call_`
Instance details Defined in Language.Python.DSL Methods s_ :: Raw Expr -> Raw Arg #
PositionalSyntax Arg Expr #	See `call_`
Instance details Defined in Language.Python.DSL Methods p_ :: Raw Expr -> Raw Arg #
Functor (Arg v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> Arg v a -> Arg v b # (<$) :: a -> Arg v b -> Arg v a #
Foldable (Arg v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => Arg v m -> m # foldMap :: Monoid m => (a -> m) -> Arg v a -> m # foldr :: (a -> b -> b) -> b -> Arg v a -> b # foldr' :: (a -> b -> b) -> b -> Arg v a -> b # foldl :: (b -> a -> b) -> b -> Arg v a -> b # foldl' :: (b -> a -> b) -> b -> Arg v a -> b # foldr1 :: (a -> a -> a) -> Arg v a -> a # foldl1 :: (a -> a -> a) -> Arg v a -> a # toList :: Arg v a -> [a] # null :: Arg v a -> Bool # length :: Arg v a -> Int # elem :: Eq a => a -> Arg v a -> Bool # maximum :: Ord a => Arg v a -> a # minimum :: Ord a => Arg v a -> a # sum :: Num a => Arg v a -> a # product :: Num a => Arg v a -> a #
Traversable (Arg v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> Arg v a -> f (Arg v b) # sequenceA :: Applicative f => Arg v (f a) -> f (Arg v a) # mapM :: Monad m => (a -> m b) -> Arg v a -> m (Arg v b) # sequence :: Monad m => Arg v (m a) -> m (Arg v a) #
HasAnn (Arg v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> Arg v a -> f (Arg v a) #
Eq a => Eq (Arg v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: Arg v a -> Arg v a -> Bool # (/=) :: Arg v a -> Arg v a -> Bool #
Show a => Show (Arg v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> Arg v a -> ShowS # show :: Arg v a -> String # showList :: [Arg v a] -> ShowS #
IsString (Arg ([] :: [*]) ()) #
Instance details Defined in Language.Python.Syntax.Expr Methods fromString :: String -> Arg [] () #
Generic (Arg v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (Arg v a) :: * -> * # Methods from :: Arg v a -> Rep (Arg v a) x # to :: Rep (Arg v a) x -> Arg v a #
HasNewlines (Arg v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (Arg v a) Newline #
type Rep (Arg v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (Arg v a) = D1 (MetaData "Arg" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) ((C1 (MetaCons "PositionalArg" PrefixI True) (S1 (MetaSel (Just "_argAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_argExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :+: C1 (MetaCons "KeywordArg" PrefixI True) ((S1 (MetaSel (Just "_argAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeKeywordArgName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ident v a))) :: (S1 (MetaSel (Just "_unsafeKeywordArgWhitespaceRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_argExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))))) :+: (C1 (MetaCons "StarArg" PrefixI True) (S1 (MetaSel (Just "_argAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeStarArgWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_argExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))) :+: C1 (MetaCons "DoubleStarArg" PrefixI True) (S1 (MetaSel (Just "_argAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeDoubleStarArgWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_argExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))))))

argExpr :: Lens (Arg v a) (Arg '[] a) (Expr v a) (Expr '[] a) #

Lens on the Python expression which is passed as the argument

Comprehension expressions

https://docs.python.org/3/reference/expressions.html#grammar-token-comprehension

data Comprehension e (v :: [*]) a #

A Python for comprehension, such as

x for y in z

Constructors

Comprehension (Ann a) (e v a) (CompFor v a) [Either (CompFor v a) (CompIf v a)]

expr comp_for (comp_for | comp_if)*

Instances

HasIdents e => HasIdents (Comprehension e) #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> Comprehension e v a -> f (Comprehension e [] a) #
Functor (e v) => Functor (Comprehension e v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> Comprehension e v a -> Comprehension e v b # (<$) :: a -> Comprehension e v b -> Comprehension e v a #
Foldable (e v) => Foldable (Comprehension e v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => Comprehension e v m -> m # foldMap :: Monoid m => (a -> m) -> Comprehension e v a -> m # foldr :: (a -> b -> b) -> b -> Comprehension e v a -> b # foldr' :: (a -> b -> b) -> b -> Comprehension e v a -> b # foldl :: (b -> a -> b) -> b -> Comprehension e v a -> b # foldl' :: (b -> a -> b) -> b -> Comprehension e v a -> b # foldr1 :: (a -> a -> a) -> Comprehension e v a -> a # foldl1 :: (a -> a -> a) -> Comprehension e v a -> a # toList :: Comprehension e v a -> [a] # null :: Comprehension e v a -> Bool # length :: Comprehension e v a -> Int # elem :: Eq a => a -> Comprehension e v a -> Bool # maximum :: Ord a => Comprehension e v a -> a # minimum :: Ord a => Comprehension e v a -> a # sum :: Num a => Comprehension e v a -> a # product :: Num a => Comprehension e v a -> a #
Traversable (e v) => Traversable (Comprehension e v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> Comprehension e v a -> f (Comprehension e v b) # sequenceA :: Applicative f => Comprehension e v (f a) -> f (Comprehension e v a) # mapM :: Monad m => (a -> m b) -> Comprehension e v a -> m (Comprehension e v b) # sequence :: Monad m => Comprehension e v (m a) -> m (Comprehension e v a) #
HasAnn (Comprehension e v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> Comprehension e v a -> f (Comprehension e v a) #
(Eq a, Eq (e v a)) => Eq (Comprehension e v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: Comprehension e v a -> Comprehension e v a -> Bool # (/=) :: Comprehension e v a -> Comprehension e v a -> Bool #
(Show a, Show (e v a)) => Show (Comprehension e v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> Comprehension e v a -> ShowS # show :: Comprehension e v a -> String # showList :: [Comprehension e v a] -> ShowS #
Generic (Comprehension e v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (Comprehension e v a) :: * -> * # Methods from :: Comprehension e v a -> Rep (Comprehension e v a) x # to :: Rep (Comprehension e v a) x -> Comprehension e v a #
HasTrailingWhitespace (Comprehension e v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (Comprehension e v a) [Whitespace] #
HasNewlines (e v a) => HasNewlines (Comprehension e v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (Comprehension e v a) Newline #
type Rep (Comprehension e v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (Comprehension e v a) = D1 (MetaData "Comprehension" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) (C1 (MetaCons "Comprehension" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (e v a))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CompFor v a)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Either (CompFor v a) (CompIf v a)]))))

data CompIf (v :: [*]) a #

A condition inside a comprehension, e.g. [x for x in xs if even(x)]

Constructors

CompIf (Ann a) [Whitespace] (Expr v a)

Instances

HasIdents CompIf #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> CompIf v a -> f (CompIf [] a) #
Functor (CompIf v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> CompIf v a -> CompIf v b # (<$) :: a -> CompIf v b -> CompIf v a #
Foldable (CompIf v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => CompIf v m -> m # foldMap :: Monoid m => (a -> m) -> CompIf v a -> m # foldr :: (a -> b -> b) -> b -> CompIf v a -> b # foldr' :: (a -> b -> b) -> b -> CompIf v a -> b # foldl :: (b -> a -> b) -> b -> CompIf v a -> b # foldl' :: (b -> a -> b) -> b -> CompIf v a -> b # foldr1 :: (a -> a -> a) -> CompIf v a -> a # foldl1 :: (a -> a -> a) -> CompIf v a -> a # toList :: CompIf v a -> [a] # null :: CompIf v a -> Bool # length :: CompIf v a -> Int # elem :: Eq a => a -> CompIf v a -> Bool # maximum :: Ord a => CompIf v a -> a # minimum :: Ord a => CompIf v a -> a # sum :: Num a => CompIf v a -> a # product :: Num a => CompIf v a -> a #
Traversable (CompIf v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> CompIf v a -> f (CompIf v b) # sequenceA :: Applicative f => CompIf v (f a) -> f (CompIf v a) # mapM :: Monad m => (a -> m b) -> CompIf v a -> m (CompIf v b) # sequence :: Monad m => CompIf v (m a) -> m (CompIf v a) #
HasAnn (CompIf v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> CompIf v a -> f (CompIf v a) #
Eq a => Eq (CompIf v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: CompIf v a -> CompIf v a -> Bool # (/=) :: CompIf v a -> CompIf v a -> Bool #
Show a => Show (CompIf v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> CompIf v a -> ShowS # show :: CompIf v a -> String # showList :: [CompIf v a] -> ShowS #
Generic (CompIf v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (CompIf v a) :: * -> * # Methods from :: CompIf v a -> Rep (CompIf v a) x # to :: Rep (CompIf v a) x -> CompIf v a #
HasTrailingWhitespace (CompIf v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (CompIf v a) [Whitespace] #
HasNewlines (CompIf v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (CompIf v a) Newline #
type Rep (CompIf v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (CompIf v a) = D1 (MetaData "CompIf" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) (C1 (MetaCons "CompIf" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))))

data CompFor (v :: [*]) a #

A nested comprehesion, e.g. [(x, y) for x in xs for y in ys]

Constructors

CompFor (Ann a) [Whitespace] (Expr v a) [Whitespace] (Expr v a)

Instances

HasIdents CompFor #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> CompFor v a -> f (CompFor [] a) #
Functor (CompFor v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> CompFor v a -> CompFor v b # (<$) :: a -> CompFor v b -> CompFor v a #
Foldable (CompFor v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => CompFor v m -> m # foldMap :: Monoid m => (a -> m) -> CompFor v a -> m # foldr :: (a -> b -> b) -> b -> CompFor v a -> b # foldr' :: (a -> b -> b) -> b -> CompFor v a -> b # foldl :: (b -> a -> b) -> b -> CompFor v a -> b # foldl' :: (b -> a -> b) -> b -> CompFor v a -> b # foldr1 :: (a -> a -> a) -> CompFor v a -> a # foldl1 :: (a -> a -> a) -> CompFor v a -> a # toList :: CompFor v a -> [a] # null :: CompFor v a -> Bool # length :: CompFor v a -> Int # elem :: Eq a => a -> CompFor v a -> Bool # maximum :: Ord a => CompFor v a -> a # minimum :: Ord a => CompFor v a -> a # sum :: Num a => CompFor v a -> a # product :: Num a => CompFor v a -> a #
Traversable (CompFor v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> CompFor v a -> f (CompFor v b) # sequenceA :: Applicative f => CompFor v (f a) -> f (CompFor v a) # mapM :: Monad m => (a -> m b) -> CompFor v a -> m (CompFor v b) # sequence :: Monad m => CompFor v (m a) -> m (CompFor v a) #
HasAnn (CompFor v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> CompFor v a -> f (CompFor v a) #
ForSyntax (Raw CompFor) In #	`for_` :: `Raw` `In` -> `Raw` `CompFor` `>>>` comp_ (var_ "a") (for_ $ var_ "a" `in_` var_ "b") []a for a in b
Instance details Defined in Language.Python.DSL Methods for_ :: Raw In -> Raw CompFor #
Eq a => Eq (CompFor v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: CompFor v a -> CompFor v a -> Bool # (/=) :: CompFor v a -> CompFor v a -> Bool #
Show a => Show (CompFor v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> CompFor v a -> ShowS # show :: CompFor v a -> String # showList :: [CompFor v a] -> ShowS #
Generic (CompFor v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (CompFor v a) :: * -> * # Methods from :: CompFor v a -> Rep (CompFor v a) x # to :: Rep (CompFor v a) x -> CompFor v a #
HasTrailingWhitespace (CompFor v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (CompFor v a) [Whitespace] #
HasNewlines (CompFor v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (CompFor v a) Newline #
type Rep (CompFor v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (CompFor v a) = D1 (MetaData "CompFor" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) (C1 (MetaCons "CompFor" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace])) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))))))

Collection items

data DictItem (v :: [*]) a #

a : b or **a

Used to construct dictionaries, e.g. { 1: a, 2: b, **c }

https://docs.python.org/3/reference/expressions.html#dictionary-displays

Constructors

DictItem
Fields _dictItemAnn :: Ann a _unsafeDictItemKey :: Expr v a _unsafeDictItemColon :: Colon _unsafeDictItemValue :: Expr v a
DictUnpack
Fields _dictItemAnn :: Ann a _unsafeDictItemUnpackWhitespace :: [Whitespace] _unsafeDictItemUnpackValue :: Expr v a

Instances

Validated DictItem #
Instance details Defined in Language.Python.Syntax.Expr Methods unvalidated :: (Contravariant f, Functor f) => (DictItem [] a -> f (DictItem [] a)) -> DictItem v a -> f (DictItem v a) #
HasIdents DictItem #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> DictItem v a -> f (DictItem [] a) #
DoubleStarSyntax Expr DictItem #	See `dict_`
Instance details Defined in Language.Python.DSL Methods ss_ :: Raw Expr -> Raw DictItem #
ColonSyntax Expr DictItem #	Constructing dictionary items (`.:`) :: `Raw` `Expr` -> `Raw` `Expr` -> `Raw` `DictItem`
Instance details Defined in Language.Python.DSL Methods (.:) :: Raw Expr -> Raw Expr -> Raw DictItem #
Functor (DictItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> DictItem v a -> DictItem v b # (<$) :: a -> DictItem v b -> DictItem v a #
Foldable (DictItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => DictItem v m -> m # foldMap :: Monoid m => (a -> m) -> DictItem v a -> m # foldr :: (a -> b -> b) -> b -> DictItem v a -> b # foldr' :: (a -> b -> b) -> b -> DictItem v a -> b # foldl :: (b -> a -> b) -> b -> DictItem v a -> b # foldl' :: (b -> a -> b) -> b -> DictItem v a -> b # foldr1 :: (a -> a -> a) -> DictItem v a -> a # foldl1 :: (a -> a -> a) -> DictItem v a -> a # toList :: DictItem v a -> [a] # null :: DictItem v a -> Bool # length :: DictItem v a -> Int # elem :: Eq a => a -> DictItem v a -> Bool # maximum :: Ord a => DictItem v a -> a # minimum :: Ord a => DictItem v a -> a # sum :: Num a => DictItem v a -> a # product :: Num a => DictItem v a -> a #
Traversable (DictItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> DictItem v a -> f (DictItem v b) # sequenceA :: Applicative f => DictItem v (f a) -> f (DictItem v a) # mapM :: Monad m => (a -> m b) -> DictItem v a -> m (DictItem v b) # sequence :: Monad m => DictItem v (m a) -> m (DictItem v a) #
HasAnn (DictItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> DictItem v a -> f (DictItem v a) #
Eq a => Eq (DictItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: DictItem v a -> DictItem v a -> Bool # (/=) :: DictItem v a -> DictItem v a -> Bool #
Show a => Show (DictItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> DictItem v a -> ShowS # show :: DictItem v a -> String # showList :: [DictItem v a] -> ShowS #
Generic (DictItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (DictItem v a) :: * -> * # Methods from :: DictItem v a -> Rep (DictItem v a) x # to :: Rep (DictItem v a) x -> DictItem v a #
HasTrailingWhitespace (DictItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (DictItem v a) [Whitespace] #
HasNewlines (DictItem v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (DictItem v a) Newline #
type Rep (DictItem v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (DictItem v a) = D1 (MetaData "DictItem" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) (C1 (MetaCons "DictItem" PrefixI True) ((S1 (MetaSel (Just "_dictItemAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeDictItemKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :: (S1 (MetaSel (Just "_unsafeDictItemColon") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Colon) :: S1 (MetaSel (Just "_unsafeDictItemValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))) :+: C1 (MetaCons "DictUnpack" PrefixI True) (S1 (MetaSel (Just "_dictItemAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: (S1 (MetaSel (Just "_unsafeDictItemUnpackWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :*: S1 (MetaSel (Just "_unsafeDictItemUnpackValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))))

data ListItem (v :: [*]) a #

a or *a

Used to construct lists, e.g. [ 1, x, **c ]

https://docs.python.org/3/reference/expressions.html#list-displays

Constructors

ListItem
Fields _listItemAnn :: Ann a _unsafeListItemValue :: Expr v a
ListUnpack
Fields _listItemAnn :: Ann a _unsafeListUnpackParens :: [([Whitespace], [Whitespace])] _unsafeListUnpackWhitespace :: [Whitespace] _unsafeListUnpackValue :: Expr v a

Instances

Validated ListItem #
Instance details Defined in Language.Python.Syntax.Expr Methods unvalidated :: (Contravariant f, Functor f) => (ListItem [] a -> f (ListItem [] a)) -> ListItem v a -> f (ListItem v a) #
HasExprs ListItem #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> ListItem v a -> f (ListItem [] a) #
HasIdents ListItem #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> ListItem v a -> f (ListItem [] a) #
AsListItem ListItem #
Instance details Defined in Language.Python.DSL Methods li_ :: Raw ListItem -> Raw ListItem #
StarSyntax Expr ListItem #	See `list_`
Instance details Defined in Language.Python.DSL Methods s_ :: Raw Expr -> Raw ListItem #
Functor (ListItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> ListItem v a -> ListItem v b # (<$) :: a -> ListItem v b -> ListItem v a #
Foldable (ListItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => ListItem v m -> m # foldMap :: Monoid m => (a -> m) -> ListItem v a -> m # foldr :: (a -> b -> b) -> b -> ListItem v a -> b # foldr' :: (a -> b -> b) -> b -> ListItem v a -> b # foldl :: (b -> a -> b) -> b -> ListItem v a -> b # foldl' :: (b -> a -> b) -> b -> ListItem v a -> b # foldr1 :: (a -> a -> a) -> ListItem v a -> a # foldl1 :: (a -> a -> a) -> ListItem v a -> a # toList :: ListItem v a -> [a] # null :: ListItem v a -> Bool # length :: ListItem v a -> Int # elem :: Eq a => a -> ListItem v a -> Bool # maximum :: Ord a => ListItem v a -> a # minimum :: Ord a => ListItem v a -> a # sum :: Num a => ListItem v a -> a # product :: Num a => ListItem v a -> a #
Traversable (ListItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> ListItem v a -> f (ListItem v b) # sequenceA :: Applicative f => ListItem v (f a) -> f (ListItem v a) # mapM :: Monad m => (a -> m b) -> ListItem v a -> m (ListItem v b) # sequence :: Monad m => ListItem v (m a) -> m (ListItem v a) #
HasAnn (ListItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> ListItem v a -> f (ListItem v a) #
Eq a => Eq (ListItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: ListItem v a -> ListItem v a -> Bool # (/=) :: ListItem v a -> ListItem v a -> Bool #
Show a => Show (ListItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> ListItem v a -> ShowS # show :: ListItem v a -> String # showList :: [ListItem v a] -> ShowS #
Generic (ListItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (ListItem v a) :: * -> * # Methods from :: ListItem v a -> Rep (ListItem v a) x # to :: Rep (ListItem v a) x -> ListItem v a #
HasTrailingWhitespace (ListItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (ListItem v a) [Whitespace] #
HasNewlines (ListItem v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (ListItem v a) Newline #
type Rep (ListItem v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (ListItem v a) = D1 (MetaData "ListItem" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) (C1 (MetaCons "ListItem" PrefixI True) (S1 (MetaSel (Just "_listItemAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeListItemValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :+: C1 (MetaCons "ListUnpack" PrefixI True) ((S1 (MetaSel (Just "_listItemAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeListUnpackParens") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [([Whitespace], [Whitespace])])) :: (S1 (MetaSel (Just "_unsafeListUnpackWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeListUnpackValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))))

data SetItem (v :: [*]) a #

a or *a

Used to construct sets, e.g. { 1, x, **c }

https://docs.python.org/3/reference/expressions.html#set-displays

Constructors

SetItem
Fields _setItemAnn :: Ann a _unsafeSetItemValue :: Expr v a
SetUnpack
Fields _setItemAnn :: Ann a _unsafeSetUnpackParens :: [([Whitespace], [Whitespace])] _unsafeSetUnpackWhitespace :: [Whitespace] _unsafeSetUnpackValue :: Expr v a

Instances

Validated SetItem #
Instance details Defined in Language.Python.Syntax.Expr Methods unvalidated :: (Contravariant f, Functor f) => (SetItem [] a -> f (SetItem [] a)) -> SetItem v a -> f (SetItem v a) #
HasExprs SetItem #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> SetItem v a -> f (SetItem [] a) #
HasIdents SetItem #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> SetItem v a -> f (SetItem [] a) #
AsSetItem SetItem #
Instance details Defined in Language.Python.DSL Methods si_ :: Raw SetItem -> Raw SetItem #
StarSyntax Expr SetItem #	See `set_`
Instance details Defined in Language.Python.DSL Methods s_ :: Raw Expr -> Raw SetItem #
Functor (SetItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> SetItem v a -> SetItem v b # (<$) :: a -> SetItem v b -> SetItem v a #
Foldable (SetItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => SetItem v m -> m # foldMap :: Monoid m => (a -> m) -> SetItem v a -> m # foldr :: (a -> b -> b) -> b -> SetItem v a -> b # foldr' :: (a -> b -> b) -> b -> SetItem v a -> b # foldl :: (b -> a -> b) -> b -> SetItem v a -> b # foldl' :: (b -> a -> b) -> b -> SetItem v a -> b # foldr1 :: (a -> a -> a) -> SetItem v a -> a # foldl1 :: (a -> a -> a) -> SetItem v a -> a # toList :: SetItem v a -> [a] # null :: SetItem v a -> Bool # length :: SetItem v a -> Int # elem :: Eq a => a -> SetItem v a -> Bool # maximum :: Ord a => SetItem v a -> a # minimum :: Ord a => SetItem v a -> a # sum :: Num a => SetItem v a -> a # product :: Num a => SetItem v a -> a #
Traversable (SetItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> SetItem v a -> f (SetItem v b) # sequenceA :: Applicative f => SetItem v (f a) -> f (SetItem v a) # mapM :: Monad m => (a -> m b) -> SetItem v a -> m (SetItem v b) # sequence :: Monad m => SetItem v (m a) -> m (SetItem v a) #
HasAnn (SetItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> SetItem v a -> f (SetItem v a) #
Eq a => Eq (SetItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: SetItem v a -> SetItem v a -> Bool # (/=) :: SetItem v a -> SetItem v a -> Bool #
Show a => Show (SetItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> SetItem v a -> ShowS # show :: SetItem v a -> String # showList :: [SetItem v a] -> ShowS #
Generic (SetItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (SetItem v a) :: * -> * # Methods from :: SetItem v a -> Rep (SetItem v a) x # to :: Rep (SetItem v a) x -> SetItem v a #
HasTrailingWhitespace (SetItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (SetItem v a) [Whitespace] #
HasNewlines (SetItem v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (SetItem v a) Newline #
type Rep (SetItem v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (SetItem v a) = D1 (MetaData "SetItem" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) (C1 (MetaCons "SetItem" PrefixI True) (S1 (MetaSel (Just "_setItemAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeSetItemValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :+: C1 (MetaCons "SetUnpack" PrefixI True) ((S1 (MetaSel (Just "_setItemAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeSetUnpackParens") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [([Whitespace], [Whitespace])])) :: (S1 (MetaSel (Just "_unsafeSetUnpackWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeSetUnpackValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))))

data TupleItem (v :: [*]) a #

a or *a

Used to construct tuples, e.g. (1, x, **c)

Constructors

TupleItem
Fields _tupleItemAnn :: Ann a _unsafeTupleItemValue :: Expr v a
TupleUnpack
Fields _tupleItemAnn :: Ann a _unsafeTupleUnpackParens :: [([Whitespace], [Whitespace])] _unsafeTupleUnpackWhitespace :: [Whitespace] _unsafeTupleUnpackValue :: Expr v a

Instances

Validated TupleItem #
Instance details Defined in Language.Python.Syntax.Expr Methods unvalidated :: (Contravariant f, Functor f) => (TupleItem [] a -> f (TupleItem [] a)) -> TupleItem v a -> f (TupleItem v a) #
HasExprs TupleItem #
Instance details Defined in Language.Python.Syntax.Expr Methods _Exprs :: Applicative f => (Expr v a -> f (Expr [] a)) -> TupleItem v a -> f (TupleItem [] a) #
HasIdents TupleItem #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> TupleItem v a -> f (TupleItem [] a) #
AsTupleItem TupleItem #
Instance details Defined in Language.Python.DSL Methods ti_ :: Raw TupleItem -> Raw TupleItem #
StarSyntax Expr TupleItem #	See `tuple_`
Instance details Defined in Language.Python.DSL Methods s_ :: Raw Expr -> Raw TupleItem #
Functor (TupleItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> TupleItem v a -> TupleItem v b # (<$) :: a -> TupleItem v b -> TupleItem v a #
Foldable (TupleItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => TupleItem v m -> m # foldMap :: Monoid m => (a -> m) -> TupleItem v a -> m # foldr :: (a -> b -> b) -> b -> TupleItem v a -> b # foldr' :: (a -> b -> b) -> b -> TupleItem v a -> b # foldl :: (b -> a -> b) -> b -> TupleItem v a -> b # foldl' :: (b -> a -> b) -> b -> TupleItem v a -> b # foldr1 :: (a -> a -> a) -> TupleItem v a -> a # foldl1 :: (a -> a -> a) -> TupleItem v a -> a # toList :: TupleItem v a -> [a] # null :: TupleItem v a -> Bool # length :: TupleItem v a -> Int # elem :: Eq a => a -> TupleItem v a -> Bool # maximum :: Ord a => TupleItem v a -> a # minimum :: Ord a => TupleItem v a -> a # sum :: Num a => TupleItem v a -> a # product :: Num a => TupleItem v a -> a #
Traversable (TupleItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> TupleItem v a -> f (TupleItem v b) # sequenceA :: Applicative f => TupleItem v (f a) -> f (TupleItem v a) # mapM :: Monad m => (a -> m b) -> TupleItem v a -> m (TupleItem v b) # sequence :: Monad m => TupleItem v (m a) -> m (TupleItem v a) #
HasAnn (TupleItem v) #
Instance details Defined in Language.Python.Syntax.Expr Methods annot :: Functor f => (Ann a -> f (Ann a)) -> TupleItem v a -> f (TupleItem v a) #
Eq a => Eq (TupleItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: TupleItem v a -> TupleItem v a -> Bool # (/=) :: TupleItem v a -> TupleItem v a -> Bool #
Show a => Show (TupleItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> TupleItem v a -> ShowS # show :: TupleItem v a -> String # showList :: [TupleItem v a] -> ShowS #
Generic (TupleItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (TupleItem v a) :: * -> * # Methods from :: TupleItem v a -> Rep (TupleItem v a) x # to :: Rep (TupleItem v a) x -> TupleItem v a #
HasTrailingWhitespace (TupleItem v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (TupleItem v a) [Whitespace] #
HasNewlines (TupleItem v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (TupleItem v a) Newline #
type Rep (TupleItem v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (TupleItem v a) = D1 (MetaData "TupleItem" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) (C1 (MetaCons "TupleItem" PrefixI True) (S1 (MetaSel (Just "_tupleItemAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeTupleItemValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :+: C1 (MetaCons "TupleUnpack" PrefixI True) ((S1 (MetaSel (Just "_tupleItemAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann a)) :: S1 (MetaSel (Just "_unsafeTupleUnpackParens") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [([Whitespace], [Whitespace])])) :: (S1 (MetaSel (Just "_unsafeTupleUnpackWhitespace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Whitespace]) :: S1 (MetaSel (Just "_unsafeTupleUnpackValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a)))))

Subscripts

data Subscript (v :: [*]) a #

Syntax for things that can be used as subscripts (inside the square brackets)

e.g.

a[b]

a[:]

a[b:]

a[:b]

a[b:c]

a[b:c:d]

https://docs.python.org/3/reference/expressions.html#subscriptions

Constructors

SubscriptExpr (Expr v a)
SubscriptSlice (Maybe (Expr v a)) Colon (Maybe (Expr v a)) (Maybe (Colon, Maybe (Expr v a)))

Instances

HasIdents Subscript #
Instance details Defined in Language.Python.Optics.Idents Methods _Idents :: Applicative f => (Ident v a -> f (Ident [] a)) -> Subscript v a -> f (Subscript [] a) #
Functor (Subscript v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fmap :: (a -> b) -> Subscript v a -> Subscript v b # (<$) :: a -> Subscript v b -> Subscript v a #
Foldable (Subscript v) #
Instance details Defined in Language.Python.Syntax.Expr Methods fold :: Monoid m => Subscript v m -> m # foldMap :: Monoid m => (a -> m) -> Subscript v a -> m # foldr :: (a -> b -> b) -> b -> Subscript v a -> b # foldr' :: (a -> b -> b) -> b -> Subscript v a -> b # foldl :: (b -> a -> b) -> b -> Subscript v a -> b # foldl' :: (b -> a -> b) -> b -> Subscript v a -> b # foldr1 :: (a -> a -> a) -> Subscript v a -> a # foldl1 :: (a -> a -> a) -> Subscript v a -> a # toList :: Subscript v a -> [a] # null :: Subscript v a -> Bool # length :: Subscript v a -> Int # elem :: Eq a => a -> Subscript v a -> Bool # maximum :: Ord a => Subscript v a -> a # minimum :: Ord a => Subscript v a -> a # sum :: Num a => Subscript v a -> a # product :: Num a => Subscript v a -> a #
Traversable (Subscript v) #
Instance details Defined in Language.Python.Syntax.Expr Methods traverse :: Applicative f => (a -> f b) -> Subscript v a -> f (Subscript v b) # sequenceA :: Applicative f => Subscript v (f a) -> f (Subscript v a) # mapM :: Monad m => (a -> m b) -> Subscript v a -> m (Subscript v b) # sequence :: Monad m => Subscript v (m a) -> m (Subscript v a) #
Eq a => Eq (Subscript v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods (==) :: Subscript v a -> Subscript v a -> Bool # (/=) :: Subscript v a -> Subscript v a -> Bool #
Show a => Show (Subscript v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods showsPrec :: Int -> Subscript v a -> ShowS # show :: Subscript v a -> String # showList :: [Subscript v a] -> ShowS #
Generic (Subscript v a) #
Instance details Defined in Language.Python.Syntax.Expr Associated Types type Rep (Subscript v a) :: * -> * # Methods from :: Subscript v a -> Rep (Subscript v a) x # to :: Rep (Subscript v a) x -> Subscript v a #
HasTrailingWhitespace (Subscript v a) #
Instance details Defined in Language.Python.Syntax.Expr Methods trailingWhitespace :: Lens' (Subscript v a) [Whitespace] #
HasNewlines (Subscript v a) #
Instance details Defined in Language.Python.Optics.Newlines Methods _Newlines :: Traversal' (Subscript v a) Newline #
type Rep (Subscript v a) #
Instance details Defined in Language.Python.Syntax.Expr type Rep (Subscript v a) = D1 (MetaData "Subscript" "Language.Python.Syntax.Expr" "hpython-0.1.0.1-inplace" False) (C1 (MetaCons "SubscriptExpr" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Expr v a))) :+: C1 (MetaCons "SubscriptSlice" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Expr v a))) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Colon)) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Expr v a))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Colon, Maybe (Expr v a)))))))