Language.Python.Common.AST

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

Copyright | (c) 2009 Bernie Pope
License | BSD-style
Maintainer | bjpop@csse.unimelb.edu.au
Stability | experimental
Portability | ghc
Safe Haskell | Safe
Language | Haskell98

Language.Python.Common.AST

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 {
    - import_items :: [ImportItem annot]
    - stmt_annot :: annot
    }
  - | FromImport {
    - from_module :: ImportRelative annot
    - from_items :: FromItems annot
    - stmt_annot :: annot
    }
  - | While {
    - 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 {
    - 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 {
    - 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 {
    - decorated_decorators :: [Decorator annot]
    - decorated_def :: Statement annot
    - stmt_annot :: annot
    }
  - | Return {
    - 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 {
    - 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
    }
  - | Break {
    - stmt_annot :: annot
    }
  - | Continue {
    - stmt_annot :: annot
    }
  - | Delete {
    - del_exprs :: [Expr annot]
    - stmt_annot :: annot
    }
  - | StmtExpr {
    - stmt_expr :: Expr annot
    - stmt_annot :: annot
    }
  - | Global {
    - global_vars :: [Ident annot]
    - stmt_annot :: annot
    }
  - | NonLocal {
    - nonLocal_vars :: [Ident annot]
    - stmt_annot :: annot
    }
  - | Assert {
    - assert_exprs :: [Expr annot]
    - stmt_annot :: annot
    }
  - | Print {
    - 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 {
    - param_name :: Ident annot
    - param_py_annotation :: Maybe (Expr annot)
    - param_default :: Maybe (Expr annot)
    - param_annot :: annot
    }
  - | VarArgsPos {
    - 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
    }
  - | ParamTuple {
    - 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
  - = 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
    }
- 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
    }
  - | LongInt {
    - int_value :: Integer
    - expr_literal :: String
    - expr_annot :: annot
    }
  - | Float {
    - float_value :: Double
    - expr_literal :: String
    - expr_annot :: annot
    }
  - | Imaginary {
    - imaginary_value :: Double
    - expr_literal :: String
    - expr_annot :: annot
    }
  - | Bool {
    - bool_value :: Bool
    - expr_annot :: annot
    }
  - | None {
    - expr_annot :: annot
    }
  - | Ellipsis {
    - expr_annot :: annot
    }
  - | ByteStrings {
    - byte_string_strings :: [String]
    - expr_annot :: annot
    }
  - | Strings {
    - strings_strings :: [String]
    - expr_annot :: annot
    }
  - | UnicodeStrings {
    - unicodestrings_strings :: [String]
    - expr_annot :: annot
    }
  - | Call {
    - call_fun :: Expr annot
    - call_args :: [Argument annot]
    - expr_annot :: annot
    }
  - | Subscript {
    - subscriptee :: Expr annot
    - subscript_expr :: Expr annot
    - expr_annot :: annot
    }
  - | SlicedExpr {
    - slicee :: Expr annot
    - slices :: [Slice annot]
    - expr_annot :: annot
    }
  - | CondExpr {
    - ce_true_branch :: Expr annot
    - ce_condition :: Expr annot
    - ce_false_branch :: Expr annot
    - expr_annot :: annot
    }
  - | BinaryOp {
    - operator :: Op annot
    - left_op_arg :: Expr annot
    - right_op_arg :: Expr annot
    - expr_annot :: annot
    }
  - | UnaryOp {
    - operator :: Op annot
    - op_arg :: Expr annot
    - expr_annot :: annot
    }
  - | Dot {
    - dot_expr :: Expr annot
    - dot_attribute :: Ident annot
    - expr_annot :: annot
    }
  - | Lambda {
    - lambda_args :: [Parameter annot]
    - lambda_body :: Expr annot
    - expr_annot :: annot
    }
  - | Tuple {
    - tuple_exprs :: [Expr annot]
    - expr_annot :: annot
    }
  - | Yield {
    - yield_arg :: Maybe (YieldArg annot)
    - expr_annot :: annot
    }
  - | Generator {
    - gen_comprehension :: Comprehension annot
    - expr_annot :: annot
    }
  - | ListComp {
    - list_comprehension :: Comprehension annot
    - expr_annot :: annot
    }
  - | List {
    - list_exprs :: [Expr annot]
    - expr_annot :: annot
    }
  - | Dictionary {
    - dict_mappings :: [DictMappingPair annot]
    - expr_annot :: annot
    }
  - | DictComp {
    - dict_comprehension :: Comprehension annot
    - expr_annot :: annot
    }
  - | Set {
    - set_exprs :: [Expr annot]
    - expr_annot :: annot
    }
  - | SetComp {
    - set_comprehension :: Comprehension annot
    - expr_annot :: annot
    }
  - | Starred {
    - starred_expr :: Expr annot
    - expr_annot :: annot
    }
  - | Paren {
    - 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
    }
  - | 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 {
    - op_annot :: annot
    }
  - | In {
    - op_annot :: annot
    }
  - | Is {
    - op_annot :: annot
    }
  - | IsNot {
    - op_annot :: annot
    }
  - | NotIn {
    - 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 {
    - op_annot :: annot
    }
  - | Modulo {
    - op_annot :: annot
    }
- type OpSpan = Op SrcSpan
- data Argument annot
  - = ArgExpr {
    - arg_expr :: Expr annot
    - arg_annot :: annot
    }
  - | ArgVarArgsPos {
    - arg_expr :: Expr annot
    - arg_annot :: annot
    }
  - | ArgVarArgsKeyword {
    - arg_expr :: Expr annot
    - arg_annot :: annot
    }
  - | ArgKeyword {
    - 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
    }
  - | SliceExpr {
    - slice_expr :: Expr annot
    - slice_annot :: annot
    }
  - | SliceEllipsis {
    - slice_annot :: annot
    }
- type SliceSpan = Slice SrcSpan
- data DictMappingPair annot = DictMappingPair (Expr annot) (Expr annot)
- type DictMappingPairSpan = DictMappingPair SrcSpan
- data YieldArg annot
  - = YieldFrom (Expr annot) annot
  - | YieldExpr (Expr annot)
- type YieldArgSpan = YieldArg 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
    }
  - | FromItems {
    - 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 annot = Comprehension {
  - comprehension_expr :: ComprehensionExpr annot
  - comprehension_for :: CompFor annot
  - comprehension_annot :: annot
  }
- type ComprehensionSpan = Comprehension SrcSpan
- data ComprehensionExpr annot
  - = ComprehensionExpr (Expr annot)
  - | ComprehensionDict (DictMappingPair annot)
- type ComprehensionExprSpan = ComprehensionExpr 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
  - = IterFor {
    - comp_iter_for :: CompFor annot
    - comp_iter_annot :: annot
    }
  - | IterIf {
    - 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.

Instances

Annotated AssignOp |
Annotated Op |
Annotated Slice |
Annotated Expr |
Annotated CompIter |
Annotated CompIf |
Annotated CompFor |
Annotated Comprehension |
Annotated ExceptClause |
Annotated Handler |
Annotated Argument |
Annotated ParamTuple |
Annotated Parameter |
Annotated Decorator |
Annotated Statement |
Annotated ImportRelative |
Annotated FromItems |
Annotated FromItem |
Annotated ImportItem |
Annotated Ident |

# Modules

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.

Instances

Functor Module |
Eq annot => Eq (Module annot) |
Data annot => Data (Module annot) |
Ord annot => Ord (Module annot) |
Show annot => Show (Module annot) |

type ModuleSpan = Module SrcSpan

# Identifiers and dotted names

data Ident annot

Identifier.

Constructors

Ident |
Fields ident_string :: !String ident_annot :: annot

Instances

Functor Ident |
Span IdentSpan |
Annotated Ident |
Eq annot => Eq (Ident annot) |
Data annot => Data (Ident annot) |
Ord annot => Ord (Ident annot) |
Show annot => Show (Ident annot) |

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.
Fields import_items :: [ImportItem annot] Items to import. stmt_annot :: annot
FromImport | From ... import statement.
Fields from_module :: ImportRelative annot Module to import from. from_items :: FromItems annot Items to import. stmt_annot :: annot
While | While loop.
Fields while_cond :: Expr annot Loop condition. while_body :: Suite annot Loop body. while_else :: Suite annot Else clause. stmt_annot :: annot
For | For loop.
Fields 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.
Fields 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.
Fields 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).
Fields 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.
Fields assign_to :: [Expr annot] Entity to assign to. assign_expr :: Expr annot Expression to evaluate. stmt_annot :: annot
AugmentedAssign | Augmented assignment statement.
Fields 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.
Fields 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).
Fields return_expr :: Maybe (Expr annot) Optional expression to evaluate and return to caller. stmt_annot :: annot
Try | Try statement (exception handling).
Fields 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).
Fields raise_expr :: RaiseExpr annot stmt_annot :: annot
With | With statement (context management).
Fields 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).
Fields 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).
Fields 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).
Fields stmt_annot :: annot
Delete | Del statement (delete).
Fields del_exprs :: [Expr annot] Items to delete. stmt_annot :: annot
StmtExpr | Expression statement.
Fields stmt_expr :: Expr annot stmt_annot :: annot
Global | Global declaration.
Fields global_vars :: [Ident annot] Variables declared global in the current block. stmt_annot :: annot
NonLocal | Nonlocal declaration. Version 3.x only.
Fields 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.
Fields assert_exprs :: [Expr annot] Expressions being asserted. stmt_annot :: annot
Print | Print statement. Version 2 only.
Fields 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.
Fields 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

