Language.Python.Common.AST

language-python-0.2: Parsing and pretty printing of Python code.

Language.Python.Common.AST

Portability	ghc
Stability	experimental
Maintainer	bjpop@csse.unimelb.edu.au

Contents

Annotation projection
Modules
Identifiers and dotted names
Statements, suites, parameters, decorators and assignment operators
Expressions, operators, arguments and slices
Imports
Exceptions
Comprehensions

Description

Representation of the Python abstract syntax tree (AST). The representation is a superset of versions 2.x and 3.x of Python. In many cases they are identical. The documentation in this module indicates where they are different.

All the data types have a (polymorphic) parameter which allows the AST to be annotated by an arbitrary type (for example source locations). Specialised instances of the types are provided for source spans. For example Module a is the type of modules, and ModuleSpan is the type of modules annoted with source span information.

Note: there are cases where the AST is more liberal than the formal grammar of the language. Therefore some care must be taken when constructing Python programs using the raw AST.

Synopsis

class Annotated t where

annot :: t annot -> annot

newtype Module annot = Module [Statement annot]

type ModuleSpan = Module SrcSpan

data Ident annot = Ident {

ident_string :: !String

ident_annot :: annot

}

type IdentSpan = Ident SrcSpan

type DottedName annot = [Ident annot]

type DottedNameSpan = DottedName SrcSpan

data Statement annot

import_items :: [ImportItem annot]

stmt_annot :: annot

}

from_module :: ImportRelative annot

from_items :: FromItems annot

stmt_annot :: annot

}

while_cond :: Expr annot

while_body :: Suite annot

while_else :: Suite annot

stmt_annot :: annot

}

| For {

for_targets :: [Expr annot]

for_generator :: Expr annot

for_body :: Suite annot

for_else :: Suite annot

stmt_annot :: annot

}

| Fun {

fun_name :: Ident annot

fun_args :: [Parameter annot]

fun_result_annotation :: Maybe (Expr annot)

fun_body :: Suite annot

stmt_annot :: annot

}

class_name :: Ident annot

class_args :: [Argument annot]

class_body :: Suite annot

stmt_annot :: annot

}

| Conditional {

cond_guards :: [(Expr annot, Suite annot)]

cond_else :: Suite annot

stmt_annot :: annot

}

assign_to :: [Expr annot]

assign_expr :: Expr annot

stmt_annot :: annot

}

| AugmentedAssign {

aug_assign_to :: Expr annot

aug_assign_op :: AssignOp annot

aug_assign_expr :: Expr annot

stmt_annot :: annot

}

decorated_decorators :: [Decorator annot]

decorated_def :: Statement annot

stmt_annot :: annot

}

return_expr :: Maybe (Expr annot)

stmt_annot :: annot

}

| Try {

try_body :: Suite annot

try_excepts :: [Handler annot]

try_else :: Suite annot

try_finally :: Suite annot

stmt_annot :: annot

}

raise_expr :: RaiseExpr annot

stmt_annot :: annot

}

| With {

with_context :: [(Expr annot, Maybe (Expr annot))]

with_body :: Suite annot

stmt_annot :: annot

}

| Pass {

stmt_annot :: annot

}

stmt_annot :: annot

}

stmt_annot :: annot

}

del_exprs :: [Expr annot]

stmt_annot :: annot

}

stmt_expr :: Expr annot

stmt_annot :: annot

}

global_vars :: [Ident annot]

stmt_annot :: annot

}

nonLocal_vars :: [Ident annot]

stmt_annot :: annot

}

assert_exprs :: [Expr annot]

stmt_annot :: annot

}

print_chevron :: Bool

print_exprs :: [Expr annot]

print_trailing_comma :: Bool

stmt_annot :: annot

}

| Exec {

exec_expr :: Expr annot

exec_globals_locals :: Maybe (Expr annot, Maybe (Expr annot))

stmt_annot :: annot

}

type StatementSpan = Statement SrcSpan

type Suite annot = [Statement annot]

type SuiteSpan = Suite SrcSpan

data Parameter annot

param_name :: Ident annot

param_py_annotation :: Maybe (Expr annot)

param_default :: Maybe (Expr annot)

param_annot :: annot

}

param_name :: Ident annot

param_py_annotation :: Maybe (Expr annot)

param_annot :: annot

}

| VarArgsKeyword {

param_name :: Ident annot

param_py_annotation :: Maybe (Expr annot)

param_annot :: annot

}

| EndPositional {

param_annot :: annot

}

| UnPackTuple {

param_unpack_tuple :: ParamTuple annot

param_default :: Maybe (Expr annot)

param_annot :: annot

}