Instances

Functor 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) |

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.

- Version 2.6:
- http://www.python.org/doc/2.6/reference/compound_stmts.html#function-definitions
- http://www.python.org/doc/2.6/reference/expressions.html#calls
- Version 3.1:
- http://www.python.org/doc/3.1/reference/compound_stmts.html#function-definitions
- http://www.python.org/doc/3.1/reference/expressions.html#calls

Constructors

Param | Ordinary named parameter.
Fields 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).
Fields 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).
Fields 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).
Fields param_annot :: annot
UnPackTuple | Tuple unpack. Version 2 only.
Fields param_unpack_tuple :: ParamTuple annot The tuple to unpack. param_default :: Maybe (Expr annot) Optional default value. param_annot :: annot

Instances

Functor 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) |

type ParameterSpan = Parameter SrcSpan

data ParamTuple annot

Tuple unpack parameter. Version 2 only.

Constructors

ParamTupleName | A variable name.
Fields param_tuple_name :: Ident annot param_tuple_annot :: annot
ParamTuple | A (possibly nested) tuple parameter.
Fields param_tuple :: [ParamTuple annot] param_tuple_annot :: annot

Instances

Functor 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) |

type ParamTupleSpan = ParamTuple SrcSpan

data Decorator annot

Decorator.

Constructors

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