type ParameterSpan = Parameter SrcSpan

data ParamTuple annot

= ParamTupleName {

param_tuple_name :: Ident annot

param_tuple_annot :: annot

}

param_tuple :: [ParamTuple annot]

param_tuple_annot :: annot

}

type ParamTupleSpan = ParamTuple SrcSpan

data Decorator annot = Decorator {

decorator_name :: DottedName annot

decorator_args :: [Argument annot]

decorator_annot :: annot

}

type DecoratorSpan = Decorator SrcSpan

data AssignOp annot

assignOp_annot :: annot

}

| MinusAssign {

assignOp_annot :: annot

}

assignOp_annot :: annot

}

assignOp_annot :: annot

}

assignOp_annot :: annot

}

assignOp_annot :: annot

}

| BinAndAssign {

assignOp_annot :: annot

}

| BinOrAssign {

assignOp_annot :: annot

}

| BinXorAssign {

assignOp_annot :: annot

}

| LeftShiftAssign {

assignOp_annot :: annot

}

| RightShiftAssign {

assignOp_annot :: annot

}

| FloorDivAssign {

assignOp_annot :: annot

}

type AssignOpSpan = AssignOp SrcSpan

data Expr annot

= Var {

var_ident :: Ident annot

expr_annot :: annot

}

| Int {

int_value :: Integer

expr_literal :: String

expr_annot :: annot

}

int_value :: Integer

expr_literal :: String

expr_annot :: annot

}

float_value :: Double

expr_literal :: String

expr_annot :: annot

}

imaginary_value :: Double

expr_literal :: String

expr_annot :: annot

}

| Bool {

bool_value :: Bool

expr_annot :: annot

}

| None {

expr_annot :: annot

}

expr_annot :: annot

}

| ByteStrings {

byte_string_strings :: [String]

expr_annot :: annot

}

strings_strings :: [String]

expr_annot :: annot

}

| Call {

call_fun :: Expr annot

call_args :: [Argument annot]

expr_annot :: annot

}

subscriptee :: Expr annot

subscript_exprs :: [Expr annot]

expr_annot :: annot

}

slicee :: Expr annot

slices :: [Slice annot]

expr_annot :: annot

}

ce_true_branch :: Expr annot

ce_condition :: Expr annot

ce_false_branch :: Expr annot

expr_annot :: annot

}

operator :: Op annot

left_op_arg :: Expr annot

right_op_arg :: Expr annot

expr_annot :: annot

}

operator :: Op annot

op_arg :: Expr annot

expr_annot :: annot

}

lambda_args :: [Parameter annot]

lambda_body :: Expr annot

expr_annot :: annot

}

tuple_exprs :: [Expr annot]

expr_annot :: annot

}

yield_expr :: Maybe (Expr annot)

expr_annot :: annot

}

gen_comprehension :: Comprehension (Expr annot) annot

expr_annot :: annot

}

list_comprehension :: Comprehension (Expr annot) annot

expr_annot :: annot

}

| List {

list_exprs :: [Expr annot]

expr_annot :: annot

}

dict_mappings :: [(Expr annot, Expr annot)]

expr_annot :: annot

}

dict_comprehension :: Comprehension (Expr annot, Expr annot) annot

expr_annot :: annot

}

| Set {

set_exprs :: [Expr annot]

expr_annot :: annot

}

set_comprehension :: Comprehension (Expr annot) annot

expr_annot :: annot

}

starred_expr :: Expr annot

expr_annot :: annot

}

paren_expr :: Expr annot

expr_annot :: annot

}

| StringConversion {

backquoted_expr :: Expr annot

expr_anot :: annot

}

type ExprSpan = Expr SrcSpan

data Op annot

= And {

op_annot :: annot

}

| Or {

op_annot :: annot

}

| Not {

op_annot :: annot

}

op_annot :: annot

}

op_annot :: annot

}

| GreaterThan {

op_annot :: annot

}

op_annot :: annot

}

| GreaterThanEquals {

op_annot :: annot

}

| LessThanEquals {

op_annot :: annot

}

op_annot :: annot

}

| NotEqualsV2 {

op_annot :: annot

}

| In {

op_annot :: annot

}

| Is {

op_annot :: annot

}

op_annot :: annot

}

op_annot :: annot

}

op_annot :: annot

}

| Xor {

op_annot :: annot

}

op_annot :: annot

}

op_annot :: annot

}

op_annot :: annot

}

op_annot :: annot

}

| Plus {

op_annot :: annot

}

op_annot :: annot

}

op_annot :: annot

}

| FloorDivide {

op_annot :: annot

}

op_annot :: annot

}

op_annot :: annot

}

| Dot {

op_annot :: annot

}

type OpSpan = Op SrcSpan

data Argument annot

arg_expr :: Expr annot

arg_annot :: annot

}

| ArgVarArgsPos {

arg_expr :: Expr annot

arg_annot :: annot

}

| ArgVarArgsKeyword {

arg_expr :: Expr annot

arg_annot :: annot

}

arg_keyword :: Ident annot

arg_expr :: Expr annot

arg_annot :: annot

}

type ArgumentSpan = Argument SrcSpan

data Slice annot

= SliceProper {

slice_lower :: Maybe (Expr annot)

slice_upper :: Maybe (Expr annot)

slice_stride :: Maybe (Maybe (Expr annot))

slice_annot :: annot

}

slice_expr :: Expr annot

slice_annot :: annot

}

| SliceEllipsis {

slice_annot :: annot

}

type SliceSpan = Slice SrcSpan

data ImportItem annot = ImportItem {

import_item_name :: DottedName annot

import_as_name :: Maybe (Ident annot)

import_item_annot :: annot

}

type ImportItemSpan = ImportItem SrcSpan

data FromItem annot = FromItem {

from_item_name :: Ident annot

from_as_name :: Maybe (Ident annot)

from_item_annot :: annot

}

type FromItemSpan = FromItem SrcSpan

data FromItems annot

= ImportEverything {

from_items_annot :: annot

}

from_items_items :: [FromItem annot]

from_items_annot :: annot

}

type FromItemsSpan = FromItems SrcSpan

data ImportRelative annot = ImportRelative {

import_relative_dots :: Int

import_relative_module :: Maybe (DottedName annot)

import_relative_annot :: annot

}

type ImportRelativeSpan = ImportRelative SrcSpan

data Handler annot = Handler {

handler_clause :: ExceptClause annot

handler_suite :: Suite annot

handler_annot :: annot

}

type HandlerSpan = Handler SrcSpan

data ExceptClause annot = ExceptClause {

except_clause :: Maybe (Expr annot, Maybe (Expr annot))

except_clause_annot :: annot

}

type ExceptClauseSpan = ExceptClause SrcSpan

data RaiseExpr annot

= RaiseV3 (Maybe (Expr annot, Maybe (Expr annot)))

| RaiseV2 (Maybe (Expr annot, Maybe (Expr annot, Maybe (Expr annot))))

type RaiseExprSpan = RaiseExpr SrcSpan

data Comprehension e annot = Comprehension {

comprehension_expr :: e

comprehension_for :: CompFor annot

comprehension_annot :: annot

}

type ComprehensionSpan e = Comprehension e SrcSpan

data CompFor annot = CompFor {

comp_for_exprs :: [Expr annot]

comp_in_expr :: Expr annot

comp_for_iter :: Maybe (CompIter annot)

comp_for_annot :: annot

}

type CompForSpan = CompFor SrcSpan

data CompIf annot = CompIf {

comp_if :: Expr annot

comp_if_iter :: Maybe (CompIter annot)

comp_if_annot :: annot

}

type CompIfSpan = CompIf SrcSpan

data CompIter annot

comp_iter_for :: CompFor annot

comp_iter_annot :: annot

}

comp_iter_if :: CompIf annot

comp_iter_annot :: annot

}

type CompIterSpan = CompIter SrcSpan

Annotation projection

class Annotated t where

Convenient access to annotations in annotated types.

Methods

annot :: t annot -> annot

Given an annotated type, project out its annotation value.

show/hide

Instances

newtype Module annot

A module (Python source file).

Version 2.6 http://www.python.org/doc/2.6/reference/toplevel_components.html
Version 3.1 http://www.python.org/doc/3.1/reference/toplevel_components.html

Constructors

Module [Statement annot]

A module is just a sequence of top-level statements.

show/hide

Instances

Typeable1 Module

Eq annot => Eq (Module annot)

Data annot => Data (Module annot)

Ord annot => Ord (Module annot)

Show annot => Show (Module annot)

Pretty (Module a)

type ModuleSpan = Module SrcSpan

Identifiers and dotted names

data Ident annot

Identifier.

Constructors

Ident

ident_string :: !String
ident_annot :: annot

show/hide

Instances

Typeable1 Ident

Annotated Ident

Eq annot => Eq (Ident annot)

Data annot => Data (Ident annot)

Ord annot => Ord (Ident annot)

Show annot => Show (Ident annot)

Pretty (Ident a)

type IdentSpan = Ident SrcSpan

type DottedName annot = [Ident annot]

A compound name constructed with the dot operator.

type DottedNameSpan = DottedName SrcSpan

Statements, suites, parameters, decorators and assignment operators