Instances

Functor 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) |

type DecoratorSpan = Decorator SrcSpan

data AssignOp annot

Augmented assignment operators.

Constructors

PlusAssign | '+='
Fields assignOp_annot :: annot
MinusAssign | '-='
Fields assignOp_annot :: annot
MultAssign | '*='
Fields assignOp_annot :: annot
DivAssign | '/='
Fields assignOp_annot :: annot
ModAssign | '%='
Fields assignOp_annot :: annot
PowAssign | '*='
Fields assignOp_annot :: annot
BinAndAssign | '&='
Fields assignOp_annot :: annot
BinOrAssign | '|='
Fields assignOp_annot :: annot
BinXorAssign | '^='
Fields assignOp_annot :: annot
LeftShiftAssign | '<<='
Fields assignOp_annot :: annot
RightShiftAssign | '>>='
Fields assignOp_annot :: annot
FloorDivAssign | '//='
Fields assignOp_annot :: annot

Instances

Functor 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) |

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.
Fields var_ident :: Ident annot expr_annot :: annot
Int | Literal integer.
Fields int_value :: Integer expr_literal :: String expr_annot :: annot
LongInt | Long literal integer. Version 2 only.
Fields int_value :: Integer expr_literal :: String expr_annot :: annot
Float | Literal floating point number.
Fields float_value :: Double expr_literal :: String expr_annot :: annot
Imaginary | Literal imaginary number.
Fields imaginary_value :: Double expr_literal :: String expr_annot :: annot
Bool | Literal boolean.
Fields bool_value :: Bool expr_annot :: annot
None | Literal 'None' value.
Fields expr_annot :: annot
Ellipsis | Ellipsis '...'.
Fields expr_annot :: annot
ByteStrings | Literal byte string.
Fields byte_string_strings :: [String] expr_annot :: annot
Strings | Literal strings (to be concatentated together).
Fields strings_strings :: [String] expr_annot :: annot
UnicodeStrings | Unicode literal strings (to be concatentated together). Version 2 only.
Fields unicodestrings_strings :: [String] expr_annot :: annot
Call | Function call.
Fields 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]'.
Fields subscriptee :: Expr annot subscript_expr :: Expr annot expr_annot :: annot
SlicedExpr | Slicing, for example 'w [x:y:z]'.
Fields slicee :: Expr annot slices :: [Slice annot] expr_annot :: annot
CondExpr | Conditional expresison.
Fields 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.
Fields operator :: Op annot left_op_arg :: Expr annot right_op_arg :: Expr annot expr_annot :: annot
UnaryOp | Unary operator application.
Fields operator :: Op annot op_arg :: Expr annot expr_annot :: annot
Dot |
Fields dot_expr :: Expr annot dot_attribute :: Ident annot expr_annot :: annot
Lambda | Anonymous function definition (lambda).
Fields lambda_args :: [Parameter annot] lambda_body :: Expr annot expr_annot :: annot
Tuple | Tuple. Can be empty.
Fields tuple_exprs :: [Expr annot] expr_annot :: annot
Yield | Generator yield.
Fields yield_arg :: Maybe (YieldArg annot) Optional Yield argument. expr_annot :: annot
Generator | Generator.
Fields gen_comprehension :: Comprehension annot expr_annot :: annot
ListComp | List comprehension.
Fields list_comprehension :: Comprehension annot expr_annot :: annot
List | List.
Fields list_exprs :: [Expr annot] expr_annot :: annot
Dictionary | Dictionary.
Fields dict_mappings :: [DictMappingPair annot] expr_annot :: annot
DictComp | Dictionary comprehension. Version 3 only.
Fields dict_comprehension :: Comprehension annot expr_annot :: annot
Set | Set.
Fields set_exprs :: [Expr annot] expr_annot :: annot
SetComp | Set comprehension. Version 3 only.
Fields set_comprehension :: Comprehension annot expr_annot :: annot
Starred | Starred expression. Version 3 only.
Fields starred_expr :: Expr annot expr_annot :: annot
Paren | Parenthesised expression.
Fields paren_expr :: Expr annot expr_annot :: annot
StringConversion | String conversion (backquoted expression). Version 2 only.
Fields backquoted_expr :: Expr annot expr_anot :: annot

Instances

Functor Expr |
Span ExprSpan |
Annotated Expr |
Eq annot => Eq (Expr annot) |
Data annot => Data (Expr annot) |
Ord annot => Ord (Expr annot) |
Show annot => Show (Expr annot) |

type ExprSpan = Expr SrcSpan

data Op annot

Operators.

Constructors

And | 'and'
Fields op_annot :: annot
Or | 'or'
Fields op_annot :: annot
Not | 'not'
Fields op_annot :: annot
Exponent | '**'
Fields op_annot :: annot
LessThan | '<'
Fields op_annot :: annot
GreaterThan | '>'
Fields op_annot :: annot
Equality | '=='
Fields op_annot :: annot
GreaterThanEquals | '>='
Fields op_annot :: annot
LessThanEquals | '<='
Fields op_annot :: annot
NotEquals | '!='
Fields op_annot :: annot
NotEqualsV2 | '<>'. Version 2 only.
Fields op_annot :: annot
In | 'in'
Fields op_annot :: annot
Is | 'is'
Fields op_annot :: annot
IsNot | 'is not'
Fields op_annot :: annot
NotIn | 'not in'
Fields op_annot :: annot
BinaryOr | '|'
Fields op_annot :: annot
Xor | '^'
Fields op_annot :: annot
BinaryAnd | '&'
Fields op_annot :: annot
ShiftLeft | '<<'
Fields op_annot :: annot
ShiftRight | '>>'
Fields op_annot :: annot
Multiply | '*'
Fields op_annot :: annot
Plus | '+'
Fields op_annot :: annot
Minus | '-'
Fields op_annot :: annot
Divide | '/'
Fields op_annot :: annot
FloorDivide | '//'
Fields op_annot :: annot
Invert | '~' (bitwise inversion of its integer argument)
Fields op_annot :: annot
Modulo | '%'
Fields op_annot :: annot