data Statement annot

Statements.

Simple statements:
Version 2.6 http://www.python.org/doc/2.6/reference/simple_stmts.html
Version 3.1 http://www.python.org/doc/3.1/reference/simple_stmts.html
Compound statements:
Version 2.6 http://www.python.org/doc/2.6/reference/compound_stmts.html
Version 3.1 http://www.python.org/doc/3.1/reference/compound_stmts.html

Constructors

Import

Import statement.

import_items :: [ImportItem annot]	Items to import.
stmt_annot :: annot

FromImport

From ... import statement.

from_module :: ImportRelative annot	Module to import from.
from_items :: FromItems annot	Items to import.
stmt_annot :: annot

While

While loop.

while_cond :: Expr annot	Loop condition.
while_body :: Suite annot	Loop body.
while_else :: Suite annot	Else clause.
stmt_annot :: annot

For

For loop.

for_targets :: [Expr annot]	Loop variables.
for_generator :: Expr annot	Loop generator.
for_body :: Suite annot	Loop body
for_else :: Suite annot	Else clause.
stmt_annot :: annot

Fun

Function definition.

fun_name :: Ident annot	Function name.
fun_args :: [Parameter annot]	Function parameter list.
fun_result_annotation :: Maybe (Expr annot)	Optional result annotation.
fun_body :: Suite annot	Function body.
stmt_annot :: annot

Class

Class definition.

class_name :: Ident annot	Class name.
class_args :: [Argument annot]	Class argument list. In version 2.x this is only ArgExprs.
class_body :: Suite annot	Class body.
stmt_annot :: annot

Conditional

Conditional statement (if-elif-else).

cond_guards :: [(Expr annot, Suite annot)]	Sequence of if-elif conditional clauses.
cond_else :: Suite annot	Possibly empty unconditional else clause.
stmt_annot :: annot

Assign

Assignment statement.

assign_to :: [Expr annot]	Entity to assign to.
assign_expr :: Expr annot	Expression to evaluate.
stmt_annot :: annot

AugmentedAssign

Augmented assignment statement.

aug_assign_to :: Expr annot	Entity to assign to.
aug_assign_op :: AssignOp annot	Assignment operator (for example '+=').
aug_assign_expr :: Expr annot	Expression to evaluate.
stmt_annot :: annot

Decorated

Decorated definition of a function or class.

decorated_decorators :: [Decorator annot]	Decorators.
decorated_def :: Statement annot	Function or class definition to be decorated.
stmt_annot :: annot

Return

Return statement (may only occur syntactically nested in a function definition).

return_expr :: Maybe (Expr annot)	Optional expression to evaluate and return to caller.
stmt_annot :: annot

Try

Try statement (exception handling).

try_body :: Suite annot	Try clause.
try_excepts :: [Handler annot]	Exception handlers.
try_else :: Suite annot	Possibly empty else clause, executed if and when control flows off the end of the try clause.
try_finally :: Suite annot	Possibly empty finally clause.
stmt_annot :: annot

Raise

Raise statement (exception throwing).

raise_expr :: RaiseExpr annot
stmt_annot :: annot

With

With statement (context management).

with_context :: [(Expr annot, Maybe (Expr annot))]	Context expression(s) (yields a context manager).
with_body :: Suite annot	Suite to be managed.
stmt_annot :: annot

Pass

Pass statement (null operation).

stmt_annot :: annot

Break

Break statement (may only occur syntactically nested in a for or while loop, but not nested in a function or class definition within that loop).

stmt_annot :: annot

Continue

Continue statement (may only occur syntactically nested in a for or while loop, but not nested in a function or class definition or finally clause within that loop).

stmt_annot :: annot

Delete

Del statement (delete).

del_exprs :: [Expr annot]	Items to delete.
stmt_annot :: annot

StmtExpr

Expression statement.

stmt_expr :: Expr annot
stmt_annot :: annot

Global

Global declaration.

global_vars :: [Ident annot]	Variables declared global in the current block.
stmt_annot :: annot

NonLocal

Nonlocal declaration. Version 3.x only.

nonLocal_vars :: [Ident annot]	Variables declared nonlocal in the current block (their binding comes from bound the nearest enclosing scope).
stmt_annot :: annot

Assert

Assertion.

assert_exprs :: [Expr annot]	Expressions being asserted.
stmt_annot :: annot

Print

Print statement. Version 2 only.

print_chevron :: Bool	Optional chevron (>>)
print_exprs :: [Expr annot]	Arguments to print
print_trailing_comma :: Bool	Does it end in a comma?
stmt_annot :: annot

Exec

Exec statement. Version 2 only.

exec_expr :: Expr annot	Expression to exec.
exec_globals_locals :: Maybe (Expr annot, Maybe (Expr annot))	Global and local environments to evaluate the expression within.
stmt_annot :: annot

show/hide

Instances

Typeable1 Statement

Span StatementSpan

Annotated Statement

Eq annot => Eq (Statement annot)

Data annot => Data (Statement annot)

Ord annot => Ord (Statement annot)

Show annot => Show (Statement annot)

Pretty (Statement a)

type StatementSpan = Statement SrcSpan

type Suite annot = [Statement annot]

A block of statements. A suite is a group of statements controlled by a clause, for example, the body of a loop.

Version 2.6 http://www.python.org/doc/2.6/reference/compound_stmts.html
Version 3.1 http://www.python.org/doc/3.1/reference/compound_stmts.html

type SuiteSpan = Suite SrcSpan

data Parameter annot

Formal parameter of function definitions and lambda expressions.

Constructors

Param

Ordinary named parameter.

param_name :: Ident annot	Parameter name.
param_py_annotation :: Maybe (Expr annot)	Optional annotation.
param_default :: Maybe (Expr annot)	Optional default value.
param_annot :: annot

VarArgsPos

Excess positional parameter (single asterisk before its name in the concrete syntax).

param_name :: Ident annot	Parameter name.
param_py_annotation :: Maybe (Expr annot)	Optional annotation.
param_annot :: annot

VarArgsKeyword

Excess keyword parameter (double asterisk before its name in the concrete syntax).

param_name :: Ident annot	Parameter name.
param_py_annotation :: Maybe (Expr annot)	Optional annotation.
param_annot :: annot

EndPositional

Marker for the end of positional parameters (not a parameter itself).

param_annot :: annot

UnPackTuple

Tuple unpack. Version 2 only.

param_unpack_tuple :: ParamTuple annot	The tuple to unpack.
param_default :: Maybe (Expr annot)	Optional default value.
param_annot :: annot

show/hide

Instances

Typeable1 Parameter

Span ParameterSpan

Annotated Parameter

Eq annot => Eq (Parameter annot)

Data annot => Data (Parameter annot)

Ord annot => Ord (Parameter annot)

Show annot => Show (Parameter annot)

Pretty (Parameter a)

type ParameterSpan = Parameter SrcSpan

data ParamTuple annot

Tuple unpack parameter. Version 2 only.

Constructors

ParamTupleName

A variable name.

param_tuple_name :: Ident annot
param_tuple_annot :: annot

ParamTuple

A (possibly nested) tuple parameter.

param_tuple :: [ParamTuple annot]
param_tuple_annot :: annot

show/hide

Instances

Typeable1 ParamTuple

Span ParamTupleSpan

Annotated ParamTuple

Eq annot => Eq (ParamTuple annot)

Data annot => Data (ParamTuple annot)

Ord annot => Ord (ParamTuple annot)

Show annot => Show (ParamTuple annot)

Pretty (ParamTuple a)

type ParamTupleSpan = ParamTuple SrcSpan

data Decorator annot

Decorator.

Constructors

Decorator

decorator_name :: DottedName annot	Decorator name.
decorator_args :: [Argument annot]	Decorator arguments.
decorator_annot :: annot

show/hide

Instances

Typeable1 Decorator

Span DecoratorSpan

Annotated Decorator

Eq annot => Eq (Decorator annot)

Data annot => Data (Decorator annot)

Ord annot => Ord (Decorator annot)

Show annot => Show (Decorator annot)

Pretty (Decorator a)

type DecoratorSpan = Decorator SrcSpan

data AssignOp annot

Augmented assignment operators.

Constructors

PlusAssign

'+='

assignOp_annot :: annot

MinusAssign

'-='

assignOp_annot :: annot

MultAssign

'*='

assignOp_annot :: annot

DivAssign

'/='

assignOp_annot :: annot

ModAssign

'%='

assignOp_annot :: annot

PowAssign

'*='

assignOp_annot :: annot

BinAndAssign

'&='

assignOp_annot :: annot

BinOrAssign

'|='

assignOp_annot :: annot

BinXorAssign

'^='

assignOp_annot :: annot

LeftShiftAssign

'<<='

assignOp_annot :: annot

RightShiftAssign

'>>='

assignOp_annot :: annot

FloorDivAssign

'//='

assignOp_annot :: annot

show/hide

Instances

Typeable1 AssignOp

Span AssignOpSpan

Annotated AssignOp

Eq annot => Eq (AssignOp annot)

Data annot => Data (AssignOp annot)

Ord annot => Ord (AssignOp annot)

Show annot => Show (AssignOp annot)

Pretty (AssignOp a)