Instances

Functor Op |
Span OpSpan |
Annotated Op |
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.
Fields arg_expr :: Expr annot Argument expression. arg_annot :: annot
ArgVarArgsPos | Excess positional argument.
Fields arg_expr :: Expr annot Argument expression. arg_annot :: annot
ArgVarArgsKeyword | Excess keyword argument.
Fields arg_expr :: Expr annot Argument expression. arg_annot :: annot
ArgKeyword | Keyword argument.
Fields arg_keyword :: Ident annot Keyword name. arg_expr :: Expr annot Argument expression. arg_annot :: annot

Instances

Functor 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) |

type ArgumentSpan = Argument SrcSpan

data Slice annot

Slice compenent.

Constructors

SliceProper |
Fields slice_lower :: Maybe (Expr annot) slice_upper :: Maybe (Expr annot) slice_stride :: Maybe (Maybe (Expr annot)) slice_annot :: annot
SliceExpr |
Fields slice_expr :: Expr annot slice_annot :: annot
SliceEllipsis |
Fields slice_annot :: annot

Instances

Functor Slice |
Span SliceSpan |
Annotated Slice |
Eq annot => Eq (Slice annot) |
Data annot => Data (Slice annot) |
Ord annot => Ord (Slice annot) |
Show annot => Show (Slice annot) |

type SliceSpan = Slice SrcSpan

data DictMappingPair annot

Constructors

DictMappingPair (Expr annot) (Expr annot) |

Instances

Functor DictMappingPair |
Span DictMappingPairSpan |
Eq annot => Eq (DictMappingPair annot) |
Data annot => Data (DictMappingPair annot) |
Ord annot => Ord (DictMappingPair annot) |
Show annot => Show (DictMappingPair annot) |

type DictMappingPairSpan = DictMappingPair SrcSpan

data YieldArg annot

Constructors

YieldFrom (Expr annot) annot | Yield from a generator (Version 3 only)
YieldExpr (Expr annot) | Yield value of an expression

Instances

Functor YieldArg |
Span YieldArgSpan |
Eq annot => Eq (YieldArg annot) |
Data annot => Data (YieldArg annot) |
Ord annot => Ord (YieldArg annot) |
Show annot => Show (YieldArg annot) |

type YieldArgSpan = YieldArg SrcSpan

# Imports

data ImportItem annot

An entity imported using the 'import' keyword.