type AssignOpSpan = AssignOp SrcSpan

Expressions, operators, arguments and slices

data Expr annot

Expressions.

Version 2.6 http://www.python.org/doc/2.6/reference/expressions.html.
Version 3.1 http://www.python.org/doc/3.1/reference/expressions.html.

Constructors

Var

Variable.

var_ident :: Ident annot
expr_annot :: annot

Int

Literal integer.

int_value :: Integer
expr_literal :: String
expr_annot :: annot

LongInt

Long literal integer. Version 2 only.

int_value :: Integer
expr_literal :: String
expr_annot :: annot

Float

Literal floating point number.

float_value :: Double
expr_literal :: String
expr_annot :: annot

Imaginary

Literal imaginary number.

imaginary_value :: Double
expr_literal :: String
expr_annot :: annot

Bool

Literal boolean.

bool_value :: Bool
expr_annot :: annot

None

Literal 'None' value.

expr_annot :: annot

Ellipsis

Ellipsis '...'.

expr_annot :: annot

ByteStrings

Literal byte string.

byte_string_strings :: [String]
expr_annot :: annot

Strings

Literal strings (to be concatentated together).

strings_strings :: [String]
expr_annot :: annot

Call

Function call.

call_fun :: Expr annot	Expression yielding a callable object (such as a function).
call_args :: [Argument annot]	Call arguments.
expr_annot :: annot

Subscript

Subscription, for example 'x [y]'.

subscriptee :: Expr annot
subscript_exprs :: [Expr annot]
expr_annot :: annot

SlicedExpr

Slicing, for example 'w [x:y:z]'.

slicee :: Expr annot
slices :: [Slice annot]
expr_annot :: annot

CondExpr

Conditional expresison.

ce_true_branch :: Expr annot	Expression to evaluate if condition is True.
ce_condition :: Expr annot	Boolean condition.
ce_false_branch :: Expr annot	Expression to evaluate if condition is False.
expr_annot :: annot

BinaryOp

Binary operator application.

operator :: Op annot
left_op_arg :: Expr annot
right_op_arg :: Expr annot
expr_annot :: annot

UnaryOp

Unary operator application.

operator :: Op annot
op_arg :: Expr annot
expr_annot :: annot

Lambda

Anonymous function definition (lambda).

lambda_args :: [Parameter annot]
lambda_body :: Expr annot
expr_annot :: annot

Tuple

Tuple. Can be empty.

tuple_exprs :: [Expr annot]
expr_annot :: annot

Yield

Generator yield.

yield_expr :: Maybe (Expr annot)	Optional expression to yield.
expr_annot :: annot

Generator

Generator.

gen_comprehension :: Comprehension (Expr annot) annot
expr_annot :: annot

ListComp

List comprehension.

list_comprehension :: Comprehension (Expr annot) annot
expr_annot :: annot

List

List.

list_exprs :: [Expr annot]
expr_annot :: annot

Dictionary

Dictionary.

dict_mappings :: [(Expr annot, Expr annot)]
expr_annot :: annot

DictComp

Dictionary comprehension. Version 3 only.

dict_comprehension :: Comprehension (Expr annot, Expr annot) annot
expr_annot :: annot

Set

Set.

set_exprs :: [Expr annot]
expr_annot :: annot

SetComp

Set comprehension. Version 3 only.

set_comprehension :: Comprehension (Expr annot) annot
expr_annot :: annot

Starred

Starred expression. Version 3 only.

starred_expr :: Expr annot
expr_annot :: annot

Paren

Parenthesised expression.

paren_expr :: Expr annot
expr_annot :: annot

StringConversion

String conversion (backquoted expression). Version 2 only.

backquoted_expr :: Expr annot
expr_anot :: annot

show/hide

Instances

Eq annot => Eq (Expr annot)

Data annot => Data (Expr annot)

Ord annot => Ord (Expr annot)

Show annot => Show (Expr annot)

Pretty (Expr a)

type ExprSpan = Expr SrcSpan

data Op annot

Operators.

Constructors

And

'and'

op_annot :: annot

Or

'or'

op_annot :: annot

Not

'not'

op_annot :: annot

Exponent

'**'

op_annot :: annot

LessThan

'<'

op_annot :: annot

GreaterThan

'>'

op_annot :: annot

Equality

'=='

op_annot :: annot

GreaterThanEquals

'>='

op_annot :: annot

LessThanEquals

'<='

op_annot :: annot

NotEquals

'!='

op_annot :: annot

NotEqualsV2

''. Version 2 only.

op_annot :: annot

In

'in'

op_annot :: annot

Is

'is'

op_annot :: annot

IsNot

'is not'

op_annot :: annot

NotIn

'not in'

op_annot :: annot

BinaryOr

'|'

op_annot :: annot

Xor

'^'

op_annot :: annot

BinaryAnd

'&'

op_annot :: annot

ShiftLeft

'<<'

op_annot :: annot

ShiftRight

'>>'

op_annot :: annot

Multiply

'*'

op_annot :: annot

Plus

'+'

op_annot :: annot

Minus

'-'

op_annot :: annot

Divide

'/'

op_annot :: annot

FloorDivide

'//'

op_annot :: annot

Invert

'~' (bitwise inversion of its integer argument)

op_annot :: annot

Modulo

'%'

op_annot :: annot

Dot

'.'

op_annot :: annot

show/hide

Instances

Eq annot => Eq (Op annot)

Data annot => Data (Op annot)

Ord annot => Ord (Op annot)

Show annot => Show (Op annot)

type OpSpan = Op SrcSpan

data Argument annot

Arguments to function calls, class declarations and decorators.

Constructors

ArgExpr

Ordinary argument expression.

arg_expr :: Expr annot
arg_annot :: annot

ArgVarArgsPos

Excess positional argument.

arg_expr :: Expr annot
arg_annot :: annot

ArgVarArgsKeyword

Excess keyword argument.

arg_expr :: Expr annot
arg_annot :: annot

ArgKeyword

Keyword argument.

arg_keyword :: Ident annot	Keyword name.
arg_expr :: Expr annot	Argument expression.
arg_annot :: annot

show/hide

Instances

Typeable1 Argument

Span ArgumentSpan

Annotated Argument

Eq annot => Eq (Argument annot)

Data annot => Data (Argument annot)

Ord annot => Ord (Argument annot)

Show annot => Show (Argument annot)

Pretty (Argument a)

type ArgumentSpan = Argument SrcSpan

data Slice annot

Slice compenent.

Constructors

SliceProper

slice_lower :: Maybe (Expr annot)
slice_upper :: Maybe (Expr annot)
slice_stride :: Maybe (Maybe (Expr annot))
slice_annot :: annot

SliceExpr

slice_expr :: Expr annot
slice_annot :: annot

SliceEllipsis

slice_annot :: annot

show/hide

Instances

Typeable1 Slice

Annotated Slice

Eq annot => Eq (Slice annot)

Data annot => Data (Slice annot)

Ord annot => Ord (Slice annot)

Show annot => Show (Slice annot)

Pretty (Slice a)

type SliceSpan = Slice SrcSpan

data ImportItem annot

An entity imported using the 'import' keyword.

Constructors

ImportItem

import_item_name :: DottedName annot	The name of module to import.
import_as_name :: Maybe (Ident annot)	An optional name to refer to the entity (the 'as' name).
import_item_annot :: annot

show/hide

Instances

Typeable1 ImportItem

Span ImportItemSpan

Annotated ImportItem

Eq annot => Eq (ImportItem annot)

Data annot => Data (ImportItem annot)

Ord annot => Ord (ImportItem annot)

Show annot => Show (ImportItem annot)

Pretty (ImportItem a)

type ImportItemSpan = ImportItem SrcSpan

data FromItem annot

An entity imported using the 'from ... import' construct.

Constructors

FromItem

from_item_name :: Ident annot	The name of the entity imported.
from_as_name :: Maybe (Ident annot)	An optional name to refer to the entity (the 'as' name).
from_item_annot :: annot

show/hide

Instances

Typeable1 FromItem

Span FromItemSpan

Annotated FromItem

Eq annot => Eq (FromItem annot)

Data annot => Data (FromItem annot)

Ord annot => Ord (FromItem annot)

Show annot => Show (FromItem annot)

Pretty (FromItem a)

type FromItemSpan = FromItem SrcSpan

data FromItems annot

Items imported using the 'from ... import' construct.

Constructors

ImportEverything

Import everything exported from the module.

from_items_annot :: annot

FromItems

Import a specific list of items from the module.

from_items_items :: [FromItem annot]
from_items_annot :: annot

show/hide

Instances

Typeable1 FromItems

Span FromItemsSpan

Annotated FromItems

Eq annot => Eq (FromItems annot)

Data annot => Data (FromItems annot)

Ord annot => Ord (FromItems annot)

Show annot => Show (FromItems annot)

Pretty (FromItems a)

type FromItemsSpan = FromItems SrcSpan

data ImportRelative annot

A reference to the module to import from using the 'from ... import' construct.

Constructors

ImportRelative

import_relative_dots :: Int
import_relative_module :: Maybe (DottedName annot)
import_relative_annot :: annot

show/hide

Instances