- Version 2.6 http://www.python.org/doc/2.6/reference/simple_stmts.html#the-import-statement
- Version 3.1 http://www.python.org/doc/3.1/reference/simple_stmts.html#the-import-statement

Constructors

ImportItem |
Fields 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

Instances

Functor 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) |

type ImportItemSpan = ImportItem SrcSpan

data FromItem annot

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

- Version 2.6 http://www.python.org/doc/2.6/reference/simple_stmts.html#the-import-statement
- Version 3.1 http://www.python.org/doc/3.1/reference/simple_stmts.html#the-import-statement

Constructors

FromItem |
Fields 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

Instances

Functor 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) |

type FromItemSpan = FromItem SrcSpan

data FromItems annot

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

Constructors

ImportEverything | Import everything exported from the module.
Fields from_items_annot :: annot
FromItems | Import a specific list of items from the module.
Fields from_items_items :: [FromItem annot] from_items_annot :: annot

Instances

Functor 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) |

type FromItemsSpan = FromItems SrcSpan

data ImportRelative annot

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

Constructors

ImportRelative |
Fields import_relative_dots :: Int import_relative_module :: Maybe (DottedName annot) import_relative_annot :: annot

Instances

Functor 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) |

type ImportRelativeSpan = ImportRelative SrcSpan

# Exceptions

data Handler annot

Exception handler.

Constructors

Handler |
Fields handler_clause :: ExceptClause annot handler_suite :: Suite annot handler_annot :: annot

Instances

Functor 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) |

type HandlerSpan = Handler SrcSpan

data ExceptClause annot

Exception clause.

Constructors

ExceptClause |
Fields except_clause :: Maybe (Expr annot, Maybe (Expr annot)) except_clause_annot :: annot

Instances

Functor 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) |

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.

Instances

Functor RaiseExpr |
Eq annot => Eq (RaiseExpr annot) |
Data annot => Data (RaiseExpr annot) |
Ord annot => Ord (RaiseExpr annot) |
Show annot => Show (RaiseExpr annot) |

type RaiseExprSpan = RaiseExpr SrcSpan

# Comprehensions

data Comprehension annot

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

Constructors

Comprehension |
Fields comprehension_expr :: ComprehensionExpr annot comprehension_for :: CompFor annot comprehension_annot :: annot

Instances

Functor Comprehension |
Span ComprehensionSpan |
Annotated Comprehension |
Eq annot => Eq (Comprehension annot) |
Data annot => Data (Comprehension annot) |
Ord annot => Ord (Comprehension annot) |
Show annot => Show (Comprehension annot) |

type ComprehensionSpan = Comprehension SrcSpan

data ComprehensionExpr annot

Constructors

ComprehensionExpr (Expr annot) |
ComprehensionDict (DictMappingPair annot) |

Instances

Functor ComprehensionExpr |
Span ComprehensionExprSpan |
Eq annot => Eq (ComprehensionExpr annot) |
Data annot => Data (ComprehensionExpr annot) |
Ord annot => Ord (ComprehensionExpr annot) |
Show annot => Show (ComprehensionExpr annot) |

type ComprehensionExprSpan = ComprehensionExpr SrcSpan

data CompFor annot

Comprehension 'for' component.

Constructors

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

Instances

Functor 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) |

type CompForSpan = CompFor SrcSpan

data CompIf annot

Comprehension guard.

Constructors

CompIf |
Fields comp_if :: Expr annot comp_if_iter :: Maybe (CompIter annot) comp_if_annot :: annot

Instances

Functor 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) |

type CompIfSpan = CompIf SrcSpan

data CompIter annot

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

Constructors

IterFor |
Fields comp_iter_for :: CompFor annot comp_iter_annot :: annot
IterIf |
Fields comp_iter_if :: CompIf annot comp_iter_annot :: annot

Instances

Functor 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) |

type CompIterSpan = CompIter SrcSpan