Typeable1 ImportRelative

Span ImportRelativeSpan

Annotated ImportRelative

Eq annot => Eq (ImportRelative annot)

Data annot => Data (ImportRelative annot)

Ord annot => Ord (ImportRelative annot)

Show annot => Show (ImportRelative annot)

Pretty (ImportRelative a)

type ImportRelativeSpan = ImportRelative SrcSpan

data Handler annot

Exception handler.

Constructors

Handler

handler_clause :: ExceptClause annot
handler_suite :: Suite annot
handler_annot :: annot

show/hide

Instances

Typeable1 Handler

Span HandlerSpan

Annotated Handler

Eq annot => Eq (Handler annot)

Data annot => Data (Handler annot)

Ord annot => Ord (Handler annot)

Show annot => Show (Handler annot)

Pretty (Handler a)

type HandlerSpan = Handler SrcSpan

data ExceptClause annot

Exception clause.

Constructors

ExceptClause

except_clause :: Maybe (Expr annot, Maybe (Expr annot))
except_clause_annot :: annot

show/hide

Instances

Typeable1 ExceptClause

Span ExceptClauseSpan

Annotated ExceptClause

Eq annot => Eq (ExceptClause annot)

Data annot => Data (ExceptClause annot)

Ord annot => Ord (ExceptClause annot)

Show annot => Show (ExceptClause annot)

Pretty (ExceptClause a)

type ExceptClauseSpan = ExceptClause SrcSpan

data RaiseExpr annot

The argument for a raise statement.

Constructors

RaiseV3 (Maybe (Expr annot, Maybe (Expr annot)))	Optional expression to evaluate, and optional 'from' clause. Version 3 only.
RaiseV2 (Maybe (Expr annot, Maybe (Expr annot, Maybe (Expr annot))))	Version 2 only.

show/hide

Instances

Typeable1 RaiseExpr

Eq annot => Eq (RaiseExpr annot)

Data annot => Data (RaiseExpr annot)

Ord annot => Ord (RaiseExpr annot)

Show annot => Show (RaiseExpr annot)

Pretty (RaiseExpr a)

type RaiseExprSpan = RaiseExpr SrcSpan

data Comprehension e annot

Comprehension. In version 3.x this can be used for lists, sets, dictionaries and generators.

Constructors

Comprehension

comprehension_expr :: e
comprehension_for :: CompFor annot
comprehension_annot :: annot

show/hide

Instances

Typeable2 Comprehension

Span (ComprehensionSpan e)

Annotated (Comprehension e)

(Eq e, Eq annot) => Eq (Comprehension e annot)

(Data e, Data annot) => Data (Comprehension e annot)

(Ord e, Ord annot) => Ord (Comprehension e annot)

(Show e, Show annot) => Show (Comprehension e annot)

Pretty t => Pretty (Comprehension t a)

type ComprehensionSpan e = Comprehension e SrcSpan

data CompFor annot

Comprehension 'for' component.

Constructors

CompFor

comp_for_exprs :: [Expr annot]
comp_in_expr :: Expr annot
comp_for_iter :: Maybe (CompIter annot)
comp_for_annot :: annot

show/hide

Instances

Typeable1 CompFor

Span CompForSpan

Annotated CompFor

Eq annot => Eq (CompFor annot)

Data annot => Data (CompFor annot)

Ord annot => Ord (CompFor annot)

Show annot => Show (CompFor annot)

Pretty (CompFor a)

type CompForSpan = CompFor SrcSpan

data CompIf annot

Comprehension guard.

Constructors

CompIf

comp_if :: Expr annot
comp_if_iter :: Maybe (CompIter annot)
comp_if_annot :: annot

show/hide

Instances

Typeable1 CompIf

Span CompIfSpan

Annotated CompIf

Eq annot => Eq (CompIf annot)

Data annot => Data (CompIf annot)

Ord annot => Ord (CompIf annot)

Show annot => Show (CompIf annot)

Pretty (CompIf a)

type CompIfSpan = CompIf SrcSpan

data CompIter annot

Comprehension iterator (either a 'for' or an 'if').

Constructors

IterFor

comp_iter_for :: CompFor annot
comp_iter_annot :: annot

IterIf

comp_iter_if :: CompIf annot
comp_iter_annot :: annot

show/hide

Instances

Typeable1 CompIter

Span CompIterSpan

Annotated CompIter

Eq annot => Eq (CompIter annot)

Data annot => Data (CompIter annot)

Ord annot => Ord (CompIter annot)

Show annot => Show (CompIter annot)

Pretty (CompIter a)

type CompIterSpan = CompIter SrcSpan

Produced by Haddock version 2.4.2