-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Python language tools
--   
--   <a>hpython</a> provides an abstract syntax tree for Python 3.5, along
--   with a parser, printer, and syntax checker. It also contains optics
--   for working with the AST, and a DSL for writing Python programs
--   directly in Haskell.
--   
--   For a high-level overview of the library, see the
--   <tt>Language.Python</tt> module.
--   
--   For code examples, see the <a>examples directory on GitHub</a>.
--   
--   For general information about the project, see the <a>project
--   readme</a>.
@package hpython
@version 0.2


-- | This module defines some helpful set-like functions for working with
--   type-level lists.
module Data.Type.Set

-- | Remove adjacent equal elements from a type-level list
type family Nub t

-- | Determine whether type <tt>a</tt> is a member of type-level list
--   <tt>s</tt>
class Member a s
instance forall a1 (a2 :: a1) (s :: [a1]). Data.Type.Set.Member a2 (a2 : s)
instance forall a1 k (a2 :: k) (s :: [a1]) (b :: a1). Data.Type.Set.Member a2 s => Data.Type.Set.Member a2 (b : s)


module Data.Validate.Monadic

-- | The composition of <a>Validation</a> with another <a>Applicative</a>
--   functor.
--   
--   <a>Validation</a> is not a <a>Monad</a>, and <a>ValidateM</a> is not a
--   monad transformer. It is equipped with a useful bind function, but
--   that function does not have the right type to make <a>ValidateM</a> a
--   <a>Monad</a> (besides which it would break the laws)
newtype ValidateM e m a
ValidateM :: Compose m (Validation e) a -> ValidateM e m a
[unValidateM] :: ValidateM e m a -> Compose m (Validation e) a

-- | Unwrap a <a>ValidateM</a>
runValidateM :: ValidateM e m a -> m (Validation e a)

-- | Bind into a <a>ValidateM</a>. Note that the first parameter is <tt>m
--   a</tt>, not <tt>ValidateM e m a</tt>.
bindVM :: Monad m => m a -> (a -> ValidateM e m b) -> ValidateM e m b

-- | Lift into a succeeding validation
liftVM0 :: (Functor m, Semigroup e) => m a -> ValidateM e m a

-- | Run a natural transformation across <a>ValidateM</a> to alter
--   <tt>m</tt>
liftVM1 :: (forall x. m x -> m x) -> ValidateM e m a -> ValidateM e m a

-- | Lift an error into <a>ValidateM</a>
errorVM :: Applicative m => e -> ValidateM e m a

-- | Lift an error in an <a>Applicative</a> into <a>ValidateM</a>. This is
--   especially useful if you're using list or <a>NonEmpty</a> to collect
--   errors.
errorVM1 :: (Applicative f, Applicative m) => e -> ValidateM (f e) m a
instance (GHC.Base.Applicative m, GHC.Base.Semigroup e) => GHC.Base.Applicative (Data.Validate.Monadic.ValidateM e m)
instance GHC.Base.Functor m => GHC.Base.Functor (Data.Validate.Monadic.ValidateM e m)


module Language.Python.Optics.Validated

-- | A type class for things for which we can strip the validation
--   information. This can help types line up when they need to, for
--   example to put many things of various validation statuses together in
--   a list.
class Validated (s :: [*] -> * -> *)
unvalidated :: Validated s => Getter (s v a) (s '[] a)
unvalidated :: (Validated s, Coercible (s v a) (s '[] a)) => Getter (s v a) (s '[] a)


module Language.Python.Syntax.Ann

-- | Used to mark annotations in data structures, which helps with generic
--   deriving
newtype Ann a
Ann :: a -> Ann a
[getAnn] :: Ann a -> a

-- | Get an annotation and forget the wrapper
annot_ :: HasAnn s => Lens' (s a) a

-- | Classy <a>Lens'</a> for things that are annotated
class HasAnn s
annot :: HasAnn s => Lens' (s a) (Ann a)
instance Data.Functor.Classes.Show1 Language.Python.Syntax.Ann.Ann
instance Data.Functor.Classes.Ord1 Language.Python.Syntax.Ann.Ann
instance Data.Functor.Classes.Eq1 Language.Python.Syntax.Ann.Ann
instance (Language.Python.Syntax.Ann.Ann a1 Data.Type.Equality.~ t) => Control.Lens.Wrapped.Rewrapped (Language.Python.Syntax.Ann.Ann a2) t
instance Control.Lens.Wrapped.Wrapped (Language.Python.Syntax.Ann.Ann a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Language.Python.Syntax.Ann.Ann a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Language.Python.Syntax.Ann.Ann a)
instance Data.Traversable.Traversable Language.Python.Syntax.Ann.Ann
instance Data.Foldable.Foldable Language.Python.Syntax.Ann.Ann
instance GHC.Base.Functor Language.Python.Syntax.Ann.Ann
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Ann.Ann a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Language.Python.Syntax.Ann.Ann a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Ann.Ann a)


module Language.Python.Syntax.Comment

-- | A Python single-line comment, such as on the following line:
--   
--   <pre>
--   y = x + 4 # add four to the value of x
--   </pre>
--   
--   In this case, the structure parsed would be
--   
--   <pre>
--   MkComment () " add four to the value of x"
--   </pre>
--   
--   with the hash being inferred, and the space after the hash being
--   preserved.
--   
--   Python does not have multi-line comments. There is a common convention
--   of using a multi-line string expression as a multi-line comment, since
--   a string expression is a no-op statement. Such multi-line comments are
--   <b>NOT</b> represented with this data type, but rather as normal
--   string expressions (since that's what they are).
data Comment a
MkComment :: Ann a -> String -> Comment a
[_commentAnn] :: Comment a -> Ann a
[_commentValue] :: Comment a -> String
instance Data.Functor.Classes.Ord1 Language.Python.Syntax.Comment.Comment
instance Data.Functor.Classes.Eq1 Language.Python.Syntax.Comment.Comment
instance GHC.Generics.Generic (Language.Python.Syntax.Comment.Comment a)
instance Data.Traversable.Traversable Language.Python.Syntax.Comment.Comment
instance Data.Foldable.Foldable Language.Python.Syntax.Comment.Comment
instance GHC.Base.Functor Language.Python.Syntax.Comment.Comment
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Comment.Comment a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Language.Python.Syntax.Comment.Comment a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Comment.Comment a)
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Comment.Comment


-- | Numerical literal values in Python
module Language.Python.Syntax.Numbers

-- | An integer literal value.
--   
--   <tt>5</tt> is an integer literal.
--   
--   <tt>6.2</tt> is a literal but is not an integer
--   
--   <tt>x</tt> might be an integer, but is not a literal
--   
--   See
--   <a>https://docs.python.org/3.5/reference/lexical_analysis.html#integer-literals</a>
data IntLiteral a

-- | Decimal
--   
--   <pre>
--   1234
--   </pre>
IntLiteralDec :: Ann a -> NonEmpty DecDigit -> IntLiteral a
[_intLiteralAnn] :: IntLiteral a -> Ann a
[_unsafeIntLiteralDecValue] :: IntLiteral a -> NonEmpty DecDigit

-- | Binary
--   
--   <pre>
--   0b10110
--   </pre>
IntLiteralBin :: Ann a -> Bool -> NonEmpty BinDigit -> IntLiteral a
[_intLiteralAnn] :: IntLiteral a -> Ann a
[_unsafeIntLiteralBinUppercase] :: IntLiteral a -> Bool
[_unsafeIntLiteralBinValue] :: IntLiteral a -> NonEmpty BinDigit

-- | Octal
--   
--   <pre>
--   0o1367
--   </pre>
IntLiteralOct :: Ann a -> Bool -> NonEmpty OctDigit -> IntLiteral a
[_intLiteralAnn] :: IntLiteral a -> Ann a
[_unsafeIntLiteralOctUppercase] :: IntLiteral a -> Bool
[_unsafeIntLiteralOctValue] :: IntLiteral a -> NonEmpty OctDigit

-- | Mixed-case hexadecimal
--   
--   <pre>
--   0x18B4f
--   </pre>
IntLiteralHex :: Ann a -> Bool -> NonEmpty HeXDigit -> IntLiteral a
[_intLiteralAnn] :: IntLiteral a -> Ann a
[_unsafeIntLiteralHexUppercase] :: IntLiteral a -> Bool
[_unsafeIntLiteralHexValue] :: IntLiteral a -> NonEmpty HeXDigit

-- | Positive or negative, as in <tt>-7</tt>
data Sign
Pos :: Sign
Neg :: Sign

-- | When a floating point literal is in scientific notation, it includes
--   the character <tt>e</tt>, which can be lower or upper case.
data E
Ee :: E
EE :: E

-- | The exponent of a floating point literal.
--   
--   An <tt>e</tt>, followed by an optional <a>Sign</a>, followed by at
--   least one digit.
data FloatExponent
FloatExponent :: E -> Maybe Sign -> NonEmpty DecDigit -> FloatExponent

-- | A literal floating point value.
--   
--   Eg. <tt>7.63</tt>
--   
--   See
--   <a>https://docs.python.org/3.5/reference/lexical_analysis.html#floating-point-literals</a>
data FloatLiteral a

-- | 'Complete' floats
--   
--   <pre>
--   12.
--   </pre>
--   
--   <pre>
--   12.34
--   </pre>
--   
--   <pre>
--   12.e34
--   </pre>
--   
--   <pre>
--   12.34e56
--   </pre>
FloatLiteralFull :: Ann a -> NonEmpty DecDigit -> Maybe (These (NonEmpty DecDigit) FloatExponent) -> FloatLiteral a
[_floatLiteralAnn] :: FloatLiteral a -> Ann a
[_floatLiteralFullLeft] :: FloatLiteral a -> NonEmpty DecDigit
[_floatLiteralFullRight] :: FloatLiteral a -> Maybe (These (NonEmpty DecDigit) FloatExponent)

-- | Floats that begin with a decimal point
--   
--   <pre>
--   .12
--   </pre>
--   
--   <pre>
--   .12e34
--   </pre>
FloatLiteralPoint :: Ann a -> NonEmpty DecDigit -> Maybe FloatExponent -> FloatLiteral a
[_floatLiteralAnn] :: FloatLiteral a -> Ann a
[_floatLiteralPointRight] :: FloatLiteral a -> NonEmpty DecDigit
[_floatLiteralPointExponent] :: FloatLiteral a -> Maybe FloatExponent

-- | Floats with no decimal points
--   
--   <pre>
--   12e34
--   </pre>
FloatLiteralWhole :: Ann a -> NonEmpty DecDigit -> FloatExponent -> FloatLiteral a
[_floatLiteralAnn] :: FloatLiteral a -> Ann a
[_floatLiteralWholeRight] :: FloatLiteral a -> NonEmpty DecDigit
[_floatLiteralWholeExponent] :: FloatLiteral a -> FloatExponent

-- | Imaginary number literals
--   
--   See
--   <a>https://docs.python.org/3.5/reference/lexical_analysis.html#imaginary-literals</a>
data ImagLiteral a

-- | A decimal integer followed by a 'j'
--   
--   <pre>
--   12j
--   </pre>
ImagLiteralInt :: Ann a -> NonEmpty DecDigit -> Bool -> ImagLiteral a
[_imagLiteralAnn] :: ImagLiteral a -> Ann a
[_unsafeImagLiteralIntValue] :: ImagLiteral a -> NonEmpty DecDigit
[_imagLiteralUppercase] :: ImagLiteral a -> Bool

-- | A float followed by a 'j'
--   
--   <pre>
--   12.j
--   </pre>
--   
--   <pre>
--   12.3j
--   </pre>
--   
--   <pre>
--   .3j
--   </pre>
ImagLiteralFloat :: Ann a -> FloatLiteral a -> Bool -> ImagLiteral a
[_imagLiteralAnn] :: ImagLiteral a -> Ann a
[_unsafeImagLiteralFloatValue] :: ImagLiteral a -> FloatLiteral a
[_imagLiteralUppercase] :: ImagLiteral a -> Bool
showIntLiteral :: IntLiteral a -> Text
showFloatLiteral :: FloatLiteral a -> Text
showFloatExponent :: FloatExponent -> Text
showImagLiteral :: ImagLiteral a -> Text
instance Data.Functor.Classes.Ord1 Language.Python.Syntax.Numbers.ImagLiteral
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Numbers.ImagLiteral
instance Data.Functor.Classes.Eq1 Language.Python.Syntax.Numbers.ImagLiteral
instance GHC.Generics.Generic (Language.Python.Syntax.Numbers.ImagLiteral a)
instance Data.Traversable.Traversable Language.Python.Syntax.Numbers.ImagLiteral
instance Data.Foldable.Foldable Language.Python.Syntax.Numbers.ImagLiteral
instance GHC.Base.Functor Language.Python.Syntax.Numbers.ImagLiteral
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Numbers.ImagLiteral a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Numbers.ImagLiteral a)
instance Data.Functor.Classes.Ord1 Language.Python.Syntax.Numbers.FloatLiteral
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Numbers.FloatLiteral
instance Data.Functor.Classes.Eq1 Language.Python.Syntax.Numbers.FloatLiteral
instance GHC.Generics.Generic (Language.Python.Syntax.Numbers.FloatLiteral a)
instance Data.Traversable.Traversable Language.Python.Syntax.Numbers.FloatLiteral
instance Data.Foldable.Foldable Language.Python.Syntax.Numbers.FloatLiteral
instance GHC.Base.Functor Language.Python.Syntax.Numbers.FloatLiteral
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Numbers.FloatLiteral a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Numbers.FloatLiteral a)
instance GHC.Generics.Generic Language.Python.Syntax.Numbers.FloatExponent
instance GHC.Show.Show Language.Python.Syntax.Numbers.FloatExponent
instance GHC.Classes.Ord Language.Python.Syntax.Numbers.FloatExponent
instance GHC.Classes.Eq Language.Python.Syntax.Numbers.FloatExponent
instance GHC.Generics.Generic Language.Python.Syntax.Numbers.E
instance GHC.Show.Show Language.Python.Syntax.Numbers.E
instance GHC.Classes.Ord Language.Python.Syntax.Numbers.E
instance GHC.Classes.Eq Language.Python.Syntax.Numbers.E
instance GHC.Generics.Generic Language.Python.Syntax.Numbers.Sign
instance GHC.Show.Show Language.Python.Syntax.Numbers.Sign
instance GHC.Classes.Ord Language.Python.Syntax.Numbers.Sign
instance GHC.Classes.Eq Language.Python.Syntax.Numbers.Sign
instance Data.Functor.Classes.Ord1 Language.Python.Syntax.Numbers.IntLiteral
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Numbers.IntLiteral
instance Data.Functor.Classes.Eq1 Language.Python.Syntax.Numbers.IntLiteral
instance GHC.Generics.Generic (Language.Python.Syntax.Numbers.IntLiteral a)
instance Data.Traversable.Traversable Language.Python.Syntax.Numbers.IntLiteral
instance Data.Foldable.Foldable Language.Python.Syntax.Numbers.IntLiteral
instance GHC.Base.Functor Language.Python.Syntax.Numbers.IntLiteral
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Numbers.IntLiteral a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Numbers.IntLiteral a)

module Language.Python.Syntax.Raw

-- | <a>Raw</a> represents unvalidated, un-annotated terms.
type Raw f = f '[] ()


module Language.Python.Syntax.Whitespace

-- | A newline is either a carriage return, a line feed, or a carriage
--   return followed by a line feed.
data Newline
CR :: Newline
LF :: Newline
CRLF :: Newline

-- | Whitespace is either a space, a tab, a newline that continues the
--   logical line (<a>Continued</a>), a newline that ends the logical line
--   (<a>Newline</a>), or a <a>Whitespace</a>.
--   
--   Despite not literally being whitespace, comments inside enclosed forms
--   are treated as whitespace. See
--   <a>https://docs.python.org/3.5/reference/lexical_analysis.html#implicit-line-joining</a>
--   
--   Example and counterexample of comments as whitespace
--   
--   <pre>
--   ( 1 +
--     # here's a comment
--    2 +
--    3 # another comment
--   )
--    
--   </pre>
--   
--   <pre>
--   x = 5 + 5
--   # this line is not considered whitespace
--   y = x * 2
--   </pre>
--   
--   <pre>
--   [ 1
--   , 2 # I'm whitespace
--   , 3
--   # also whitespace
--   ]
--   </pre>
data Whitespace
Space :: Whitespace
Tab :: Whitespace
Continued :: Newline -> [Whitespace] -> Whitespace
Newline :: Newline -> Whitespace
Comment :: Comment () -> Whitespace

-- | Lines which are "blank", meaning that they contain, if anything, only
--   whitespace and/or a comment.
data Blank a
Blank :: Ann a -> [Whitespace] -> Maybe (Comment a) -> Blank a
[_blankAnn] :: Blank a -> Ann a
[_blankWhitespaces] :: Blank a -> [Whitespace]
[_blankComment] :: Blank a -> Maybe (Comment a)

-- | Every syntactic element contains the whitespace that immediately
--   follows it.
--   
--   This type class lets us access this trailing whitespace in many
--   different types throughout hpython.
class HasTrailingWhitespace s
trailingWhitespace :: HasTrailingWhitespace s => Lens' s [Whitespace]

-- | A statement-containing thing may have a trailing newline
--   
--   Some forms <i>always</i> have a trailing newline, which is why this
--   class isn't just <tt>trailingNewline :: <a>Lens'</a> (s v a)
--   (<a>Maybe</a> <a>Newline</a>)</tt>
class HasTrailingNewline (s :: [*] -> * -> *)
trailingNewline :: HasTrailingNewline s => Traversal' (s v a) Newline
setTrailingNewline :: HasTrailingNewline s => s v a -> Newline -> s v a

-- | Python has rules regarding the expansion of tabs into spaces and how
--   to go about computing indentation after this is done.
--   
--   See
--   <a>https://docs.python.org/3.5/reference/lexical_analysis.html#indentation</a>
--   
--   This data structure implements those rules as a monoid.
data IndentLevel
getIndentLevel :: IndentLevel -> Int
indentLevel :: Indent -> Int
absoluteIndentLevel :: Int -> Indent -> Int
newtype Indent
MkIndent :: FingerTree IndentLevel Whitespace -> Indent
[unIndent] :: Indent -> FingerTree IndentLevel Whitespace

-- | An <a>Indent</a> is isomorphic to a list of <a>Whitespace</a>
indentWhitespaces :: Iso' Indent [Whitespace]

-- | Indent some indentation by a chunk
indentIt :: [Whitespace] -> Indents a -> Indents a

-- | Deent some indentation by a chunk
dedentIt :: Indents a -> Indents a

-- | A possibly annotated list of <a>Indent</a>s.
data Indents a
Indents :: [Indent] -> Ann a -> Indents a
[_indentsValue] :: Indents a -> [Indent]
[_indentsAnn] :: Indents a -> Ann a
indentsValue :: forall a_aCu9. Lens' (Indents a_aCu9) [Indent]
indentsAnn :: forall a_aCu9 a_aDy8. Lens (Indents a_aCu9) (Indents a_aDy8) (Ann a_aCu9) (Ann a_aDy8)

-- | Subtract the first argument from the beginning of the second
--   
--   Returns <a>Nothing</a> if the first list is not a prefix of the
--   second.
subtractStart :: Indents a -> Indents a -> Maybe (Indents a)
instance Data.Functor.Classes.Ord1 Language.Python.Syntax.Whitespace.Indents
instance Data.Functor.Classes.Eq1 Language.Python.Syntax.Whitespace.Indents
instance GHC.Generics.Generic (Language.Python.Syntax.Whitespace.Indents a)
instance Data.Traversable.Traversable Language.Python.Syntax.Whitespace.Indents
instance Data.Foldable.Foldable Language.Python.Syntax.Whitespace.Indents
instance GHC.Base.Functor Language.Python.Syntax.Whitespace.Indents
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Whitespace.Indents a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Whitespace.Indents a)
instance GHC.Base.Monoid Language.Python.Syntax.Whitespace.Indent
instance GHC.Base.Semigroup Language.Python.Syntax.Whitespace.Indent
instance GHC.Show.Show Language.Python.Syntax.Whitespace.Indent
instance GHC.Classes.Ord Language.Python.Syntax.Whitespace.Indent
instance GHC.Classes.Eq Language.Python.Syntax.Whitespace.Indent
instance GHC.Base.Monoid Language.Python.Syntax.Whitespace.IndentLevel
instance GHC.Base.Semigroup Language.Python.Syntax.Whitespace.IndentLevel
instance GHC.Generics.Generic (Language.Python.Syntax.Whitespace.Blank a)
instance Data.Traversable.Traversable Language.Python.Syntax.Whitespace.Blank
instance Data.Foldable.Foldable Language.Python.Syntax.Whitespace.Blank
instance GHC.Base.Functor Language.Python.Syntax.Whitespace.Blank
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Whitespace.Blank a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Whitespace.Blank a)
instance GHC.Show.Show Language.Python.Syntax.Whitespace.Whitespace
instance GHC.Classes.Ord Language.Python.Syntax.Whitespace.Whitespace
instance GHC.Classes.Eq Language.Python.Syntax.Whitespace.Whitespace
instance GHC.Show.Show Language.Python.Syntax.Whitespace.Newline
instance GHC.Classes.Ord Language.Python.Syntax.Whitespace.Newline
instance GHC.Classes.Eq Language.Python.Syntax.Whitespace.Newline
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Language.Python.Syntax.Whitespace.Indents a)
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Whitespace.Indents
instance GHC.Exts.IsList Language.Python.Syntax.Whitespace.Indent
instance Data.FingerTree.Measured Language.Python.Syntax.Whitespace.IndentLevel Language.Python.Syntax.Whitespace.Whitespace
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Whitespace.Blank
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace a => Language.Python.Syntax.Whitespace.HasTrailingWhitespace (GHC.Base.NonEmpty a)


-- | Python string literals.
--   
--   See
--   <a>https://docs.python.org/3.5/reference/lexical_analysis.html#string-and-bytes-literals</a>
module Language.Python.Syntax.Strings

-- | A character in a string literal. This is a large sum type, with a
--   catch-all of a Haskell <a>Char</a>.
data PyChar

-- | <pre>
--   \newline
--   </pre>
Char_newline :: PyChar

-- | <pre>
--   \1
--   </pre>
Char_octal1 :: OctDigit -> PyChar

-- | <pre>
--   \12
--   </pre>
Char_octal2 :: OctDigit -> OctDigit -> PyChar

-- | <pre>
--   \123
--   </pre>
Char_octal3 :: OctDigit -> OctDigit -> OctDigit -> PyChar

-- | <pre>
--   \xFb
--   </pre>
Char_hex :: HeXDigit -> HeXDigit -> PyChar

-- | <pre>
--   \u12aD
--   </pre>
Char_uni16 :: HeXDigit -> HeXDigit -> HeXDigit -> HeXDigit -> PyChar

-- | <pre>
--   \Udeadbeef
--   </pre>
Char_uni32 :: HeXDigit -> HeXDigit -> HeXDigit -> HeXDigit -> HeXDigit -> HeXDigit -> HeXDigit -> HeXDigit -> PyChar

-- | <pre>
--   \\
--   </pre>
Char_esc_bslash :: PyChar

-- | <pre>
--   \'
--   </pre>
Char_esc_singlequote :: PyChar

-- | <pre>
--   \"
--   </pre>
Char_esc_doublequote :: PyChar

-- | <pre>
--   \a
--   </pre>
Char_esc_a :: PyChar

-- | <pre>
--   \b
--   </pre>
Char_esc_b :: PyChar

-- | <pre>
--   \f
--   </pre>
Char_esc_f :: PyChar

-- | <pre>
--   \n
--   </pre>
Char_esc_n :: PyChar

-- | <pre>
--   \r
--   </pre>
Char_esc_r :: PyChar

-- | <pre>
--   \t
--   </pre>
Char_esc_t :: PyChar

-- | <pre>
--   \v
--   </pre>
Char_esc_v :: PyChar

-- | Any character
Char_lit :: Char -> PyChar

-- | Convert a Haskell string to a list of <a>PyChar</a>. This is useful
--   when writing Python in Haskell.
fromHaskellString :: String -> [PyChar]

-- | Double or single quotation marks?
--   
--   <pre>
--   "Double quotes"
--   """Double quotes"""
--   'Single quotes'
--   '''Single quotes'''
--   </pre>
data QuoteType
SingleQuote :: QuoteType
DoubleQuote :: QuoteType

-- | Three pairs of quotations or one?
--   
--   <pre>
--   """Long string"""
--   '''Also long string'''
--   "Short string"
--   'Also short string'
--   </pre>
data StringType
ShortString :: StringType
LongString :: StringType

-- | In Python 3.5, a prefix of <tt>u</tt> or <tt>U</tt> is allowed, but
--   doesn't have any meaning. They exist for backwards compatibility with
--   Python 2.
--   
--   See <a>https://www.python.org/dev/peps/pep-0414/</a>
data StringPrefix
Prefix_u :: StringPrefix
Prefix_U :: StringPrefix

-- | Raw strings are prefixed with either <tt>r</tt> or <tt>R</tt>.
data RawStringPrefix
Prefix_r :: RawStringPrefix
Prefix_R :: RawStringPrefix

-- | This prefix indicates it's a bytes literal rather than a string
--   literal.
data BytesPrefix
Prefix_b :: BytesPrefix
Prefix_B :: BytesPrefix

-- | A string of raw bytes can be indicated by a number of prefixes
data RawBytesPrefix
Prefix_br :: RawBytesPrefix
Prefix_Br :: RawBytesPrefix
Prefix_bR :: RawBytesPrefix
Prefix_BR :: RawBytesPrefix
Prefix_rb :: RawBytesPrefix
Prefix_rB :: RawBytesPrefix
Prefix_Rb :: RawBytesPrefix
Prefix_RB :: RawBytesPrefix

-- | Most types of <a>StringLiteral</a> have prefixes. Plain old strings
--   may have an optional prefix, but it is meaningless.
hasPrefix :: StringLiteral a -> Bool

-- | A <a>StringLiteral</a>, complete with a prefix, information about
--   quote type and number, and a list of <a>PyChar</a>s.
--   
--   Like many other data types in hpython, it has an annotation and
--   trailing whitespace.
data StringLiteral a
RawStringLiteral :: Ann a -> RawStringPrefix -> StringType -> QuoteType -> [PyChar] -> [Whitespace] -> StringLiteral a
[_stringLiteralAnn] :: StringLiteral a -> Ann a
[_unsafeRawStringLiteralPrefix] :: StringLiteral a -> RawStringPrefix
[_stringLiteralStringType] :: StringLiteral a -> StringType
[_stringLiteralQuoteType] :: StringLiteral a -> QuoteType
[_stringLiteralValue] :: StringLiteral a -> [PyChar]
[_stringLiteralWhitespace] :: StringLiteral a -> [Whitespace]
StringLiteral :: Ann a -> Maybe StringPrefix -> StringType -> QuoteType -> [PyChar] -> [Whitespace] -> StringLiteral a
[_stringLiteralAnn] :: StringLiteral a -> Ann a
[_unsafeStringLiteralPrefix] :: StringLiteral a -> Maybe StringPrefix
[_stringLiteralStringType] :: StringLiteral a -> StringType
[_stringLiteralQuoteType] :: StringLiteral a -> QuoteType
[_stringLiteralValue] :: StringLiteral a -> [PyChar]
[_stringLiteralWhitespace] :: StringLiteral a -> [Whitespace]
RawBytesLiteral :: Ann a -> RawBytesPrefix -> StringType -> QuoteType -> [PyChar] -> [Whitespace] -> StringLiteral a
[_stringLiteralAnn] :: StringLiteral a -> Ann a
[_unsafeRawBytesLiteralPrefix] :: StringLiteral a -> RawBytesPrefix
[_stringLiteralStringType] :: StringLiteral a -> StringType
[_stringLiteralQuoteType] :: StringLiteral a -> QuoteType
[_stringLiteralValue] :: StringLiteral a -> [PyChar]
[_stringLiteralWhitespace] :: StringLiteral a -> [Whitespace]
BytesLiteral :: Ann a -> BytesPrefix -> StringType -> QuoteType -> [PyChar] -> [Whitespace] -> StringLiteral a
[_stringLiteralAnn] :: StringLiteral a -> Ann a
[_unsafeBytesLiteralPrefix] :: StringLiteral a -> BytesPrefix
[_stringLiteralStringType] :: StringLiteral a -> StringType
[_stringLiteralQuoteType] :: StringLiteral a -> QuoteType
[_stringLiteralValue] :: StringLiteral a -> [PyChar]
[_stringLiteralWhitespace] :: StringLiteral a -> [Whitespace]
stringLiteralStringType :: forall a_aHO9. Lens' (StringLiteral a_aHO9) StringType
stringLiteralQuoteType :: forall a_aHO9. Lens' (StringLiteral a_aHO9) QuoteType
stringLiteralValue :: forall a_aHO9. Lens' (StringLiteral a_aHO9) [PyChar]
stringLiteralWhitespace :: forall a_aHO9. Lens' (StringLiteral a_aHO9) [Whitespace]
showQuoteType :: QuoteType -> Char
showStringPrefix :: StringPrefix -> Text
showRawStringPrefix :: RawStringPrefix -> Text
showBytesPrefix :: BytesPrefix -> Text
showRawBytesPrefix :: RawBytesPrefix -> Text

-- | Determine whether a <a>PyChar</a> is an escape character or not.
isEscape :: PyChar -> Bool
instance GHC.Generics.Generic (Language.Python.Syntax.Strings.StringLiteral a)
instance Data.Traversable.Traversable Language.Python.Syntax.Strings.StringLiteral
instance Data.Foldable.Foldable Language.Python.Syntax.Strings.StringLiteral
instance GHC.Base.Functor Language.Python.Syntax.Strings.StringLiteral
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Strings.StringLiteral a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Language.Python.Syntax.Strings.StringLiteral a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Strings.StringLiteral a)
instance GHC.Generics.Generic Language.Python.Syntax.Strings.PyChar
instance GHC.Show.Show Language.Python.Syntax.Strings.PyChar
instance GHC.Classes.Ord Language.Python.Syntax.Strings.PyChar
instance GHC.Classes.Eq Language.Python.Syntax.Strings.PyChar
instance GHC.Generics.Generic Language.Python.Syntax.Strings.RawBytesPrefix
instance GHC.Show.Show Language.Python.Syntax.Strings.RawBytesPrefix
instance GHC.Classes.Ord Language.Python.Syntax.Strings.RawBytesPrefix
instance GHC.Classes.Eq Language.Python.Syntax.Strings.RawBytesPrefix
instance GHC.Generics.Generic Language.Python.Syntax.Strings.BytesPrefix
instance GHC.Show.Show Language.Python.Syntax.Strings.BytesPrefix
instance GHC.Classes.Ord Language.Python.Syntax.Strings.BytesPrefix
instance GHC.Classes.Eq Language.Python.Syntax.Strings.BytesPrefix
instance GHC.Generics.Generic Language.Python.Syntax.Strings.RawStringPrefix
instance GHC.Show.Show Language.Python.Syntax.Strings.RawStringPrefix
instance GHC.Classes.Ord Language.Python.Syntax.Strings.RawStringPrefix
instance GHC.Classes.Eq Language.Python.Syntax.Strings.RawStringPrefix
instance GHC.Generics.Generic Language.Python.Syntax.Strings.StringPrefix
instance GHC.Show.Show Language.Python.Syntax.Strings.StringPrefix
instance GHC.Classes.Ord Language.Python.Syntax.Strings.StringPrefix
instance GHC.Classes.Eq Language.Python.Syntax.Strings.StringPrefix
instance GHC.Generics.Generic Language.Python.Syntax.Strings.StringType
instance GHC.Show.Show Language.Python.Syntax.Strings.StringType
instance GHC.Classes.Ord Language.Python.Syntax.Strings.StringType
instance GHC.Classes.Eq Language.Python.Syntax.Strings.StringType
instance GHC.Generics.Generic Language.Python.Syntax.Strings.QuoteType
instance GHC.Show.Show Language.Python.Syntax.Strings.QuoteType
instance GHC.Classes.Ord Language.Python.Syntax.Strings.QuoteType
instance GHC.Classes.Eq Language.Python.Syntax.Strings.QuoteType
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Strings.StringLiteral
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Strings.StringLiteral a)


-- | These types are used throughout the syntax tree to help preserve
--   formatting.
module Language.Python.Syntax.Punctuation

-- | A period character, possibly followed by some whitespace.
newtype Dot
MkDot :: [Whitespace] -> Dot

-- | The venerable comma separator
newtype Comma
MkComma :: [Whitespace] -> Comma
newtype Colon
MkColon :: [Whitespace] -> Colon
data Semicolon a
MkSemicolon :: Ann a -> [Whitespace] -> Semicolon a
newtype Equals
MkEquals :: [Whitespace] -> Equals
newtype At
MkAt :: [Whitespace] -> At
instance GHC.Show.Show Language.Python.Syntax.Punctuation.At
instance GHC.Classes.Eq Language.Python.Syntax.Punctuation.At
instance GHC.Show.Show Language.Python.Syntax.Punctuation.Equals
instance GHC.Classes.Eq Language.Python.Syntax.Punctuation.Equals
instance GHC.Generics.Generic (Language.Python.Syntax.Punctuation.Semicolon a)
instance Data.Traversable.Traversable Language.Python.Syntax.Punctuation.Semicolon
instance Data.Foldable.Foldable Language.Python.Syntax.Punctuation.Semicolon
instance GHC.Base.Functor Language.Python.Syntax.Punctuation.Semicolon
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Punctuation.Semicolon a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Punctuation.Semicolon a)
instance GHC.Generics.Generic Language.Python.Syntax.Punctuation.Colon
instance GHC.Show.Show Language.Python.Syntax.Punctuation.Colon
instance GHC.Classes.Eq Language.Python.Syntax.Punctuation.Colon
instance GHC.Generics.Generic Language.Python.Syntax.Punctuation.Comma
instance GHC.Show.Show Language.Python.Syntax.Punctuation.Comma
instance GHC.Classes.Eq Language.Python.Syntax.Punctuation.Comma
instance GHC.Show.Show Language.Python.Syntax.Punctuation.Dot
instance GHC.Classes.Eq Language.Python.Syntax.Punctuation.Dot
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace Language.Python.Syntax.Punctuation.At
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace Language.Python.Syntax.Punctuation.Equals
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Punctuation.Semicolon
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Punctuation.Semicolon a)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace Language.Python.Syntax.Punctuation.Colon
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace Language.Python.Syntax.Punctuation.Comma
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace Language.Python.Syntax.Punctuation.Dot


-- | Unary operators
module Language.Python.Syntax.Operator.Unary

-- | An <a>UnOp</a> is a unary operator in Python, such as <tt>-</tt> for
--   negation. An operator is stored with an annotation and its trailing
--   whitespace.
data UnOp a

-- | <pre>
--   -a
--   </pre>
Negate :: Ann a -> [Whitespace] -> UnOp a

-- | <pre>
--   +a
--   </pre>
Positive :: Ann a -> [Whitespace] -> UnOp a

-- | <pre>
--   ~a
--   </pre>
Complement :: Ann a -> [Whitespace] -> UnOp a
instance GHC.Generics.Generic (Language.Python.Syntax.Operator.Unary.UnOp a)
instance Data.Traversable.Traversable Language.Python.Syntax.Operator.Unary.UnOp
instance Data.Foldable.Foldable Language.Python.Syntax.Operator.Unary.UnOp
instance GHC.Base.Functor Language.Python.Syntax.Operator.Unary.UnOp
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Operator.Unary.UnOp a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Operator.Unary.UnOp a)
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Operator.Unary.UnOp
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Operator.Unary.UnOp a)


-- | This module contains a datatype for binary operators and a precedence
--   table with associated operations. This presentation of operators is
--   simpler and more flexible than hard-coding them into the syntax tree.
module Language.Python.Syntax.Operator.Binary

-- | A Python binary operator, such as <tt>+</tt>, along with its trailing
--   <a>Whitespace</a>
data BinOp a

-- | <pre>
--   a is b
--   </pre>
Is :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a is not b
--   </pre>
IsNot :: Ann a -> [Whitespace] -> [Whitespace] -> BinOp a

-- | <pre>
--   a in b
--   </pre>
In :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a not in b
--   </pre>
NotIn :: Ann a -> [Whitespace] -> [Whitespace] -> BinOp a

-- | <pre>
--   a - b
--   </pre>
Minus :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a ** b
--   </pre>
Exp :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a and b
--   </pre>
BoolAnd :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a or b
--   </pre>
BoolOr :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a == b
--   </pre>
Eq :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a &lt; b
--   </pre>
Lt :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a &lt;= b
--   </pre>
LtEq :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a &gt; b
--   </pre>
Gt :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a &gt;= b
--   </pre>
GtEq :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a != b
--   </pre>
NotEq :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a * b
--   </pre>
Multiply :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a / b
--   </pre>
Divide :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a // b
--   </pre>
FloorDivide :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a % b
--   </pre>
Percent :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a + b
--   </pre>
Plus :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a | b
--   </pre>
BitOr :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a ^ b
--   </pre>
BitXor :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a &amp; b
--   </pre>
BitAnd :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a &lt;&lt; b
--   </pre>
ShiftLeft :: Ann a -> [Whitespace] -> BinOp a

-- | <pre>
--   a &gt;&gt; b
--   </pre>
ShiftRight :: Ann a -> [Whitespace] -> BinOp a

-- | <tt>a </tt> b@
At :: Ann a -> [Whitespace] -> BinOp a

-- | The associativity of an operator. Each operator is either
--   left-associative or right associative.
--   
--   Left associative:
--   
--   <pre>
--   x + y + z = (x + y) + z
--   </pre>
--   
--   Right associative:
--   
--   <pre>
--   x + y + z = x + (y + z)
--   </pre>
data Assoc
L :: Assoc
R :: Assoc

-- | An operator along with its precedence and associativity.
data OpEntry
OpEntry :: BinOp () -> Int -> Assoc -> OpEntry
[_opOperator] :: OpEntry -> BinOp ()
[_opPrec] :: OpEntry -> Int
[_opAssoc] :: OpEntry -> Assoc
opPrec :: Lens' OpEntry Int
opOperator :: Lens' OpEntry (BinOp ())
opAssoc :: Lens' OpEntry Assoc

-- | <a>operatorTable</a> is a list of all operators in ascending order of
--   precedence.
operatorTable :: [OpEntry]

-- | Compare two <a>BinOp</a>s to determine whether they represent the same
--   operator, ignoring annotations and trailing whitespace.
sameOperator :: BinOp a -> BinOp a' -> Bool

-- | Is a <a>BinOp</a> a comparison, such as <tt>&lt;=</tt>
isComparison :: BinOp a -> Bool

-- | Retrieve the information for a given operator from the operator table.
lookupOpEntry :: BinOp a -> [OpEntry] -> OpEntry
instance GHC.Show.Show Language.Python.Syntax.Operator.Binary.Assoc
instance GHC.Classes.Eq Language.Python.Syntax.Operator.Binary.Assoc
instance GHC.Generics.Generic (Language.Python.Syntax.Operator.Binary.BinOp a)
instance Data.Traversable.Traversable Language.Python.Syntax.Operator.Binary.BinOp
instance Data.Foldable.Foldable Language.Python.Syntax.Operator.Binary.BinOp
instance GHC.Base.Functor Language.Python.Syntax.Operator.Binary.BinOp
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Operator.Binary.BinOp a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Operator.Binary.BinOp a)
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.Operator.Binary.BinOp
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Operator.Binary.BinOp a)


module Language.Python.Syntax.Ident

-- | An identifier. Like many types in hpython, it has an optional
--   annotation and tracks its trailing whitespace.
--   
--   <a>Raw</a> <a>Ident</a>s have an <a>IsString</a> instance.
--   
--   See
--   <a>https://docs.python.org/3.5/reference/lexical_analysis.html#identifiers</a>
data Ident (v :: [*]) a
MkIdent :: Ann a -> String -> [Whitespace] -> Ident a
[_identAnn] :: Ident a -> Ann a
[_identValue] :: Ident a -> String
[_identWhitespace] :: Ident a -> [Whitespace]
identAnn :: Lens (Ident v a) (Ident v a) a a
identValue :: Lens (Ident v a) (Ident '[] a) String String
identWhitespace :: Lens (Ident v a) (Ident v a) [Whitespace] [Whitespace]

-- | Determine whether this character could start a valid identifier
isIdentifierStart :: Char -> Bool

-- | Determine whether this character could be part of a valid identifier
isIdentifierChar :: Char -> Bool
instance GHC.Generics.Generic (Language.Python.Syntax.Ident.Ident v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Ident.Ident v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Ident.Ident v)
instance GHC.Base.Functor (Language.Python.Syntax.Ident.Ident v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Ident.Ident v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Ident.Ident v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Ident.Ident v)
instance Data.String.IsString (Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Ident.Ident)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Ident.Ident v a)
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Ident.Ident


-- | Module names, including those qualified by packages.
--   
--   See <a>https://docs.python.org/3.5/tutorial/modules.html#packages</a>
module Language.Python.Syntax.ModuleNames

-- | A module name. It can be a single segment, or a sequence of them which
--   are implicitly separated by period character.
--   
--   <pre>
--   a
--   </pre>
--   
--   <pre>
--   a.b
--   </pre>
data ModuleName v a
ModuleNameOne :: Ann a -> Ident v a -> ModuleName v a
ModuleNameMany :: Ann a -> Ident v a -> Dot -> ModuleName v a -> ModuleName v a

-- | <pre>
--   .a.b
--   </pre>
--   
--   <pre>
--   .
--   </pre>
--   
--   <pre>
--   ...
--   </pre>
--   
--   See
--   <a>https://docs.python.org/3.5/tutorial/modules.html#intra-package-references</a>
data RelativeModuleName v a
RelativeWithName :: Ann a -> [Dot] -> ModuleName v a -> RelativeModuleName v a
Relative :: Ann a -> NonEmpty Dot -> RelativeModuleName v a

-- | Convenience constructor for <a>ModuleName</a>
makeModuleName :: Ident v a -> [([Whitespace], Ident v a)] -> ModuleName v a
instance GHC.Generics.Generic (Language.Python.Syntax.ModuleNames.RelativeModuleName v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.ModuleNames.RelativeModuleName v)
instance Data.Foldable.Foldable (Language.Python.Syntax.ModuleNames.RelativeModuleName v)
instance GHC.Base.Functor (Language.Python.Syntax.ModuleNames.RelativeModuleName v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.ModuleNames.RelativeModuleName v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.ModuleNames.RelativeModuleName v a)
instance GHC.Generics.Generic (Language.Python.Syntax.ModuleNames.ModuleName v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.ModuleNames.ModuleName v)
instance Data.Foldable.Foldable (Language.Python.Syntax.ModuleNames.ModuleName v)
instance GHC.Base.Functor (Language.Python.Syntax.ModuleNames.ModuleName v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.ModuleNames.ModuleName v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.ModuleNames.ModuleName v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.ModuleNames.RelativeModuleName v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.ModuleNames.RelativeModuleName v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.ModuleNames.ModuleName v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.ModuleNames.ModuleName v a)


module Language.Python.Syntax.CommaSep

-- | The venerable comma separator
newtype Comma
MkComma :: [Whitespace] -> Comma

-- | Items separated by commas, with optional whitespace following each
--   comma
data CommaSep a
CommaSepNone :: CommaSep a
CommaSepOne :: a -> CommaSep a
CommaSepMany :: a -> Comma -> CommaSep a -> CommaSep a

-- | Iso to unpack a <a>CommaSep</a>
_CommaSep :: Iso (Maybe (a, [(Comma, a)], Maybe Comma)) (Maybe (b, [(Comma, b)], Maybe Comma)) (CommaSep a) (CommaSep b)

-- | <tt>Traversal</tt> targeting the trailing whitespace in a comma
--   separated list.
--   
--   This can't be an instance of <a>HasTrailingWhitespace</a> because
--   <a>CommaSepNone</a> never has trailing whitespace.
csTrailingWhitespace :: HasTrailingWhitespace a => Traversal' (CommaSep a) [Whitespace]

-- | Appends two comma separated values together.
--   
--   The provided whitespace is to follow the joining comma which is added
appendCommaSep :: [Whitespace] -> CommaSep a -> CommaSep a -> CommaSep a

-- | Convert a maybe to a singleton or nullary <a>CommaSep</a>
maybeToCommaSep :: Maybe a -> CommaSep a

-- | Convert a list to a <a>CommaSep</a>
--   
--   Anywhere where whitespace is ambiguous, this function puts a single
--   space
listToCommaSep :: [a] -> CommaSep a

-- | Non-empty <a>CommaSep</a>
data CommaSep1 a
CommaSepOne1 :: a -> CommaSep1 a
CommaSepMany1 :: a -> Comma -> CommaSep1 a -> CommaSep1 a

-- | Get the first element of a <a>CommaSep1</a>
commaSep1Head :: CommaSep1 a -> a

-- | Appends two non-empty comma separated values together.
--   
--   The provided whitespace is to follow the joining comma which is added
appendCommaSep1 :: [Whitespace] -> CommaSep1 a -> CommaSep1 a -> CommaSep1 a

-- | Convert a <a>NonEmpty</a> to a <a>CommaSep1</a>
--   
--   Anywhere where whitespace is ambiguous, this function puts a single
--   space
listToCommaSep1 :: NonEmpty a -> CommaSep1 a

-- | Attempt to insert comma separators into a list, which will not be
--   terminated by a comma.
--   
--   If the list is empty, <a>Nothing</a> is returned.
listToCommaSep1' :: [a] -> Maybe (CommaSep1' a)

-- | Non-empty <a>CommaSep</a>, optionally terminated by a comma
--   
--   Assumes that the contents consumes trailing whitespace
data CommaSep1' a
CommaSepOne1' :: a -> Maybe Comma -> CommaSep1' a
CommaSepMany1' :: a -> Comma -> CommaSep1' a -> CommaSep1' a

-- | Iso to unpack a <a>CommaSep1'</a>
_CommaSep1' :: Iso (a, [(Comma, a)], Maybe Comma) (b, [(Comma, b)], Maybe Comma) (CommaSep1' a) (CommaSep1' b)
instance GHC.Generics.Generic (Language.Python.Syntax.CommaSep.CommaSep1' a)
instance Data.Traversable.Traversable Language.Python.Syntax.CommaSep.CommaSep1'
instance Data.Foldable.Foldable Language.Python.Syntax.CommaSep.CommaSep1'
instance GHC.Base.Functor Language.Python.Syntax.CommaSep.CommaSep1'
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.CommaSep.CommaSep1' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.CommaSep.CommaSep1' a)
instance GHC.Generics.Generic (Language.Python.Syntax.CommaSep.CommaSep1 a)
instance Data.Traversable.Traversable Language.Python.Syntax.CommaSep.CommaSep1
instance Data.Foldable.Foldable Language.Python.Syntax.CommaSep.CommaSep1
instance GHC.Base.Functor Language.Python.Syntax.CommaSep.CommaSep1
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.CommaSep.CommaSep1 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.CommaSep.CommaSep1 a)
instance GHC.Generics.Generic (Language.Python.Syntax.CommaSep.CommaSep a)
instance Data.Traversable.Traversable Language.Python.Syntax.CommaSep.CommaSep
instance Data.Foldable.Foldable Language.Python.Syntax.CommaSep.CommaSep
instance GHC.Base.Functor Language.Python.Syntax.CommaSep.CommaSep
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.CommaSep.CommaSep a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.CommaSep.CommaSep a)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace s => Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.CommaSep.CommaSep1' s)
instance GHC.Base.Semigroup (Language.Python.Syntax.CommaSep.CommaSep1 a)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace s => Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.CommaSep.CommaSep1 s)
instance GHC.Base.Semigroup (Language.Python.Syntax.CommaSep.CommaSep a)
instance GHC.Base.Monoid (Language.Python.Syntax.CommaSep.CommaSep a)


-- | Syntax used in import statements
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-import-statement</a>
module Language.Python.Syntax.Import

-- | Some data optionally followed by <tt>as <a>ident</a></tt>
--   
--   Used in:
--   
--   <pre>
--   import a as b
--   </pre>
--   
--   <pre>
--   from a import b as c, d as e
--   </pre>
--   
--   <pre>
--   from a import (b as c, d as e)
--   </pre>
data ImportAs e v a
ImportAs :: Ann a -> e v a -> Maybe (NonEmpty Whitespace, Ident v a) -> ImportAs e v a
[_importAsAnn] :: ImportAs e v a -> Ann a
[_importAsName] :: ImportAs e v a -> e v a
[_importAsQual] :: ImportAs e v a -> Maybe (NonEmpty Whitespace, Ident v a)

-- | The targets of a <tt>from ... import ...</tt> statement
data ImportTargets v a

-- | <pre>
--   from x import *
--   </pre>
ImportAll :: Ann a -> [Whitespace] -> ImportTargets v a

-- | <pre>
--   from x import a, b, c
--   </pre>
ImportSome :: Ann a -> CommaSep1 (ImportAs Ident v a) -> ImportTargets v a

-- | <pre>
--   from x import (a, b, c)
--   </pre>
ImportSomeParens :: Ann a -> [Whitespace] -> CommaSep1' (ImportAs Ident v a) -> [Whitespace] -> ImportTargets v a
importAsAnn :: Lens' (ImportAs e v a) a
importAsName :: Validated e => Lens (ImportAs e v a) (ImportAs e' '[] a) (e v a) (e' '[] a)
importAsQual :: Validated e => Lens (ImportAs e v a) (ImportAs e '[] a) (Maybe (NonEmpty Whitespace, Ident v a)) (Maybe (NonEmpty Whitespace, Ident '[] a))
instance GHC.Generics.Generic (Language.Python.Syntax.Import.ImportTargets v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Import.ImportTargets v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Import.ImportTargets v)
instance GHC.Base.Functor (Language.Python.Syntax.Import.ImportTargets v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Import.ImportTargets v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Import.ImportTargets v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Import.ImportAs e v a)
instance Data.Traversable.Traversable (e v) => Data.Traversable.Traversable (Language.Python.Syntax.Import.ImportAs e v)
instance Data.Foldable.Foldable (e v) => Data.Foldable.Foldable (Language.Python.Syntax.Import.ImportAs e v)
instance GHC.Base.Functor (e v) => GHC.Base.Functor (Language.Python.Syntax.Import.ImportAs e v)
instance (GHC.Show.Show a, GHC.Show.Show (e v a)) => GHC.Show.Show (Language.Python.Syntax.Import.ImportAs e v a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq (e v a)) => GHC.Classes.Eq (Language.Python.Syntax.Import.ImportAs e v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Import.ImportTargets v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Import.ImportTargets v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Import.ImportAs e v)
instance Language.Python.Optics.Validated.Validated e => Language.Python.Optics.Validated.Validated (Language.Python.Syntax.Import.ImportAs e)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (e v a) => Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Import.ImportAs e v a)


module Language.Python.Syntax.Expr

-- | This large sum type covers all valid Python <i>expressions</i>
data Expr (v :: [*]) a

-- | <pre>
--   ()
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#parenthesized-forms</a>
Unit :: Ann a -> [Whitespace] -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeUnitWhitespaceInner] :: Expr a -> [Whitespace]
[_unsafeUnitWhitespaceRight] :: Expr a -> [Whitespace]

-- | <pre>
--   lambda x, y: x
--   </pre>
--   
--   <a>https://docs.python.org/3/reference/expressions.html#lambda</a>
Lambda :: Ann a -> [Whitespace] -> CommaSep (Param v a) -> Colon -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeLambdaWhitespace] :: Expr a -> [Whitespace]
[_unsafeLambdaArgs] :: Expr a -> CommaSep (Param v a)
[_unsafeLambdaColon] :: Expr a -> Colon
[_unsafeLambdaBody] :: Expr a -> Expr v a

-- | <pre>
--   yield
--   </pre>
--   
--   <pre>
--   yield a
--   </pre>
--   
--   <pre>
--   yield a, b
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#yield-expressions</a>
Yield :: Ann a -> [Whitespace] -> CommaSep (Expr v a) -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeYieldWhitespace] :: Expr a -> [Whitespace]
[_unsafeYieldValue] :: Expr a -> CommaSep (Expr v a)

-- | <pre>
--   yield from a
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#yield-expressions</a>
YieldFrom :: Ann a -> [Whitespace] -> [Whitespace] -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeYieldWhitespace] :: Expr a -> [Whitespace]
[_unsafeFromWhitespace] :: Expr a -> [Whitespace]
[_unsafeYieldFromValue] :: Expr a -> Expr v a

-- | <pre>
--   a if b else c
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#conditional-expressions</a>
Ternary :: Ann a -> Expr v a -> [Whitespace] -> Expr v a -> [Whitespace] -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeTernaryValue] :: Expr a -> Expr v a
[_unsafeTernaryWhitespaceIf] :: Expr a -> [Whitespace]
[_unsafeTernaryCond] :: Expr a -> Expr v a
[_unsafeTernaryWhitespaceElse] :: Expr a -> [Whitespace]
[_unsafeTernaryElse] :: Expr a -> Expr v a

-- | <pre>
--   [a for b in c if d]
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#list-displays</a>
ListComp :: Ann a -> [Whitespace] -> Comprehension Expr v a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeListCompWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeListCompValue] :: Expr a -> Comprehension Expr v a
[_unsafeListCompWhitespaceRight] :: Expr a -> [Whitespace]

-- | <pre>
--   [a, b, c]
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#list-displays</a>
List :: Ann a -> [Whitespace] -> Maybe (CommaSep1' (ListItem v a)) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeListWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeListValues] :: Expr a -> Maybe (CommaSep1' (ListItem v a))
[_unsafeListWhitespaceRight] :: Expr a -> [Whitespace]

-- | <pre>
--   {a: b for c in d if e}
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#dictionary-displays</a>
DictComp :: Ann a -> [Whitespace] -> Comprehension DictItem v a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeDictCompWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeDictCompValue] :: Expr a -> Comprehension DictItem v a
[_unsafeDictCompWhitespaceRight] :: Expr a -> [Whitespace]

-- | <pre>
--   {}
--   </pre>
--   
--   <pre>
--   {a: 1, b: 2, c: 3}
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#dictionary-displays</a>
Dict :: Ann a -> [Whitespace] -> Maybe (CommaSep1' (DictItem v a)) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeDictWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeDictValues] :: Expr a -> Maybe (CommaSep1' (DictItem v a))
[_unsafeDictWhitespaceRight] :: Expr a -> [Whitespace]

-- | <pre>
--   {a for b in c if d}
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#set-displays</a>
SetComp :: Ann a -> [Whitespace] -> Comprehension SetItem v a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeSetCompWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeSetCompValue] :: Expr a -> Comprehension SetItem v a
[_unsafeSetCompWhitespaceRight] :: Expr a -> [Whitespace]

-- | <pre>
--   {a, b, c}
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#set-displays</a>
Set :: Ann a -> [Whitespace] -> CommaSep1' (SetItem v a) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeSetWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeSetValues] :: Expr a -> CommaSep1' (SetItem v a)
[_unsafeSetWhitespaceRight] :: Expr a -> [Whitespace]

-- | <pre>
--   a.b
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#attribute-references</a>
Deref :: Ann a -> Expr v a -> [Whitespace] -> Ident v a -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeDerefValueLeft] :: Expr a -> Expr v a
[_unsafeDerefWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeDerefValueRight] :: Expr a -> Ident v a

-- | <pre>
--   a[b]
--   </pre>
--   
--   <pre>
--   a[:]
--   </pre>
--   
--   <pre>
--   a[:, b:]
--   </pre>
--   
--   etc.
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#subscriptions</a>
Subscript :: Ann a -> Expr v a -> [Whitespace] -> CommaSep1' (Subscript v a) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeSubscriptValueLeft] :: Expr a -> Expr v a
[_unsafeSubscriptWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeSubscriptValueRight] :: Expr a -> CommaSep1' (Subscript v a)
[_unsafeSubscriptWhitespaceRight] :: Expr a -> [Whitespace]

-- | <pre>
--   f(x)
--   </pre>
--   
--   <a>https://docs.python.org/3/reference/expressions.html#calls</a>
Call :: Ann a -> Expr v a -> [Whitespace] -> Maybe (CommaSep1' (Arg v a)) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeCallFunction] :: Expr a -> Expr v a
[_unsafeCallWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeCallArguments] :: Expr a -> Maybe (CommaSep1' (Arg v a))
[_unsafeCallWhitespaceRight] :: Expr a -> [Whitespace]

-- | <pre>
--   None
--   </pre>
--   
--   <a>https://docs.python.org/3/library/constants.html#None</a>
None :: Ann a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeNoneWhitespace] :: Expr a -> [Whitespace]

-- | <pre>
--   ...
--   </pre>
--   
--   <a>https://docs.python.org/3/library/constants.html#Ellipsis</a>
Ellipsis :: Ann a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeEllipsisWhitespace] :: Expr a -> [Whitespace]

-- | <pre>
--   a + b
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#the-power-operator</a>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations</a>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#shifting-operations</a>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#binary-bitwise-operations</a>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#comparisons</a>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#membership-test-operations</a>
--   
--   <a>https://docs.python.org/3/reference/expressions.html#is-not</a>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#boolean-operations</a>
BinOp :: Ann a -> Expr v a -> BinOp a -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> Ann a
[_unsafeBinOpExprLeft] :: Expr a -> Expr v a
[_unsafeBinOpOp] :: Expr a -> BinOp a
[_unsafeBinOpExprRight] :: Expr a -> Expr v a

-- | <pre>
--   -a
--   </pre>
--   
--   <pre>
--   ~a
--   </pre>
--   
--   <pre>
--   +a
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#unary-arithmetic-and-bitwise-operations</a>
UnOp :: Ann a -> UnOp a -> Expr v a -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeUnOpOp] :: Expr a -> UnOp a
[_unsafeUnOpValue] :: Expr a -> Expr v a
Parens :: Ann a -> [Whitespace] -> Expr v a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeParensWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeParensValue] :: Expr a -> Expr v a
[_unsafeParensWhitespaceAfter] :: Expr a -> [Whitespace]

-- | <pre>
--   a
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#atom-identifiers</a>
Ident :: Ann a -> Ident v a -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeIdentValue] :: Expr a -> Ident v a

-- | <pre>
--   1
--   </pre>
--   
--   @0xF3A
--   
--   @0o177
--   
--   <pre>
--   0b1011
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/lexical_analysis.html#grammar-token-integer</a>
Int :: Ann a -> IntLiteral a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeIntValue] :: Expr a -> IntLiteral a
[_unsafeIntWhitespace] :: Expr a -> [Whitespace]

-- | <pre>
--   1.
--   </pre>
--   
--   <pre>
--   3.14
--   </pre>
--   
--   <pre>
--   10e100
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals</a>
Float :: Ann a -> FloatLiteral a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeFloatValue] :: Expr a -> FloatLiteral a
[_unsafeFloatWhitespace] :: Expr a -> [Whitespace]

-- | <pre>
--   10j
--   </pre>
--   
--   <pre>
--   5.j
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals</a>
Imag :: Ann a -> ImagLiteral a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeImagValue] :: Expr a -> ImagLiteral a
[_unsafeImagWhitespace] :: Expr a -> [Whitespace]

-- | <pre>
--   True
--   </pre>
--   
--   <pre>
--   False
--   </pre>
--   
--   <a>https://docs.python.org/3/library/constants.html#True</a>
--   
--   <a>https://docs.python.org/3/library/constants.html#False</a>
Bool :: Ann a -> Bool -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeBoolValue] :: Expr a -> Bool
[_unsafeBoolWhitespace] :: Expr a -> [Whitespace]

-- | <pre>
--   "asdf"
--   </pre>
--   
--   <pre>
--   b"asdf"
--   </pre>
--   
--   <pre>
--   "asdf" 'asdf'
--   </pre>
--   
--   <pre>
--   '''asdf'''
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/lexical_analysis.html#grammar-token-stringliteral</a>
String :: Ann a -> NonEmpty (StringLiteral a) -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeStringValue] :: Expr a -> NonEmpty (StringLiteral a)

-- | <pre>
--   a, b, c
--   </pre>
--   
--   <pre>
--   (a, b)
--   </pre>
--   
--   <pre>
--   (a,)
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#expression-lists</a>
Tuple :: Ann a -> TupleItem v a -> Comma -> Maybe (CommaSep1' (TupleItem v a)) -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeTupleHead] :: Expr a -> TupleItem v a
[_unsafeTupleWhitespace] :: Expr a -> Comma
[_unsafeTupleTail] :: Expr a -> Maybe (CommaSep1' (TupleItem v a))

-- | <pre>
--   not a
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#boolean-operations</a>
Not :: Ann a -> [Whitespace] -> Expr v a -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeNotWhitespace] :: Expr a -> [Whitespace]
[_unsafeNotValue] :: Expr a -> Expr v a

-- | <pre>
--   (a for b in c)
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#generator-expressions</a>
Generator :: Ann a -> Comprehension Expr v a -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_generatorValue] :: Expr a -> Comprehension Expr v a

-- | <pre>
--   await a
--   </pre>
--   
--   <a>https://docs.python.org/3/reference/expressions.html#await</a>
Await :: Ann a -> [Whitespace] -> Expr v a -> Expr a
[_exprAnn] :: Expr a -> Ann a
[_unsafeAwaitWhitespace] :: Expr a -> [Whitespace]
[_unsafeAwaitValue] :: Expr a -> Expr v a

-- | <a>Traversal</a> over all the expressions in a term
class HasExprs s
_Exprs :: HasExprs s => Traversal (s v a) (s '[] a) (Expr v a) (Expr '[] a)

-- | <tt>shouldGroupLeft op left</tt> returns true if <tt>left</tt> needs
--   to be parenthesised when it is the left argument of <tt>op</tt>
shouldGroupLeft :: BinOp a -> Expr v a -> Bool

-- | <tt>shouldGroupRight op right</tt> returns true if <tt>right</tt>
--   needs to be parenthesised when it is the right argument of <tt>op</tt>
shouldGroupRight :: BinOp a -> Expr v a -> Bool

-- | Formal parameters for functions
--   
--   See
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#function-definitions</a>
data Param (v :: [*]) a

-- | <pre>
--   def foo(a):
--   </pre>
PositionalParam :: Ann a -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> Ann a
[_paramName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)

-- | <pre>
--   def foo(bar=None):
--   </pre>
KeywordParam :: Ann a -> Ident v a -> Maybe (Colon, Expr v a) -> [Whitespace] -> Expr v a -> Param a
[_paramAnn] :: Param a -> Ann a
[_paramName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)
[_unsafeKeywordParamWhitespaceRight] :: Param a -> [Whitespace]
[_unsafeKeywordParamExpr] :: Param a -> Expr v a

-- | <pre>
--   def foo(*xs):
--   </pre>
StarParam :: Ann a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> Ann a
[_unsafeStarParamWhitespace] :: Param a -> [Whitespace]
[_unsafeStarParamName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)

-- | <pre>
--   def foo(*):
--   </pre>
UnnamedStarParam :: Ann a -> [Whitespace] -> Param a
[_paramAnn] :: Param a -> Ann a
[_unsafeUnnamedStarParamWhitespace] :: Param a -> [Whitespace]

-- | <pre>
--   def foo(**dict):
--   </pre>
DoubleStarParam :: Ann a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> Ann a
[_unsafeDoubleStarParamWhitespace] :: Param a -> [Whitespace]
[_paramName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)

-- | Lens on the syntrax tree annotation on a parameter
paramAnn :: Lens' (Param v a) a

-- | A faux-lens on the optional Python type annotation which may follow a
--   parameter
--   
--   This is not a lawful <a>Lens</a> because setting an
--   <tt>UnnamedStarParam'</tt>s type won't have any effect.
--   
--   This optic, like many others in hpython, loses validation information
--   (the <tt>v</tt> type parameter)
--   
--   The following is an example, where <tt>int</tt> is the paramtype:
--   
--   <pre>
--   def foo(x: int):
--   </pre>
paramType_ :: Functor f => (Maybe (Colon, Expr v a) -> f (Maybe (Colon, Expr '[] a))) -> Param v a -> f (Param '[] a)

-- | <a>Traversal</a> targeting the Python type annotations which may
--   follow a parameter
paramType :: Traversal (Param v a) (Param '[] a) (Colon, Expr v a) (Colon, Expr '[] a)

-- | (affine) <a>Traversal</a> on the name of a parameter
--   
--   The name is <tt>x</tt> in the following examples:
--   
--   <pre>
--   def foo(x):
--   def foo(x=None):
--   def foo(*x):
--   def foo(**x):
--   </pre>
--   
--   But the following example does not have a <a>paramName</a>:
--   
--   <pre>
--   def foo(*):
--   </pre>
paramName :: Traversal (Param v a) (Param '[] a) (Ident v a) (Ident '[] a)

-- | Actual parameters for functions
--   
--   In the following examples, <tt>x</tt> is an actual parameter.
--   
--   <pre>
--   y = foo(x)
--   y = bar(quux=x)
--   y = baz(*x)
--   y = flux(**x)
--   </pre>
data Arg (v :: [*]) a
PositionalArg :: Ann a -> Expr v a -> Arg a
[_argAnn] :: Arg a -> Ann a
[_argExpr] :: Arg a -> Expr v a
KeywordArg :: Ann a -> Ident v a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> Ann a
[_unsafeKeywordArgName] :: Arg a -> Ident v a
[_unsafeKeywordArgWhitespaceRight] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a
StarArg :: Ann a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> Ann a
[_unsafeStarArgWhitespace] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a
DoubleStarArg :: Ann a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> Ann a
[_unsafeDoubleStarArgWhitespace] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a

-- | Lens on the Python expression which is passed as the argument
argExpr :: Lens (Arg v a) (Arg '[] a) (Expr v a) (Expr '[] a)

-- | A Python for comprehension, such as
--   
--   <pre>
--   x for y in z
--   </pre>
data Comprehension e (v :: [*]) a

-- | <a>expr</a> <a>comp_for</a> (comp_for | comp_if)*
Comprehension :: Ann a -> e v a -> CompFor v a -> [Either (CompFor v a) (CompIf v a)] -> Comprehension e a

-- | A condition inside a comprehension, e.g. <tt>[x for x in xs if
--   even(x)]</tt>
data CompIf (v :: [*]) a
CompIf :: Ann a -> [Whitespace] -> Expr v a -> CompIf a

-- | A nested comprehesion, e.g. <tt>[(x, y) for x in xs for y in ys]</tt>
data CompFor (v :: [*]) a
CompFor :: Ann a -> [Whitespace] -> Expr v a -> [Whitespace] -> Expr v a -> CompFor a

-- | <tt>a : b</tt> or <tt>**a</tt>
--   
--   Used to construct dictionaries, e.g. <tt>{ 1: a, 2: b, **c }</tt>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#dictionary-displays</a>
data DictItem (v :: [*]) a
DictItem :: Ann a -> Expr v a -> Colon -> Expr v a -> DictItem a
[_dictItemAnn] :: DictItem a -> Ann a
[_unsafeDictItemKey] :: DictItem a -> Expr v a
[_unsafeDictItemColon] :: DictItem a -> Colon
[_unsafeDictItemValue] :: DictItem a -> Expr v a
DictUnpack :: Ann a -> [Whitespace] -> Expr v a -> DictItem a
[_dictItemAnn] :: DictItem a -> Ann a
[_unsafeDictItemUnpackWhitespace] :: DictItem a -> [Whitespace]
[_unsafeDictItemUnpackValue] :: DictItem a -> Expr v a

-- | <tt>a</tt> or <tt>*a</tt>
--   
--   Used to construct lists, e.g. <tt>[ 1, <tt>x</tt>, **c ]</tt>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#list-displays</a>
data ListItem (v :: [*]) a
ListItem :: Ann a -> Expr v a -> ListItem a
[_listItemAnn] :: ListItem a -> Ann a
[_unsafeListItemValue] :: ListItem a -> Expr v a
ListUnpack :: Ann a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> ListItem a
[_listItemAnn] :: ListItem a -> Ann a
[_unsafeListUnpackParens] :: ListItem a -> [([Whitespace], [Whitespace])]
[_unsafeListUnpackWhitespace] :: ListItem a -> [Whitespace]
[_unsafeListUnpackValue] :: ListItem a -> Expr v a

-- | <tt>a</tt> or <tt>*a</tt>
--   
--   Used to construct sets, e.g. <tt>{ 1, <tt>x</tt>, **c }</tt>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#set-displays</a>
data SetItem (v :: [*]) a
SetItem :: Ann a -> Expr v a -> SetItem a
[_setItemAnn] :: SetItem a -> Ann a
[_unsafeSetItemValue] :: SetItem a -> Expr v a
SetUnpack :: Ann a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> SetItem a
[_setItemAnn] :: SetItem a -> Ann a
[_unsafeSetUnpackParens] :: SetItem a -> [([Whitespace], [Whitespace])]
[_unsafeSetUnpackWhitespace] :: SetItem a -> [Whitespace]
[_unsafeSetUnpackValue] :: SetItem a -> Expr v a

-- | <tt>a</tt> or <tt>*a</tt>
--   
--   Used to construct tuples, e.g. <tt>(1, <tt>x</tt>, **c)</tt>
data TupleItem (v :: [*]) a
TupleItem :: Ann a -> Expr v a -> TupleItem a
[_tupleItemAnn] :: TupleItem a -> Ann a
[_unsafeTupleItemValue] :: TupleItem a -> Expr v a
TupleUnpack :: Ann a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> TupleItem a
[_tupleItemAnn] :: TupleItem a -> Ann a
[_unsafeTupleUnpackParens] :: TupleItem a -> [([Whitespace], [Whitespace])]
[_unsafeTupleUnpackWhitespace] :: TupleItem a -> [Whitespace]
[_unsafeTupleUnpackValue] :: TupleItem a -> Expr v a

-- | Syntax for things that can be used as subscripts (inside the square
--   brackets)
--   
--   e.g.
--   
--   <pre>
--   a[b]
--   </pre>
--   
--   <pre>
--   a[:]
--   </pre>
--   
--   <pre>
--   a[b:]
--   </pre>
--   
--   <pre>
--   a[:b]
--   </pre>
--   
--   <pre>
--   a[b:c]
--   </pre>
--   
--   <pre>
--   a[b:c:d]
--   </pre>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#subscriptions</a>
data Subscript (v :: [*]) a
SubscriptExpr :: Expr v a -> Subscript a
SubscriptSlice :: Maybe (Expr v a) -> Colon -> Maybe (Expr v a) -> Maybe (Colon, Maybe (Expr v a)) -> Subscript a
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.Param v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.Param v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.Param v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.Param v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.Param v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.Param v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.Arg v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.Arg v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.Arg v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.Arg v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.Arg v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.Arg v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.CompIf v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.CompIf v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.CompIf v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.CompIf v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.CompIf v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.CompIf v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.CompFor v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.CompFor v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.CompFor v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.CompFor v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.CompFor v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.CompFor v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.Comprehension e v a)
instance (GHC.Show.Show a, GHC.Show.Show (e v a)) => GHC.Show.Show (Language.Python.Syntax.Expr.Comprehension e v a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq (e v a)) => GHC.Classes.Eq (Language.Python.Syntax.Expr.Comprehension e v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.DictItem v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.DictItem v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.DictItem v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.DictItem v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.DictItem v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.DictItem v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.Subscript v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.Subscript v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.Subscript v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.Subscript v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.Subscript v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.Subscript v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.ListItem v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.ListItem v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.ListItem v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.ListItem v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.ListItem v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.ListItem v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.SetItem v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.SetItem v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.SetItem v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.SetItem v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.SetItem v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.SetItem v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.TupleItem v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.TupleItem v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.TupleItem v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.TupleItem v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.TupleItem v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.TupleItem v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Expr.Expr v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Expr.Expr v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Expr.Expr v)
instance GHC.Base.Functor (Language.Python.Syntax.Expr.Expr v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Expr.Expr v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Expr.Expr v a)
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Expr.Param
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Expr.Arg
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Expr.ListItem
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Expr.SetItem
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Expr.TupleItem
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Expr.Expr
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Expr.Expr
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Expr.Param
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Expr.Arg
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Expr.DictItem
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Expr.SetItem
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Expr.TupleItem
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Expr.ListItem
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.Param v)
instance Data.String.IsString (Language.Python.Syntax.Expr.Param '[] ())
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.Param v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.Arg v)
instance Data.String.IsString (Language.Python.Syntax.Expr.Arg '[] ())
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.Comprehension e v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.Comprehension e v a)
instance GHC.Base.Functor (e v) => GHC.Base.Functor (Language.Python.Syntax.Expr.Comprehension e v)
instance Data.Foldable.Foldable (e v) => Data.Foldable.Foldable (Language.Python.Syntax.Expr.Comprehension e v)
instance Data.Traversable.Traversable (e v) => Data.Traversable.Traversable (Language.Python.Syntax.Expr.Comprehension e v)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.CompIf v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.CompIf v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.CompFor v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.CompFor v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.DictItem v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.DictItem v a)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.Subscript v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.ListItem v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.ListItem v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.SetItem v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.SetItem v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.TupleItem v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.TupleItem v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Expr.Expr v)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.Expr v a)
instance Data.String.IsString (Language.Python.Syntax.Expr.Expr '[] ())
instance GHC.Num.Num (Language.Python.Syntax.Expr.Expr '[] ())
instance Control.Lens.Plated.Plated (Language.Python.Syntax.Expr.Expr '[] a)


module Language.Python.Syntax.AugAssign

-- | Augmented assignments (PEP 203), such as:
--   
--   <pre>
--   x += y
--   </pre>
--   
--   or
--   
--   <pre>
--   x &lt;&lt;= 8
--   </pre>
--   
--   An <a>AugAssign</a> has an <a>AugAssignOp</a> and trailing whitespace.
--   There is an optional annotation, which can simply be <tt>()</tt> if no
--   annotation is desired.
data AugAssign a
MkAugAssign :: Ann a -> AugAssignOp -> [Whitespace] -> AugAssign a
[_augAssignAnn] :: AugAssign a -> Ann a
[_augAssignType] :: AugAssign a -> AugAssignOp
[_augAssignWhitespace] :: AugAssign a -> [Whitespace]

-- | Augmented assignment operators
data AugAssignOp

-- | <pre>
--   +=
--   </pre>
PlusEq :: AugAssignOp

-- | <pre>
--   -=
--   </pre>
MinusEq :: AugAssignOp

-- | <pre>
--   *=
--   </pre>
StarEq :: AugAssignOp

-- | <pre>
--   @=
--   </pre>
AtEq :: AugAssignOp

-- | <pre>
--   /=
--   </pre>
SlashEq :: AugAssignOp

-- | <pre>
--   %=
--   </pre>
PercentEq :: AugAssignOp

-- | <pre>
--   &amp;=
--   </pre>
AmpersandEq :: AugAssignOp

-- | <pre>
--   |=
--   </pre>
PipeEq :: AugAssignOp

-- | <pre>
--   ^=
--   </pre>
CaretEq :: AugAssignOp

-- | <pre>
--   &lt;&lt;=
--   </pre>
ShiftLeftEq :: AugAssignOp

-- | <pre>
--   &gt;&gt;=
--   </pre>
ShiftRightEq :: AugAssignOp

-- | <pre>
--   **=
--   </pre>
DoubleStarEq :: AugAssignOp

-- | <pre>
--   //=
--   </pre>
DoubleSlashEq :: AugAssignOp
instance GHC.Generics.Generic (Language.Python.Syntax.AugAssign.AugAssign a)
instance Data.Traversable.Traversable Language.Python.Syntax.AugAssign.AugAssign
instance Data.Foldable.Foldable Language.Python.Syntax.AugAssign.AugAssign
instance GHC.Base.Functor Language.Python.Syntax.AugAssign.AugAssign
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.AugAssign.AugAssign a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.AugAssign.AugAssign a)
instance GHC.Show.Show Language.Python.Syntax.AugAssign.AugAssignOp
instance GHC.Classes.Eq Language.Python.Syntax.AugAssign.AugAssignOp
instance Language.Python.Syntax.Ann.HasAnn Language.Python.Syntax.AugAssign.AugAssign
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.AugAssign.AugAssign a)


module Language.Python.Syntax.Statement

-- | A <a>Statement</a> is either a <a>SmallStatement</a> or a
--   <a>Statement</a>
--   
--   
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#compound-statements</a>
data Statement (v :: [*]) a
SmallStatement :: Indents a -> SmallStatement v a -> Statement a
CompoundStatement :: CompoundStatement v a -> Statement a

-- | <a>Traversal</a> over all the <a>Statement</a>s in a term
class HasStatements s
_Statements :: HasStatements s => Traversal (s v a) (s '[] a) (Statement v a) (Statement '[] a)

-- | Decorators on function definitions
--   
--   
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#function-definitions</a>
--   
--   <a>https://docs.python.org/3.5/glossary.html#term-decorator</a>
data Decorator (v :: [*]) a
Decorator :: Ann a -> Indents a -> At -> Expr v a -> Maybe (Comment a) -> Newline -> [(Blank a, Newline)] -> Decorator a
[_decoratorAnn] :: Decorator a -> Ann a

-- | Preceding indentation
[_decoratorIndents] :: Decorator a -> Indents a

-- | <pre>
--   '@' &lt;spaces&gt;
--   </pre>
[_decoratorAt] :: Decorator a -> At

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_decoratorExpr] :: Decorator a -> Expr v a

-- | Trailing comment
[_decoratorComment] :: Decorator a -> Maybe (Comment a)

-- | Trailing newline
[_decoratorNewline] :: Decorator a -> Newline

-- | Trailing blank lines
[_decoratorBlankLines] :: Decorator a -> [(Blank a, Newline)]

-- | See <a>https://docs.python.org/3.5/reference/compound_stmts.html</a>
data CompoundStatement (v :: [*]) a

-- | 
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#function-definitions</a>
--   
--   
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#coroutine-function-definition</a>
Fundef :: Ann a -> [Decorator v a] -> Indents a -> Maybe (NonEmpty Whitespace) -> NonEmpty Whitespace -> Ident v a -> [Whitespace] -> CommaSep (Param v a) -> [Whitespace] -> Maybe ([Whitespace], Expr v a) -> Suite v a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> Ann a

-- | Preceding <a>Decorator</a>s
[_unsafeCsFundefDecorators] :: CompoundStatement a -> [Decorator v a]

-- | Preceding indentation
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   ['async' &lt;spaces&gt;]
--   </pre>
[_unsafeCsFundefAsync] :: CompoundStatement a -> Maybe (NonEmpty Whitespace)

-- | <pre>
--   'def' &lt;spaces&gt;
--   </pre>
[_unsafeCsFundefDef] :: CompoundStatement a -> NonEmpty Whitespace

-- | <pre>
--   &lt;ident&gt;
--   </pre>
[_unsafeCsFundefName] :: CompoundStatement a -> Ident v a

-- | <pre>
--   '(' &lt;spaces&gt;
--   </pre>
[_unsafeCsFundefLeftParen] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;parameters&gt;
--   </pre>
[_unsafeCsFundefParameters] :: CompoundStatement a -> CommaSep (Param v a)

-- | <pre>
--   ')' &lt;spaces&gt;
--   </pre>
[_unsafeCsFundefRightParen] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   ['-&gt;' &lt;spaces&gt; &lt;expr&gt;]
--   </pre>
[_unsafeCsFundefReturnType] :: CompoundStatement a -> Maybe ([Whitespace], Expr v a)

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsFundefBody] :: CompoundStatement a -> Suite v a

-- | 
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-if-statement</a>
If :: Ann a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> [(Indents a, [Whitespace], Expr v a, Suite v a)] -> Maybe (Indents a, [Whitespace], Suite v a) -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> Ann a

-- | Preceding indentation
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'if' &lt;spaces&gt;
--   </pre>
[_unsafeCsIfIf] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_unsafeCsIfCond] :: CompoundStatement a -> Expr v a

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsIfBody] :: CompoundStatement a -> Suite v a

-- | <pre>
--   ('elif' &lt;spaces&gt; &lt;expr&gt; &lt;suite&gt;)*
--   </pre>
[_unsafeCsIfElifs] :: CompoundStatement a -> [(Indents a, [Whitespace], Expr v a, Suite v a)]

-- | <pre>
--   ['else' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsIfElse] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite v a)

-- | 
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-while-statement</a>
While :: Ann a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> Maybe (Indents a, [Whitespace], Suite v a) -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> Ann a

-- | Preceding indentation
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'while' &lt;spaces&gt;
--   </pre>
[_unsafeCsWhileWhile] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_unsafeCsWhileCond] :: CompoundStatement a -> Expr v a

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsWhileBody] :: CompoundStatement a -> Suite v a

-- | <pre>
--   ['else' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsWhileElse] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite v a)

-- | 
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-try-statement</a>
TryExcept :: Ann a -> Indents a -> [Whitespace] -> Suite v a -> NonEmpty (Indents a, [Whitespace], Maybe (ExceptAs v a), Suite v a) -> Maybe (Indents a, [Whitespace], Suite v a) -> Maybe (Indents a, [Whitespace], Suite v a) -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> Ann a

-- | Preceding indentation
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'try' &lt;spaces&gt;
--   </pre>
[_unsafeCsTryExceptTry] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsTryExceptBody] :: CompoundStatement a -> Suite v a

-- | <pre>
--   ('except' &lt;spaces&gt; &lt;except_as&gt; &lt;suite&gt;)+
--   </pre>
[_unsafeCsTryExceptExcepts] :: CompoundStatement a -> NonEmpty (Indents a, [Whitespace], Maybe (ExceptAs v a), Suite v a)

-- | <pre>
--   ['else' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsTryExceptElse] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite v a)

-- | <pre>
--   ['finally' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsTryExceptFinally] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite v a)

-- | 
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-try-statement</a>
TryFinally :: Ann a -> Indents a -> [Whitespace] -> Suite v a -> Indents a -> [Whitespace] -> Suite v a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> Ann a

-- | Preceding indentation
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'try' &lt;spaces&gt;
--   </pre>
[_unsafeCsTryFinallyTry] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsTryFinallyTryBody] :: CompoundStatement a -> Suite v a
[_unsafeCsTryFinallyFinallyIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'finally' &lt;spaces&gt;
--   </pre>
[_unsafeCsTryFinallyFinally] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsTryFinallyFinallyBody] :: CompoundStatement a -> Suite v a

-- | 
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-for-statement</a>
--   
--   
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-async-for-statement</a>
For :: Ann a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> Expr v a -> [Whitespace] -> CommaSep1' (Expr v a) -> Suite v a -> Maybe (Indents a, [Whitespace], Suite v a) -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> Ann a

-- | Preceding indentation
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   ['async' &lt;spaces&gt;]
--   </pre>
[_unsafeCsForAsync] :: CompoundStatement a -> Maybe (NonEmpty Whitespace)

-- | <pre>
--   'for' &lt;spaces&gt;
--   </pre>
[_unsafeCsForFor] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_unsafeCsForBinder] :: CompoundStatement a -> Expr v a

-- | <pre>
--   'in' &lt;spaces&gt;
--   </pre>
[_unsafeCsForIn] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;exprs&gt;
--   </pre>
[_unsafeCsForCollection] :: CompoundStatement a -> CommaSep1' (Expr v a)

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsForBody] :: CompoundStatement a -> Suite v a

-- | <pre>
--   ['else' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsForElse] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite v a)

-- | 
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#class-definitions</a>
ClassDef :: Ann a -> [Decorator v a] -> Indents a -> NonEmpty Whitespace -> Ident v a -> Maybe ([Whitespace], Maybe (CommaSep1' (Arg v a)), [Whitespace]) -> Suite v a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> Ann a

-- | Preceding <a>Decorator</a>s
[_unsafeCsClassDefDecorators] :: CompoundStatement a -> [Decorator v a]

-- | Preceding indentation
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'class' &lt;spaces&gt;
--   </pre>
[_unsafeCsClassDefClass] :: CompoundStatement a -> NonEmpty Whitespace

-- | <pre>
--   &lt;ident&gt;
--   </pre>
[_unsafeCsClassDefName] :: CompoundStatement a -> Ident v a

-- | <pre>
--   ['(' &lt;spaces&gt; [&lt;args&gt;] ')' &lt;spaces&gt;]
--   </pre>
[_unsafeCsClassDefArguments] :: CompoundStatement a -> Maybe ([Whitespace], Maybe (CommaSep1' (Arg v a)), [Whitespace])

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsClassDefBody] :: CompoundStatement a -> Suite v a

-- | 
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-with-statement</a>
--   
--   
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-async-with-statement</a>
With :: Ann a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> CommaSep1 (WithItem v a) -> Suite v a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> Ann a

-- | Preceding indentation
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   ['async' &lt;spaces&gt;]
--   </pre>
[_unsafeCsWithAsync] :: CompoundStatement a -> Maybe (NonEmpty Whitespace)

-- | <pre>
--   'with' &lt;spaces&gt;
--   </pre>
[_unsafeCsWithWith] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;with_items&gt;
--   </pre>
[_unsafeCsWithItems] :: CompoundStatement a -> CommaSep1 (WithItem v a)

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsWithBody] :: CompoundStatement a -> Suite v a

-- | See <tt>simpl_stmt</tt> at
--   <a>https://docs.python.org/3.5/reference/grammar.html</a>. The grammar
--   has the terminology mixed up - it should really be called
--   <tt>small_stmt</tt> there.
data SmallStatement (v :: [*]) a
MkSmallStatement :: SimpleStatement v a -> [(Semicolon a, SimpleStatement v a)] -> Maybe (Semicolon a) -> Maybe (Comment a) -> Maybe Newline -> SmallStatement a

-- | <a>https://docs.python.org/3.5/reference/simple_stmts.html</a>
data SimpleStatement (v :: [*]) a

-- | <pre>
--   'return' &lt;spaces&gt; [&lt;expr&gt;]
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-return-statement</a>
Return :: Ann a -> [Whitespace] -> Maybe (Expr v a) -> SimpleStatement a

-- | <pre>
--   &lt;expr&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#expression-statements</a>
Expr :: Ann a -> Expr v a -> SimpleStatement a

-- | <pre>
--   &lt;expr&gt; ('=' &lt;spaces&gt; &lt;expr&gt;)+
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#assignment-statements</a>
Assign :: Ann a -> Expr v a -> NonEmpty (Equals, Expr v a) -> SimpleStatement a

-- | <pre>
--   &lt;expr&gt; &lt;augassign&gt; &lt;expr&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#augmented-assignment-statements</a>
AugAssign :: Ann a -> Expr v a -> AugAssign a -> Expr v a -> SimpleStatement a

-- | <pre>
--   'pass' &lt;spaces&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-pass-statement</a>
Pass :: Ann a -> [Whitespace] -> SimpleStatement a

-- | <pre>
--   'break' &lt;spaces&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-break-statement</a>
Break :: Ann a -> [Whitespace] -> SimpleStatement a

-- | <pre>
--   'continue' &lt;spaces&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-continue-statement</a>
Continue :: Ann a -> [Whitespace] -> SimpleStatement a

-- | <pre>
--   'global' &lt;spaces&gt; &lt;idents&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-global-statement</a>
Global :: Ann a -> NonEmpty Whitespace -> CommaSep1 (Ident v a) -> SimpleStatement a

-- | <pre>
--   'nonlocal' &lt;spaces&gt; &lt;idents&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-nonlocal-statement</a>
Nonlocal :: Ann a -> NonEmpty Whitespace -> CommaSep1 (Ident v a) -> SimpleStatement a

-- | <pre>
--   'del' &lt;spaces&gt; &lt;exprs&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-del-statement</a>
Del :: Ann a -> [Whitespace] -> CommaSep1' (Expr v a) -> SimpleStatement a

-- | <pre>
--   'import' &lt;spaces&gt; &lt;modulenames&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-import-statement</a>
Import :: Ann a -> NonEmpty Whitespace -> CommaSep1 (ImportAs ModuleName v a) -> SimpleStatement a

-- | <pre>
--   'from' &lt;spaces&gt; &lt;relative_module_name&gt; 'import' &lt;spaces&gt; &lt;import_targets&gt;
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-import-statement</a>
From :: Ann a -> [Whitespace] -> RelativeModuleName v a -> [Whitespace] -> ImportTargets v a -> SimpleStatement a

-- | <pre>
--   'raise' &lt;spaces&gt; [&lt;expr&gt; ['as' &lt;spaces&gt; &lt;expr&gt;]]
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-raise-statement</a>
Raise :: Ann a -> [Whitespace] -> Maybe (Expr v a, Maybe ([Whitespace], Expr v a)) -> SimpleStatement a

-- | <pre>
--   'assert' &lt;spaces&gt; &lt;expr&gt; [',' &lt;spaces&gt; &lt;expr&gt;]
--   </pre>
--   
--   
--   <a>https://docs.python.org/3.5/reference/simple_stmts.html#the-assert-statement</a>
Assert :: Ann a -> [Whitespace] -> Expr v a -> Maybe (Comma, Expr v a) -> SimpleStatement a

-- | See
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-with-statement</a>
data WithItem (v :: [*]) a
WithItem :: Ann a -> Expr v a -> Maybe ([Whitespace], Expr v a) -> WithItem a
[_withItemAnn] :: WithItem a -> Ann a

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_withItemValue] :: WithItem a -> Expr v a

-- | <pre>
--   ['as' &lt;spaces&gt; &lt;expr&gt;]
--   </pre>
[_withItemBinder] :: WithItem a -> Maybe ([Whitespace], Expr v a)
withItemAnn :: forall v_a26rU a_a26rV. Lens' (WithItem v_a26rU a_a26rV) (Ann a_a26rV)
withItemValue :: forall v_a26rU a_a26rV. Lens' (WithItem v_a26rU a_a26rV) (Expr v_a26rU a_a26rV)
withItemBinder :: forall v_a26rU a_a26rV. Lens' (WithItem v_a26rU a_a26rV) (Maybe ([Whitespace], Expr v_a26rU a_a26rV))

-- | See
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-try-statement</a>
data ExceptAs (v :: [*]) a
ExceptAs :: Ann a -> Expr v a -> Maybe ([Whitespace], Ident v a) -> ExceptAs a
[_exceptAsAnn] :: ExceptAs a -> Ann a

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_exceptAsExpr] :: ExceptAs a -> Expr v a

-- | <pre>
--   ['as' &lt;ident&gt;]
--   </pre>
[_exceptAsName] :: ExceptAs a -> Maybe ([Whitespace], Ident v a)
exceptAsAnn :: forall v_a26rY a_a26rZ. Lens' (ExceptAs v_a26rY a_a26rZ) (Ann a_a26rZ)
exceptAsExpr :: forall v_a26rY a_a26rZ. Lens' (ExceptAs v_a26rY a_a26rZ) (Expr v_a26rY a_a26rZ)
exceptAsName :: forall v_a26rY a_a26rZ. Lens' (ExceptAs v_a26rY a_a26rZ) (Maybe ([Whitespace], Ident v_a26rY a_a26rZ))

-- | A compound statement consists of one or more clauses. A clause
--   consists of a header and a suite.
data Suite (v :: [*]) a
SuiteOne :: Ann a -> Colon -> SmallStatement v a -> Suite a
SuiteMany :: Ann a -> Colon -> Maybe (Comment a) -> Newline -> Block v a -> Suite a

-- | A <a>Block</a> is an indented multi-line chunk of code, forming part
--   of a <a>Suite</a>.
data Block (v :: [*]) a
Block :: [(Blank a, Newline)] -> Statement v a -> [Either (Blank a, Newline) (Statement v a)] -> Block a

-- | Blank lines at the beginning of the block
[_blockBlankLines] :: Block a -> [(Blank a, Newline)]

-- | The first statement of the block
[_blockHead] :: Block a -> Statement v a

-- | The remaining items of the block, which may be statements or blank
--   lines
[_blockTail] :: Block a -> [Either (Blank a, Newline) (Statement v a)]
blockBlankLines :: forall v_a26s9 a_a26sa. Lens' (Block v_a26s9 a_a26sa) [(Blank a_a26sa, Newline)]
blockHead :: forall v_a26s9 a_a26sa. Lens' (Block v_a26s9 a_a26sa) (Statement v_a26s9 a_a26sa)
blockTail :: forall v_a26s9 a_a26sa. Lens' (Block v_a26s9 a_a26sa) [Either (Blank a_a26sa, Newline) (Statement v_a26s9 a_a26sa)]
class HasBlocks s

-- | <a>Traversal</a> targeting all the <a>Block</a>s in a structure
_Blocks :: HasBlocks s => Traversal (s v a) (s '[] a) (Block v a) (Block '[] a)
instance GHC.Generics.Generic (Language.Python.Syntax.Statement.Statement v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Statement.Statement v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Statement.Statement v)
instance GHC.Base.Functor (Language.Python.Syntax.Statement.Statement v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Statement.Statement v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Statement.Statement v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Statement.Block v a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Statement.Block v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Statement.Block v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Statement.Suite v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Statement.Suite v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Statement.Suite v)
instance GHC.Base.Functor (Language.Python.Syntax.Statement.Suite v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Statement.Suite v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Statement.Suite v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Statement.CompoundStatement v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Statement.CompoundStatement v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Statement.CompoundStatement v)
instance GHC.Base.Functor (Language.Python.Syntax.Statement.CompoundStatement v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Statement.CompoundStatement v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Statement.CompoundStatement v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Statement.Decorator v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Statement.Decorator v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Statement.Decorator v)
instance GHC.Base.Functor (Language.Python.Syntax.Statement.Decorator v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Statement.Decorator v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Statement.Decorator v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Statement.WithItem v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Statement.WithItem v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Statement.WithItem v)
instance GHC.Base.Functor (Language.Python.Syntax.Statement.WithItem v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Statement.WithItem v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Statement.WithItem v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Statement.ExceptAs v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Statement.ExceptAs v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Statement.ExceptAs v)
instance GHC.Base.Functor (Language.Python.Syntax.Statement.ExceptAs v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Statement.ExceptAs v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Statement.ExceptAs v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Statement.SmallStatement v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Statement.SmallStatement v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Statement.SmallStatement v)
instance GHC.Base.Functor (Language.Python.Syntax.Statement.SmallStatement v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Statement.SmallStatement v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Statement.SmallStatement v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Statement.SimpleStatement v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Statement.SimpleStatement v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Statement.SimpleStatement v)
instance GHC.Base.Functor (Language.Python.Syntax.Statement.SimpleStatement v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Statement.SimpleStatement v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Statement.SimpleStatement v a)
instance Language.Python.Syntax.Statement.HasStatements Language.Python.Syntax.Statement.Block
instance Language.Python.Syntax.Statement.HasStatements Language.Python.Syntax.Statement.Suite
instance Language.Python.Syntax.Statement.HasStatements Language.Python.Syntax.Statement.Statement
instance Control.Lens.Plated.Plated (Language.Python.Syntax.Statement.Statement '[] a)
instance Language.Python.Syntax.Statement.HasBlocks Language.Python.Syntax.Statement.Suite
instance Language.Python.Syntax.Statement.HasBlocks Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Syntax.Statement.HasBlocks Language.Python.Syntax.Statement.SmallStatement
instance Language.Python.Syntax.Statement.HasBlocks Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.Block
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.Suite
instance GHC.Base.Functor (Language.Python.Syntax.Statement.Block v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Statement.Block v)
instance Data.Traversable.Traversable (Language.Python.Syntax.Statement.Block v)
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Statement.Statement
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Statement.Suite v)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Statement.CompoundStatement v)
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Statement.Block
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Statement.Suite
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Syntax.Whitespace.HasTrailingNewline Language.Python.Syntax.Statement.Statement
instance Language.Python.Syntax.Whitespace.HasTrailingNewline Language.Python.Syntax.Statement.Suite
instance Language.Python.Syntax.Whitespace.HasTrailingNewline Language.Python.Syntax.Statement.Block
instance Language.Python.Syntax.Whitespace.HasTrailingNewline Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.Decorator
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Statement.Decorator v)
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Statement.Decorator
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.WithItem
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Statement.WithItem v)
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Statement.WithItem
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.ExceptAs
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Statement.ExceptAs v)
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Statement.ExceptAs
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.SmallStatement
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Statement.SmallStatement
instance Language.Python.Syntax.Whitespace.HasTrailingNewline Language.Python.Syntax.Statement.SmallStatement
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.SimpleStatement
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Statement.SimpleStatement v)
instance Control.Lens.Plated.Plated (Language.Python.Syntax.Statement.SimpleStatement '[] a)
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Statement.SimpleStatement


-- | Datatypes for different parts of Python syntax
module Language.Python.Syntax.Types
data PositionalParam v a
MkPositionalParam :: Ann a -> Ident v a -> Maybe (Colon, Expr v a) -> PositionalParam v a
[_ppAnn] :: PositionalParam v a -> Ann a
[_ppName] :: PositionalParam v a -> Ident v a
[_ppType] :: PositionalParam v a -> Maybe (Colon, Expr v a)
ppAnn :: forall v_a2Mcu a_a2Mcv. Lens' (PositionalParam v_a2Mcu a_a2Mcv) (Ann a_a2Mcv)
ppName :: forall v_a2Mcu a_a2Mcv. Lens' (PositionalParam v_a2Mcu a_a2Mcv) (Ident v_a2Mcu a_a2Mcv)
ppType :: forall v_a2Mcu a_a2Mcv. Lens' (PositionalParam v_a2Mcu a_a2Mcv) (Maybe (Colon, Expr v_a2Mcu a_a2Mcv))
data StarParam v a
MkStarParam :: Ann a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> StarParam v a
[_spAnn] :: StarParam v a -> Ann a
[_spWhitespace] :: StarParam v a -> [Whitespace]
[_spName] :: StarParam v a -> Ident v a
[_spType] :: StarParam v a -> Maybe (Colon, Expr v a)
spAnn :: forall v_a2Mw0 a_a2Mw1. Lens' (StarParam v_a2Mw0 a_a2Mw1) (Ann a_a2Mw1)
spWhitespace :: forall v_a2Mw0 a_a2Mw1. Lens' (StarParam v_a2Mw0 a_a2Mw1) [Whitespace]
spName :: forall v_a2Mw0 a_a2Mw1. Lens' (StarParam v_a2Mw0 a_a2Mw1) (Ident v_a2Mw0 a_a2Mw1)
spType :: forall v_a2Mw0 a_a2Mw1. Lens' (StarParam v_a2Mw0 a_a2Mw1) (Maybe (Colon, Expr v_a2Mw0 a_a2Mw1))
data UnnamedStarParam (v :: [*]) a
MkUnnamedStarParam :: Ann a -> [Whitespace] -> UnnamedStarParam a
[_uspAnn] :: UnnamedStarParam a -> Ann a
[_uspWhitespace] :: UnnamedStarParam a -> [Whitespace]
uspAnn :: forall v_a2MPR a_a2MPS v_a2N3R a_a2N3S. Lens (UnnamedStarParam v_a2MPR a_a2MPS) (UnnamedStarParam v_a2N3R a_a2N3S) (Ann a_a2MPS) (Ann a_a2N3S)
uspWhitespace :: forall v_a2MPR a_a2MPS v_a2N3T. Lens (UnnamedStarParam v_a2MPR a_a2MPS) (UnnamedStarParam v_a2N3T a_a2MPS) [Whitespace] [Whitespace]
data KeywordParam v a
MkKeywordParam :: Ann a -> Ident v a -> Maybe (Colon, Expr v a) -> [Whitespace] -> Expr v a -> KeywordParam v a
[_kpAnn] :: KeywordParam v a -> Ann a
[_kpName] :: KeywordParam v a -> Ident v a
[_kpType] :: KeywordParam v a -> Maybe (Colon, Expr v a)
[_kpEquals] :: KeywordParam v a -> [Whitespace]
[_kpExpr] :: KeywordParam v a -> Expr v a
kpAnn :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) (Ann a_a2LOV)
kpName :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) (Ident v_a2LOU a_a2LOV)
kpType :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) (Maybe (Colon, Expr v_a2LOU a_a2LOV))
kpEquals :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) [Whitespace]
kpExpr :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) (Expr v_a2LOU a_a2LOV)
data Fundef v a
MkFundef :: Ann a -> [Decorator v a] -> Indents a -> Maybe (NonEmpty Whitespace) -> NonEmpty Whitespace -> Ident v a -> [Whitespace] -> CommaSep (Param v a) -> [Whitespace] -> Maybe ([Whitespace], Expr v a) -> Suite v a -> Fundef v a
[_fdAnn] :: Fundef v a -> Ann a
[_fdDecorators] :: Fundef v a -> [Decorator v a]
[_fdIndents] :: Fundef v a -> Indents a
[_fdAsync] :: Fundef v a -> Maybe (NonEmpty Whitespace)
[_fdDefSpaces] :: Fundef v a -> NonEmpty Whitespace
[_fdName] :: Fundef v a -> Ident v a
[_fdLeftParenSpaces] :: Fundef v a -> [Whitespace]
[_fdParameters] :: Fundef v a -> CommaSep (Param v a)
[_fdRightParenSpaces] :: Fundef v a -> [Whitespace]
[_fdReturnType] :: Fundef v a -> Maybe ([Whitespace], Expr v a)
[_fdBody] :: Fundef v a -> Suite v a
fdAnn :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Ann a_a2KCQ)
fdDecorators :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) [Decorator v_a2KCP a_a2KCQ]
fdIndents :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Indents a_a2KCQ)
fdAsync :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Maybe (NonEmpty Whitespace))
fdDefSpaces :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (NonEmpty Whitespace)
fdName :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Ident v_a2KCP a_a2KCQ)
fdLeftParenSpaces :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) [Whitespace]
fdParameters :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (CommaSep (Param v_a2KCP a_a2KCQ))
fdRightParenSpaces :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) [Whitespace]
fdReturnType :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Maybe ([Whitespace], Expr v_a2KCP a_a2KCQ))
fdBody :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Suite v_a2KCP a_a2KCQ)
data ClassDef v a
MkClassDef :: Ann a -> [Decorator v a] -> Indents a -> NonEmpty Whitespace -> Ident v a -> Maybe ([Whitespace], Maybe (CommaSep1' (Arg v a)), [Whitespace]) -> Suite v a -> ClassDef v a
[_cdAnn] :: ClassDef v a -> Ann a
[_cdDecorators] :: ClassDef v a -> [Decorator v a]
[_cdIndents] :: ClassDef v a -> Indents a
[_cdClass] :: ClassDef v a -> NonEmpty Whitespace
[_cdName] :: ClassDef v a -> Ident v a
[_cdArguments] :: ClassDef v a -> Maybe ([Whitespace], Maybe (CommaSep1' (Arg v a)), [Whitespace])
[_cdBody] :: ClassDef v a -> Suite v a
cdAnn :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Ann a_a2PY5)
cdDecorators :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) [Decorator v_a2PY4 a_a2PY5]
cdIndents :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Indents a_a2PY5)
cdClass :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (NonEmpty Whitespace)
cdName :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Ident v_a2PY4 a_a2PY5)
cdArguments :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Maybe ([Whitespace], Maybe (CommaSep1' (Arg v_a2PY4 a_a2PY5)), [Whitespace]))
cdBody :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Suite v_a2PY4 a_a2PY5)
data If v a
MkIf :: Ann a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> [Elif v a] -> Maybe (Else v a) -> If v a
[_ifAnn] :: If v a -> Ann a
[_ifIndents] :: If v a -> Indents a
[_ifIf] :: If v a -> [Whitespace]
[_ifCond] :: If v a -> Expr v a
[_ifBody] :: If v a -> Suite v a
[_ifElifs] :: If v a -> [Elif v a]
[_ifElse] :: If v a -> Maybe (Else v a)
ifAnn :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Ann a_a2NHj)
ifIndents :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Indents a_a2NHj)
ifIf :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) [Whitespace]
ifCond :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Expr v_a2NHi a_a2NHj)
ifBody :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Suite v_a2NHi a_a2NHj)
ifElifs :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) [Elif v_a2NHi a_a2NHj]
ifElse :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Maybe (Else v_a2NHi a_a2NHj))
data Elif v a
MkElif :: Indents a -> [Whitespace] -> Expr v a -> Suite v a -> Elif v a
[_elifIndents] :: Elif v a -> Indents a
[_elifElif] :: Elif v a -> [Whitespace]
[_elifCond] :: Elif v a -> Expr v a
[_elifBody] :: Elif v a -> Suite v a
elifIndents :: forall v_a2Noq a_a2Nor. Lens' (Elif v_a2Noq a_a2Nor) (Indents a_a2Nor)
elifElif :: forall v_a2Noq a_a2Nor. Lens' (Elif v_a2Noq a_a2Nor) [Whitespace]
elifCond :: forall v_a2Noq a_a2Nor. Lens' (Elif v_a2Noq a_a2Nor) (Expr v_a2Noq a_a2Nor)
elifBody :: forall v_a2Noq a_a2Nor. Lens' (Elif v_a2Noq a_a2Nor) (Suite v_a2Noq a_a2Nor)
data For v a
MkFor :: Ann a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> Expr v a -> [Whitespace] -> CommaSep1' (Expr v a) -> Suite v a -> Maybe (Else v a) -> For v a
[_forAnn] :: For v a -> Ann a
[_forIndents] :: For v a -> Indents a
[_forAsync] :: For v a -> Maybe (NonEmpty Whitespace)
[_forFor] :: For v a -> [Whitespace]
[_forBinder] :: For v a -> Expr v a
[_forIn] :: For v a -> [Whitespace]
[_forCollection] :: For v a -> CommaSep1' (Expr v a)
[_forBody] :: For v a -> Suite v a
[_forElse] :: For v a -> Maybe (Else v a)
forAnn :: forall v_a2O6F a_a2O6G. Lens' (For v_a2O6F a_a2O6G) (Ann a_a2O6G)
forIndents :: forall v_a2O6F a_a2O6G. Lens' (For v_a2O6F a_a2O6G) (Indents a_a2O6G)
forAsync :: forall v_a2O6F a_a2O6G. Lens' (For v_a2O6F a_a2O6G) (Maybe (NonEmpty Whitespace))
forFor :: forall v_a2O6F a_a2O6G. Lens' (For v_a2O6F a_a2O6G) [Whitespace]
forBinder :: forall v_a2O6F a_a2O6G. Lens' (For v_a2O6F a_a2O6G) (Expr v_a2O6F a_a2O6G)
forIn :: forall v_a2O6F a_a2O6G. Lens' (For v_a2O6F a_a2O6G) [Whitespace]
forCollection :: forall v_a2O6F a_a2O6G. Lens' (For v_a2O6F a_a2O6G) (CommaSep1' (Expr v_a2O6F a_a2O6G))
forBody :: forall v_a2O6F a_a2O6G. Lens' (For v_a2O6F a_a2O6G) (Suite v_a2O6F a_a2O6G)
forElse :: forall v_a2O6F a_a2O6G. Lens' (For v_a2O6F a_a2O6G) (Maybe (Else v_a2O6F a_a2O6G))
data While v a
MkWhile :: Ann a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> Maybe (Else v a) -> While v a
[_whileAnn] :: While v a -> Ann a
[_whileIndents] :: While v a -> Indents a
[_whileWhile] :: While v a -> [Whitespace]
[_whileCond] :: While v a -> Expr v a
[_whileBody] :: While v a -> Suite v a
[_whileElse] :: While v a -> Maybe (Else v a)
whileAnn :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) (Ann a_a2LsY)
whileIndents :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) (Indents a_a2LsY)
whileWhile :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) [Whitespace]
whileCond :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) (Expr v_a2LsX a_a2LsY)
whileBody :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) (Suite v_a2LsX a_a2LsY)
whileElse :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) (Maybe (Else v_a2LsX a_a2LsY))
data TryExcept v a
MkTryExcept :: Ann a -> Indents a -> [Whitespace] -> Suite v a -> NonEmpty (Except v a) -> Maybe (Else v a) -> Maybe (Finally v a) -> TryExcept v a
[_teAnn] :: TryExcept v a -> Ann a
[_teIndents] :: TryExcept v a -> Indents a
[_teTry] :: TryExcept v a -> [Whitespace]
[_teBody] :: TryExcept v a -> Suite v a
[_teExcepts] :: TryExcept v a -> NonEmpty (Except v a)
[_teElse] :: TryExcept v a -> Maybe (Else v a)
[_teFinally] :: TryExcept v a -> Maybe (Finally v a)
teAnn :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Ann a_a2Pc1)
teIndents :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Indents a_a2Pc1)
teTry :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) [Whitespace]
teBody :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Suite v_a2Pc0 a_a2Pc1)
teExcepts :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (NonEmpty (Except v_a2Pc0 a_a2Pc1))
teElse :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Maybe (Else v_a2Pc0 a_a2Pc1))
teFinally :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Maybe (Finally v_a2Pc0 a_a2Pc1))
data Except v a
MkExcept :: Indents a -> [Whitespace] -> Maybe (ExceptAs v a) -> Suite v a -> Except v a
[_exceptIndents] :: Except v a -> Indents a
[_exceptExcept] :: Except v a -> [Whitespace]
[_exceptExceptAs] :: Except v a -> Maybe (ExceptAs v a)
[_exceptBody] :: Except v a -> Suite v a
exceptIndents :: forall v_a2OUh a_a2OUi. Lens' (Except v_a2OUh a_a2OUi) (Indents a_a2OUi)
exceptExcept :: forall v_a2OUh a_a2OUi. Lens' (Except v_a2OUh a_a2OUi) [Whitespace]
exceptExceptAs :: forall v_a2OUh a_a2OUi. Lens' (Except v_a2OUh a_a2OUi) (Maybe (ExceptAs v_a2OUh a_a2OUi))
exceptBody :: forall v_a2OUh a_a2OUi. Lens' (Except v_a2OUh a_a2OUi) (Suite v_a2OUh a_a2OUi)
data TryFinally v a
MkTryFinally :: Ann a -> Indents a -> [Whitespace] -> Suite v a -> Finally v a -> TryFinally v a
[_tfAnn] :: TryFinally v a -> Ann a
[_tfIndents] :: TryFinally v a -> Indents a
[_tfTry] :: TryFinally v a -> [Whitespace]
[_tfBody] :: TryFinally v a -> Suite v a
[_tfFinally] :: TryFinally v a -> Finally v a
tfAnn :: forall v_a2PC1 a_a2PC2. Lens' (TryFinally v_a2PC1 a_a2PC2) (Ann a_a2PC2)
tfIndents :: forall v_a2PC1 a_a2PC2. Lens' (TryFinally v_a2PC1 a_a2PC2) (Indents a_a2PC2)
tfTry :: forall v_a2PC1 a_a2PC2. Lens' (TryFinally v_a2PC1 a_a2PC2) [Whitespace]
tfBody :: forall v_a2PC1 a_a2PC2. Lens' (TryFinally v_a2PC1 a_a2PC2) (Suite v_a2PC1 a_a2PC2)
tfFinally :: forall v_a2PC1 a_a2PC2. Lens' (TryFinally v_a2PC1 a_a2PC2) (Finally v_a2PC1 a_a2PC2)
data Finally v a
MkFinally :: Indents a -> [Whitespace] -> Suite v a -> Finally v a
[_finallyIndents] :: Finally v a -> Indents a
[_finallyFinally] :: Finally v a -> [Whitespace]
[_finallyBody] :: Finally v a -> Suite v a
finallyIndents :: forall v_a2OBq a_a2OBr. Lens' (Finally v_a2OBq a_a2OBr) (Indents a_a2OBr)
finallyFinally :: forall v_a2OBq a_a2OBr. Lens' (Finally v_a2OBq a_a2OBr) [Whitespace]
finallyBody :: forall v_a2OBq a_a2OBr v_a2OTS. Lens (Finally v_a2OBq a_a2OBr) (Finally v_a2OTS a_a2OBr) (Suite v_a2OBq a_a2OBr) (Suite v_a2OTS a_a2OBr)
data With v a
MkWith :: Ann a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> CommaSep1 (WithItem v a) -> Suite v a -> With v a
[_withAnn] :: With v a -> Ann a
[_withIndents] :: With v a -> Indents a
[_withAsync] :: With v a -> Maybe (NonEmpty Whitespace)
[_withWith] :: With v a -> [Whitespace]
[_withItems] :: With v a -> CommaSep1 (WithItem v a)
[_withBody] :: With v a -> Suite v a
withAnn :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (Ann a_a2Qsc)
withIndents :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (Indents a_a2Qsc)
withAsync :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (Maybe (NonEmpty Whitespace))
withWith :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) [Whitespace]
withItems :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (CommaSep1 (WithItem v_a2Qsb a_a2Qsc))
withBody :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (Suite v_a2Qsb a_a2Qsc)
data Else v a
MkElse :: Indents a -> [Whitespace] -> Suite v a -> Else v a
[_elseIndents] :: Else v a -> Indents a
[_elseElse] :: Else v a -> [Whitespace]
[_elseBody] :: Else v a -> Suite v a
elseIndents :: forall v_a2L90 a_a2L91. Lens' (Else v_a2L90 a_a2L91) (Indents a_a2L91)
elseElse :: forall v_a2L90 a_a2L91. Lens' (Else v_a2L90 a_a2L91) [Whitespace]
elseBody :: forall v_a2L90 a_a2L91 v_a2Lsw. Lens (Else v_a2L90 a_a2L91) (Else v_a2Lsw a_a2L91) (Suite v_a2L90 a_a2L91) (Suite v_a2Lsw a_a2L91)
data None (v :: [*]) a
MkNone :: Ann a -> [Whitespace] -> None a
[_noneAnn] :: None a -> Ann a
[_noneWhitespace] :: None a -> [Whitespace]
noneAnn :: forall v_a2RLO a_a2RLP v_a2RZS a_a2RZT. Lens (None v_a2RLO a_a2RLP) (None v_a2RZS a_a2RZT) (Ann a_a2RLP) (Ann a_a2RZT)
noneWhitespace :: forall v_a2RLO a_a2RLP v_a2RZU. Lens (None v_a2RLO a_a2RLP) (None v_a2RZU a_a2RLP) [Whitespace] [Whitespace]
data Call v a
MkCall :: Ann a -> Expr v a -> [Whitespace] -> Maybe (CommaSep1' (Arg v a)) -> [Whitespace] -> Call v a
[_callAnn] :: Call v a -> Ann a
[_callFunction] :: Call v a -> Expr v a
[_callLeftParen] :: Call v a -> [Whitespace]
[_callArguments] :: Call v a -> Maybe (CommaSep1' (Arg v a))
[_callRightParen] :: Call v a -> [Whitespace]
callAnn :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) (Ann a_a2N4c)
callFunction :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) (Expr v_a2N4b a_a2N4c)
callLeftParen :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) [Whitespace]
callArguments :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) (Maybe (CommaSep1' (Arg v_a2N4b a_a2N4c)))
callRightParen :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) [Whitespace]
data Tuple v a
MkTuple :: Ann a -> TupleItem v a -> Comma -> Maybe (CommaSep1' (TupleItem v a)) -> Tuple v a
[_tupleAnn] :: Tuple v a -> Ann a
[_tupleHead] :: Tuple v a -> TupleItem v a
[_tupleComma] :: Tuple v a -> Comma
[_tupleTail] :: Tuple v a -> Maybe (CommaSep1' (TupleItem v a))
tupleAnn :: forall v_a2QQo a_a2QQp. Lens' (Tuple v_a2QQo a_a2QQp) (Ann a_a2QQp)
tupleHead :: forall v_a2QQo a_a2QQp. Lens' (Tuple v_a2QQo a_a2QQp) (TupleItem v_a2QQo a_a2QQp)
tupleComma :: forall v_a2QQo a_a2QQp. Lens' (Tuple v_a2QQo a_a2QQp) Comma
tupleTail :: forall v_a2QQo a_a2QQp. Lens' (Tuple v_a2QQo a_a2QQp) (Maybe (CommaSep1' (TupleItem v_a2QQo a_a2QQp)))
data TupleUnpack v a
MkTupleUnpack :: Ann a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> TupleUnpack v a
[_tupleUnpackAnn] :: TupleUnpack v a -> Ann a
[_tupleUnpackParens] :: TupleUnpack v a -> [([Whitespace], [Whitespace])]
[_tupleUnpackWhitespace] :: TupleUnpack v a -> [Whitespace]
[_tupleUnpackValue] :: TupleUnpack v a -> Expr v a
tupleUnpackAnn :: forall v_a2S0b a_a2S0c. Lens' (TupleUnpack v_a2S0b a_a2S0c) (Ann a_a2S0c)
tupleUnpackParens :: forall v_a2S0b a_a2S0c. Lens' (TupleUnpack v_a2S0b a_a2S0c) [([Whitespace], [Whitespace])]
tupleUnpackWhitespace :: forall v_a2S0b a_a2S0c. Lens' (TupleUnpack v_a2S0b a_a2S0c) [Whitespace]
tupleUnpackValue :: forall v_a2S0b a_a2S0c v_a2Sgv. Lens (TupleUnpack v_a2S0b a_a2S0c) (TupleUnpack v_a2Sgv a_a2S0c) (Expr v_a2S0b a_a2S0c) (Expr v_a2Sgv a_a2S0c)
data List v a
MkList :: Ann a -> [Whitespace] -> Maybe (CommaSep1' (ListItem v a)) -> [Whitespace] -> List v a
[_listAnn] :: List v a -> Ann a
[_listWhitespaceLeft] :: List v a -> [Whitespace]
[_listBody] :: List v a -> Maybe (CommaSep1' (ListItem v a))
[_listWhitespaceRight] :: List v a -> [Whitespace]
listAnn :: forall v_a2Rb2 a_a2Rb3. Lens' (List v_a2Rb2 a_a2Rb3) (Ann a_a2Rb3)
listWhitespaceLeft :: forall v_a2Rb2 a_a2Rb3. Lens' (List v_a2Rb2 a_a2Rb3) [Whitespace]
listBody :: forall v_a2Rb2 a_a2Rb3 v_a2Rts. Lens (List v_a2Rb2 a_a2Rb3) (List v_a2Rts a_a2Rb3) (Maybe (CommaSep1' (ListItem v_a2Rb2 a_a2Rb3))) (Maybe (CommaSep1' (ListItem v_a2Rts a_a2Rb3)))
listWhitespaceRight :: forall v_a2Rb2 a_a2Rb3. Lens' (List v_a2Rb2 a_a2Rb3) [Whitespace]
data ListUnpack v a
MkListUnpack :: Ann a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> ListUnpack v a
[_listUnpackAnn] :: ListUnpack v a -> Ann a
[_listUnpackParens] :: ListUnpack v a -> [([Whitespace], [Whitespace])]
[_listUnpackWhitespace] :: ListUnpack v a -> [Whitespace]
[_listUnpackValue] :: ListUnpack v a -> Expr v a
listUnpackAnn :: forall v_a2Ru1 a_a2Ru2. Lens' (ListUnpack v_a2Ru1 a_a2Ru2) (Ann a_a2Ru2)
listUnpackParens :: forall v_a2Ru1 a_a2Ru2. Lens' (ListUnpack v_a2Ru1 a_a2Ru2) [([Whitespace], [Whitespace])]
listUnpackWhitespace :: forall v_a2Ru1 a_a2Ru2. Lens' (ListUnpack v_a2Ru1 a_a2Ru2) [Whitespace]
listUnpackValue :: forall v_a2Ru1 a_a2Ru2 v_a2RLh. Lens (ListUnpack v_a2Ru1 a_a2Ru2) (ListUnpack v_a2RLh a_a2Ru2) (Expr v_a2Ru1 a_a2Ru2) (Expr v_a2RLh a_a2Ru2)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.TupleUnpack v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.TupleUnpack v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.TupleUnpack v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.TupleUnpack v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.TupleUnpack v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.TupleUnpack v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.TupleUnpack v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.None v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.None v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.None v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.None v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.None v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.None v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.None v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.ListUnpack v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.ListUnpack v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.ListUnpack v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.ListUnpack v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.ListUnpack v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.ListUnpack v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.ListUnpack v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.List v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.List v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.List v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.List v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.List v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.List v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.List v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.Tuple v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.Tuple v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.Tuple v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.Tuple v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.Tuple v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.Tuple v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.Tuple v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.With v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.With v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.With v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.With v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.With v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.With v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.With v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.ClassDef v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.ClassDef v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.ClassDef v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.ClassDef v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.ClassDef v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.ClassDef v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.ClassDef v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.TryFinally v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.TryFinally v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.TryFinally v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.TryFinally v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.TryFinally v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.TryFinally v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.TryFinally v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.TryExcept v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.TryExcept v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.TryExcept v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.TryExcept v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.TryExcept v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.TryExcept v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.TryExcept v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.Except v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.Except v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.Except v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.Except v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.Except v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.Except v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.Finally v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.Finally v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.Finally v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.Finally v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.Finally v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.Finally v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.For v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.For v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.For v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.For v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.For v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.For v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.For v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.If v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.If v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.If v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.If v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.If v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.If v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.If v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.Elif v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.Elif v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.Elif v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.Elif v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.Elif v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.Elif v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.Call v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.Call v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.Call v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.Call v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.Call v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.Call v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.Call v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.UnnamedStarParam v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.UnnamedStarParam v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.UnnamedStarParam v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.UnnamedStarParam v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.UnnamedStarParam v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.UnnamedStarParam v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.UnnamedStarParam v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.StarParam v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.StarParam v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.StarParam v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.StarParam v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.StarParam v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.StarParam v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.StarParam v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.PositionalParam v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.PositionalParam v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.PositionalParam v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.PositionalParam v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.PositionalParam v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.PositionalParam v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.PositionalParam v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.KeywordParam v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.KeywordParam v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.KeywordParam v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.KeywordParam v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.KeywordParam v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.KeywordParam v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.KeywordParam v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.While v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.While v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.While v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.While v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.While v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.While v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.While v a)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.Else v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.Else v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.Else v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.Else v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.Else v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.Else v a)
instance Language.Python.Syntax.Ann.HasAnn (Language.Python.Syntax.Types.Fundef v)
instance GHC.Generics.Generic (Language.Python.Syntax.Types.Fundef v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Types.Fundef v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Types.Fundef v)
instance GHC.Base.Functor (Language.Python.Syntax.Types.Fundef v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Types.Fundef v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Types.Fundef v a)


module Language.Python.Syntax.Module

-- | A Python <a>Module</a>, which is stored as a sequence of statements. A
--   module corresponds to one source file of Python code.
data Module v a
ModuleEmpty :: Module v a
ModuleBlankFinal :: Blank a -> Module v a
ModuleBlank :: Blank a -> Newline -> Module v a -> Module v a
ModuleStatement :: Statement v a -> Module v a -> Module v a
instance GHC.Generics.Generic (Language.Python.Syntax.Module.Module v a)
instance Data.Traversable.Traversable (Language.Python.Syntax.Module.Module v)
instance Data.Foldable.Foldable (Language.Python.Syntax.Module.Module v)
instance GHC.Base.Functor (Language.Python.Syntax.Module.Module v)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Syntax.Module.Module v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Syntax.Module.Module v a)
instance Language.Python.Syntax.Statement.HasStatements Language.Python.Syntax.Module.Module
instance Language.Python.Syntax.Expr.HasExprs Language.Python.Syntax.Module.Module


-- | The abstract syntax tree for Python.
--   
--   Key datatypes include <a>Module</a>, <a>Statement</a>, and
--   <a>SimpleStatement</a>.
module Language.Python.Syntax


module Language.Python.Optics.Newlines
class HasNewlines s

-- | <a>Traversal'</a> targeting all of thie <a>Newline</a>s in a structure
--   
--   This only targets places that contain the <a>Newline</a> datatype; it
--   doesn't target newline characters in string literals, for example.
_Newlines :: HasNewlines s => Traversal' s Newline
instance (Language.Python.Optics.Newlines.HasNewlines a, Language.Python.Optics.Newlines.HasNewlines b) => Language.Python.Optics.Newlines.HasNewlines (a, b)
instance (Language.Python.Optics.Newlines.HasNewlines a, Language.Python.Optics.Newlines.HasNewlines b, Language.Python.Optics.Newlines.HasNewlines c) => Language.Python.Optics.Newlines.HasNewlines (a, b, c)
instance (Language.Python.Optics.Newlines.HasNewlines a, Language.Python.Optics.Newlines.HasNewlines b, Language.Python.Optics.Newlines.HasNewlines c, Language.Python.Optics.Newlines.HasNewlines d) => Language.Python.Optics.Newlines.HasNewlines (a, b, c, d)
instance Language.Python.Optics.Newlines.HasNewlines (e v a) => Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Import.ImportAs e v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.ModuleNames.RelativeModuleName v a)
instance (Language.Python.Optics.Newlines.HasNewlines a, Language.Python.Optics.Newlines.HasNewlines b) => Language.Python.Optics.Newlines.HasNewlines (Data.Either.Either a b)
instance Language.Python.Optics.Newlines.HasNewlines Language.Python.Syntax.Whitespace.Newline
instance Language.Python.Optics.Newlines.HasNewlines a => Language.Python.Optics.Newlines.HasNewlines [a]
instance Language.Python.Optics.Newlines.HasNewlines Language.Python.Syntax.Whitespace.Whitespace
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Whitespace.Blank a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Statement.Block v a)
instance Language.Python.Optics.Newlines.HasNewlines Language.Python.Syntax.Punctuation.Colon
instance Language.Python.Optics.Newlines.HasNewlines Language.Python.Syntax.Punctuation.Dot
instance Language.Python.Optics.Newlines.HasNewlines Language.Python.Syntax.Punctuation.Comma
instance Language.Python.Optics.Newlines.HasNewlines Language.Python.Syntax.Punctuation.At
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Punctuation.Semicolon a)
instance Language.Python.Optics.Newlines.HasNewlines Language.Python.Syntax.Punctuation.Equals
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Statement.Suite v a)
instance Language.Python.Optics.Newlines.HasNewlines Language.Python.Syntax.Whitespace.Indent
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Whitespace.Indents a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Operator.Unary.UnOp a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Operator.Binary.BinOp a)
instance Language.Python.Optics.Newlines.HasNewlines a => Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.CommaSep.CommaSep a)
instance Language.Python.Optics.Newlines.HasNewlines a => Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.CommaSep.CommaSep1 a)
instance Language.Python.Optics.Newlines.HasNewlines a => Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.CommaSep.CommaSep1' a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Ident.Ident v a)
instance Language.Python.Optics.Newlines.HasNewlines a => Language.Python.Optics.Newlines.HasNewlines (GHC.Maybe.Maybe a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.Param v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.Arg v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.CompFor v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.CompIf v a)
instance Language.Python.Optics.Newlines.HasNewlines (e v a) => Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.Comprehension e v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.TupleItem v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.ListItem v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.SetItem v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.DictItem v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.Subscript v a)
instance Language.Python.Optics.Newlines.HasNewlines a => Language.Python.Optics.Newlines.HasNewlines (GHC.Base.NonEmpty a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Strings.StringLiteral a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Expr.Expr v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Statement.Decorator v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Statement.ExceptAs v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Statement.WithItem v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Statement.CompoundStatement v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.ModuleNames.ModuleName v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Import.ImportTargets v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Statement.SimpleStatement v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Statement.SmallStatement v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Statement.Statement v a)
instance Language.Python.Optics.Newlines.HasNewlines (Language.Python.Syntax.Module.Module v a)


module Language.Python.Optics.Idents

-- | <a>Traversal</a> that targets all the <a>Expr</a>s in a structure
class HasIdents s
_Idents :: HasIdents s => Traversal (s v a) (s '[] a) (Ident v a) (Ident '[] a)
_Idents :: forall v a l m. (HasIdents s, Generic (s v a), Generic (s '[] a), Rep (s v a) ~ l, Rep (s '[] a) ~ m, GHasIdents l m v a) => Traversal (s v a) (s '[] a) (Ident v a) (Ident '[] a)
instance Language.Python.Optics.Idents.HasIdents s => Language.Python.Optics.Idents.HasIdents' (s v a) (s '[] a) v a
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.CompFor
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.CompIf
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.DictItem
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.SetItem
instance Language.Python.Optics.Idents.HasIdents e => Language.Python.Optics.Idents.HasIdents (Language.Python.Syntax.Expr.Comprehension e)
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.TupleItem
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.ListItem
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.Param
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.Subscript
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.Arg
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Ident.Ident
instance Language.Python.Optics.Idents.HasIdents n => Language.Python.Optics.Idents.HasIdents (Language.Python.Syntax.Import.ImportAs n)
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Expr.Expr
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Import.ImportTargets
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.ModuleNames.RelativeModuleName
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.ModuleNames.ModuleName
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Statement.SimpleStatement
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Statement.SmallStatement
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Statement.Decorator
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Statement.Block
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Statement.Suite
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Statement.ExceptAs
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Statement.WithItem
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.Idents.HasIdents Language.Python.Syntax.Module.Module
instance Language.Python.Optics.Idents.HasIdents s => Language.Python.Optics.Idents.GHasIdents (GHC.Generics.K1 i (s v a)) (GHC.Generics.K1 i (s '[] a)) v a
instance (Language.Python.Optics.Idents.GHasIdents a c v x, Language.Python.Optics.Idents.GHasIdents b d v x) => Language.Python.Optics.Idents.GHasIdents (a GHC.Generics.:+: b) (c GHC.Generics.:+: d) v x
instance (Language.Python.Optics.Idents.GHasIdents a c v x, Language.Python.Optics.Idents.GHasIdents b d v x) => Language.Python.Optics.Idents.GHasIdents (a GHC.Generics.:*: b) (c GHC.Generics.:*: d) v x
instance Language.Python.Optics.Idents.GHasIdents GHC.Generics.U1 GHC.Generics.U1 v x
instance Language.Python.Optics.Idents.GHasIdents GHC.Generics.V1 GHC.Generics.V1 v x
instance Language.Python.Optics.Idents.GHasIdents a b v x => Language.Python.Optics.Idents.GHasIdents (GHC.Generics.M1 i t a) (GHC.Generics.M1 i' t' b) v x
instance Language.Python.Optics.Idents.HasIdents' a b v x => Language.Python.Optics.Idents.GHasIdents (GHC.Generics.K1 i a) (GHC.Generics.K1 i b) v x
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Ann.Ann a) (Language.Python.Syntax.Ann.Ann a) v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Operator.Binary.BinOp a) (Language.Python.Syntax.Operator.Binary.BinOp a) v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Numbers.IntLiteral a) (Language.Python.Syntax.Numbers.IntLiteral a) v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Numbers.FloatLiteral a) (Language.Python.Syntax.Numbers.FloatLiteral a) v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Numbers.ImagLiteral a) (Language.Python.Syntax.Numbers.ImagLiteral a) v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Strings.StringLiteral a) (Language.Python.Syntax.Strings.StringLiteral a) v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Operator.Unary.UnOp a) (Language.Python.Syntax.Operator.Unary.UnOp a) v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.AugAssign.AugAssign a) (Language.Python.Syntax.AugAssign.AugAssign a) v a
instance Language.Python.Optics.Idents.HasIdents' Language.Python.Syntax.Whitespace.Whitespace Language.Python.Syntax.Whitespace.Whitespace v a
instance Language.Python.Optics.Idents.HasIdents' Language.Python.Syntax.Whitespace.Newline Language.Python.Syntax.Whitespace.Newline v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Whitespace.Blank a) (Language.Python.Syntax.Whitespace.Blank a) v a
instance Language.Python.Optics.Idents.HasIdents' Language.Python.Syntax.Punctuation.Colon Language.Python.Syntax.Punctuation.Colon v a
instance Language.Python.Optics.Idents.HasIdents' Language.Python.Syntax.Punctuation.At Language.Python.Syntax.Punctuation.At v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Punctuation.Semicolon a) (Language.Python.Syntax.Punctuation.Semicolon a) v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Comment.Comment a) (Language.Python.Syntax.Comment.Comment a) v a
instance Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.Whitespace.Indents a) (Language.Python.Syntax.Whitespace.Indents a) v a
instance Language.Python.Optics.Idents.HasIdents' Language.Python.Syntax.Punctuation.Dot Language.Python.Syntax.Punctuation.Dot v a
instance Language.Python.Optics.Idents.HasIdents' Language.Python.Syntax.Punctuation.Equals Language.Python.Syntax.Punctuation.Equals v a
instance Language.Python.Optics.Idents.HasIdents' Language.Python.Syntax.Punctuation.Comma Language.Python.Syntax.Punctuation.Comma v a
instance Language.Python.Optics.Idents.HasIdents' GHC.Types.Bool GHC.Types.Bool v a
instance Language.Python.Optics.Idents.HasIdents' a b v x => Language.Python.Optics.Idents.HasIdents' [a] [b] v x
instance Language.Python.Optics.Idents.HasIdents' a b v x => Language.Python.Optics.Idents.HasIdents' (GHC.Base.NonEmpty a) (GHC.Base.NonEmpty b) v x
instance Language.Python.Optics.Idents.HasIdents' a b v x => Language.Python.Optics.Idents.HasIdents' (GHC.Maybe.Maybe a) (GHC.Maybe.Maybe b) v x
instance Language.Python.Optics.Idents.HasIdents' a b v x => Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.CommaSep.CommaSep a) (Language.Python.Syntax.CommaSep.CommaSep b) v x
instance Language.Python.Optics.Idents.HasIdents' a b v x => Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.CommaSep.CommaSep1 a) (Language.Python.Syntax.CommaSep.CommaSep1 b) v x
instance Language.Python.Optics.Idents.HasIdents' a b v x => Language.Python.Optics.Idents.HasIdents' (Language.Python.Syntax.CommaSep.CommaSep1' a) (Language.Python.Syntax.CommaSep.CommaSep1' b) v x
instance (Language.Python.Optics.Idents.HasIdents' a b v x, Language.Python.Optics.Idents.HasIdents' c d v x) => Language.Python.Optics.Idents.HasIdents' (a, c) (b, d) v x
instance (Language.Python.Optics.Idents.HasIdents' a b v x, Language.Python.Optics.Idents.HasIdents' c d v x, Language.Python.Optics.Idents.HasIdents' e f v x) => Language.Python.Optics.Idents.HasIdents' (a, c, e) (b, d, f) v x
instance (Language.Python.Optics.Idents.HasIdents' a b v x, Language.Python.Optics.Idents.HasIdents' c d v x, Language.Python.Optics.Idents.HasIdents' e f v x, Language.Python.Optics.Idents.HasIdents' g h v x) => Language.Python.Optics.Idents.HasIdents' (a, c, e, g) (b, d, f, h) v x
instance (Language.Python.Optics.Idents.HasIdents' a b v x, Language.Python.Optics.Idents.HasIdents' c d v x) => Language.Python.Optics.Idents.HasIdents' (Data.Either.Either a c) (Data.Either.Either b d) v x


module Language.Python.Internal.Token

-- | A <a>PyToken</a> is a single lexical token of Python source. A
--   <a>PyToken</a> has an optional annotation, which can be '()' when no
--   annotation is desired.
data PyToken a
TkIf :: a -> PyToken a
TkElse :: a -> PyToken a
TkElif :: a -> PyToken a
TkWhile :: a -> PyToken a
TkAssert :: a -> PyToken a
TkDef :: a -> PyToken a
TkReturn :: a -> PyToken a
TkPass :: a -> PyToken a
TkBreak :: a -> PyToken a
TkContinue :: a -> PyToken a
TkTrue :: a -> PyToken a
TkFalse :: a -> PyToken a
TkNone :: a -> PyToken a
TkEllipsis :: a -> PyToken a
TkOr :: a -> PyToken a
TkAnd :: a -> PyToken a
TkIs :: a -> PyToken a
TkNot :: a -> PyToken a
TkGlobal :: a -> PyToken a
TkNonlocal :: a -> PyToken a
TkDel :: a -> PyToken a
TkLambda :: a -> PyToken a
TkImport :: a -> PyToken a
TkFrom :: a -> PyToken a
TkAs :: a -> PyToken a
TkRaise :: a -> PyToken a
TkTry :: a -> PyToken a
TkExcept :: a -> PyToken a
TkFinally :: a -> PyToken a
TkClass :: a -> PyToken a
TkRightArrow :: a -> PyToken a
TkWith :: a -> PyToken a
TkFor :: a -> PyToken a
TkIn :: a -> PyToken a
TkYield :: a -> PyToken a
TkInt :: IntLiteral a -> PyToken a
TkFloat :: FloatLiteral a -> PyToken a
TkImag :: ImagLiteral a -> PyToken a
TkIdent :: String -> a -> PyToken a
TkString :: Maybe StringPrefix -> StringType -> QuoteType -> [PyChar] -> a -> PyToken a
TkBytes :: BytesPrefix -> StringType -> QuoteType -> [PyChar] -> a -> PyToken a
TkRawString :: RawStringPrefix -> StringType -> QuoteType -> [PyChar] -> a -> PyToken a
TkRawBytes :: RawBytesPrefix -> StringType -> QuoteType -> [PyChar] -> a -> PyToken a
TkSpace :: a -> PyToken a
TkTab :: a -> PyToken a
TkNewline :: Newline -> a -> PyToken a
TkLeftBracket :: a -> PyToken a
TkRightBracket :: a -> PyToken a
TkLeftParen :: a -> PyToken a
TkRightParen :: a -> PyToken a
TkLeftBrace :: a -> PyToken a
TkRightBrace :: a -> PyToken a
TkLt :: a -> PyToken a
TkLte :: a -> PyToken a
TkEq :: a -> PyToken a
TkDoubleEq :: a -> PyToken a
TkBangEq :: a -> PyToken a
TkGt :: a -> PyToken a
TkGte :: a -> PyToken a
TkContinued :: Newline -> a -> PyToken a
TkColon :: a -> PyToken a
TkSemicolon :: a -> PyToken a
TkComma :: a -> PyToken a
TkDot :: a -> PyToken a
TkPlus :: a -> PyToken a
TkMinus :: a -> PyToken a
TkTilde :: a -> PyToken a
TkComment :: Comment a -> PyToken a
TkStar :: a -> PyToken a
TkDoubleStar :: a -> PyToken a
TkSlash :: a -> PyToken a
TkDoubleSlash :: a -> PyToken a
TkPercent :: a -> PyToken a
TkShiftLeft :: a -> PyToken a
TkShiftRight :: a -> PyToken a
TkPlusEq :: a -> PyToken a
TkMinusEq :: a -> PyToken a
TkStarEq :: a -> PyToken a
TkAtEq :: a -> PyToken a
TkAt :: a -> PyToken a
TkSlashEq :: a -> PyToken a
TkPercentEq :: a -> PyToken a
TkAmpersandEq :: a -> PyToken a
TkPipeEq :: a -> PyToken a
TkCaretEq :: a -> PyToken a
TkShiftLeftEq :: a -> PyToken a
TkShiftRightEq :: a -> PyToken a
TkDoubleStarEq :: a -> PyToken a
TkDoubleSlashEq :: a -> PyToken a
TkPipe :: a -> PyToken a
TkCaret :: a -> PyToken a
TkAmpersand :: a -> PyToken a
TkIndent :: a -> Indents a -> PyToken a
TkLevel :: a -> Indents a -> PyToken a
TkDedent :: a -> PyToken a

-- | Get the annotation from a <a>PyToken</a>.
pyTokenAnn :: PyToken a -> a
instance Data.Functor.Classes.Ord1 Language.Python.Internal.Token.PyToken
instance GHC.Classes.Eq (Language.Python.Internal.Token.PyToken a)
instance GHC.Classes.Ord (Language.Python.Internal.Token.PyToken a)
instance Data.Functor.Classes.Eq1 Language.Python.Internal.Token.PyToken
instance GHC.Base.Functor Language.Python.Internal.Token.PyToken
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Token.PyToken a)


module Language.Python.Optics.Indents

-- | <a>Traversal'</a> targeting the indent-chunks in a structure
--   
--   e.g.
--   
--   This is one indent chunk:
--   
--   <pre>
--   def a():
--       pass
--       if b:
--           pass
--   ^^^^
--   </pre>
--   
--   and this is another
--   
--   <pre>
--   def a():
--       pass
--       if b:
--           pass
--       ^^^^
--   </pre>
_Indent :: HasIndents s a => Traversal' s [Whitespace]
class HasIndents s a | s -> a

-- | <a>Traversal'</a> targeting the indentation inside a structure
--   
--   Note: whitespace inside 'enclosed forms' (such as lists or tuples) is
--   not considered indentation.
--   
--   e.g.
--   
--   In the following code, there is only one chunk of indentation:
--   
--   <pre>
--   def a():
--       [ b
--       , c
--       , d
--       ]
--   </pre>
--   
--   it's here:
--   
--   <pre>
--   def a():
--       [ b
--   ^^^^
--       , c
--       , d
--       ]
--   </pre>
--   
--   The rest is whitespace that is internal to the list.
_Indents :: HasIndents s a => Traversal' s (Indents a)
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Internal.Token.PyToken a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.Fundef '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.For '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.TryFinally '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.TryExcept '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.Except '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.Finally '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.If '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.While '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.Elif '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.Else '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Statement.SmallStatement '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Statement.Statement '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Statement.Block '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Statement.Suite '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Statement.Decorator '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.ClassDef '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Types.With '[] a) a
instance Language.Python.Optics.Indents.HasIndents (Language.Python.Syntax.Statement.CompoundStatement '[] a) a


-- | Optics for manipulating Python syntax trees
module Language.Python.Optics

-- | <a>Traversal</a> targeting the variables that would modified as a
--   result of an assignment
--   
--   Here are some examples of assignment targets:
--   
--   <pre>
--   a = b
--   ^
--   </pre>
--   
--   <pre>
--   (a, b, c) = d
--    ^  ^  ^
--   </pre>
--   
--   <pre>
--   [a, b, *c] = d
--    ^  ^   ^
--   </pre>
--   
--   These expressions have variables on the left hand side of the
--   <tt>=</tt>, but those variables don't count as assignment targets:
--   
--   <pre>
--   a[b] = c
--   </pre>
--   
--   <pre>
--   a(b) = c
--   </pre>
--   
--   <pre>
--   {a: b} = c
--   </pre>
assignTargets :: Traversal (Expr v a) (Expr '[] a) (Ident v a) (Ident '[] a)
class HasCompoundStatement s
_CompoundStatement :: HasCompoundStatement s => Prism (s v a) (s '[] a) (CompoundStatement v a) (CompoundStatement '[] a)
class HasFundef s
_Fundef :: HasFundef s => Prism (s v a) (s '[] a) (Fundef v a) (Fundef '[] a)
class HasClassDef s
_ClassDef :: HasClassDef s => Prism (s v a) (s '[] a) (ClassDef v a) (ClassDef '[] a)
class HasWhile s
_While :: HasWhile s => Prism (s v a) (s '[] a) (While v a) (While '[] a)
class HasFor s
_For :: HasFor s => Prism (s v a) (s '[] a) (For v a) (For '[] a)
class HasWith s
_With :: HasWith s => Prism (s v a) (s '[] a) (With v a) (With '[] a)
class HasIf s
_If :: HasIf s => Prism (s v a) (s '[] a) (If v a) (If '[] a)
_Elif :: Iso' (Elif v a) (Indents a, [Whitespace], Expr v a, Suite v a)
class HasTryExcept s
_TryExcept :: HasTryExcept s => Prism (s v a) (s '[] a) (TryExcept v a) (TryExcept '[] a)
class HasTryFinally s
_TryFinally :: HasTryFinally s => Prism (s v a) (s '[] a) (TryFinally v a) (TryFinally '[] a)
_Finally :: Iso' (Finally v a) (Indents a, [Whitespace], Suite v a)
_Except :: Iso' (Except v a) (Indents a, [Whitespace], Maybe (ExceptAs v a), Suite v a)
_Else :: Iso' (Else v a) (Indents a, [Whitespace], Suite v a)
_PositionalParam :: Prism (Param v a) (Param '[] a) (PositionalParam v a) (PositionalParam '[] a)
_KeywordParam :: Prism (Param v a) (Param '[] a) (KeywordParam v a) (KeywordParam '[] a)
_UnnamedStarParam :: Prism (Param v a) (Param '[] a) (UnnamedStarParam v a) (UnnamedStarParam '[] a)
_StarParam :: Prism (Param v a) (Param '[] a) (StarParam v a) (StarParam '[] a)

-- | A faux-Prism for matching on the <tt>Ident</tt> constructor of an
--   <a>SimpleStatement</a>.
--   
--   It's not a Prism because:
--   
--   When <a>preview</a>ing, it discards the 'Expr'\'s annotation, and when
--   <a>review</a>ing, it re-constructs an annotation from the supplied
--   <a>Ident</a>
--   
--   <pre>
--   <a>_Ident</a> :: <a>Prism</a> (<a>SimpleStatement</a> v a) (<a>SimpleStatement</a> '[] a) (<a>Expr</a> v a) (<a>Expr</a> '[] a)
--   </pre>
_Ident :: (Choice p, Applicative f) => p (Ident v a) (f (Ident '[] a)) -> p (Expr v a) (f (Expr '[] a))
_None :: Prism (Expr v a) (Expr '[] a) (None v a) (None '[] a)
_Call :: Prism (Expr v a) (Expr '[] a) (Call v a) (Call '[] a)
_Tuple :: Prism (Expr v a) (Expr '[] a) (Tuple v a) (Tuple '[] a)
_TupleUnpack :: Prism (TupleItem v a) (TupleItem '[] a) (TupleUnpack v a) (TupleUnpack '[] a)
tupleItems :: Traversal (Tuple v a) (Tuple '[] a) (TupleItem v a) (TupleItem '[] a)
_List :: Prism (Expr v a) (Expr '[] a) (List v a) (List '[] a)
_ListUnpack :: Prism (ListItem v a) (ListItem '[] a) (ListUnpack v a) (ListUnpack '[] a)
listItems :: Traversal (List v a) (List '[] a) (ListItem v a) (ListItem '[] a)
instance Language.Python.Optics.HasWith Language.Python.Syntax.Types.With
instance Language.Python.Optics.HasWith Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.HasWith Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.HasClassDef Language.Python.Syntax.Types.ClassDef
instance Language.Python.Optics.HasClassDef Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.HasClassDef Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.HasFor Language.Python.Syntax.Types.For
instance Language.Python.Optics.HasFor Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.HasFor Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.HasTryFinally Language.Python.Syntax.Types.TryFinally
instance Language.Python.Optics.HasTryFinally Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.HasTryFinally Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.HasTryExcept Language.Python.Syntax.Types.TryExcept
instance Language.Python.Optics.HasTryExcept Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.HasTryExcept Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.HasIf Language.Python.Syntax.Types.If
instance Language.Python.Optics.HasIf Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.HasIf Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.HasWhile Language.Python.Syntax.Types.While
instance Language.Python.Optics.HasWhile Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.HasWhile Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.HasFundef Language.Python.Syntax.Types.Fundef
instance Language.Python.Optics.HasFundef Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.HasFundef Language.Python.Syntax.Statement.Statement
instance Language.Python.Optics.HasCompoundStatement Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.Optics.HasCompoundStatement Language.Python.Syntax.Statement.Statement


-- | This module only exists as our current best solution to decoupling
--   parts of the concrete syntax from abstract syntax. You won't need to
--   care about its existence and hopefully it will be deleted soon.
module Language.Python.Internal.Syntax.IR
class AsIRError s a | s -> a
_InvalidUnpacking :: AsIRError s a => Prism' s a
data IRError a

-- | Unpacking ( <tt>*value</tt> ) was used in an invalid position
InvalidUnpacking :: a -> IRError a
fromIRError :: AsIRError s a => IRError a -> s
data SmallStatement a
MkSmallStatement :: SimpleStatement a -> [(Semicolon a, SimpleStatement a)] -> Maybe (Semicolon a) -> Maybe (Comment a) -> Maybe Newline -> SmallStatement a
data Statement a
SmallStatement :: Indents a -> SmallStatement a -> Statement a
CompoundStatement :: CompoundStatement a -> Statement a
data CompoundStatement a
Fundef :: a -> [Decorator a] -> Indents a -> Maybe (NonEmpty Whitespace) -> NonEmpty Whitespace -> Ident '[] a -> [Whitespace] -> CommaSep (Param a) -> [Whitespace] -> Maybe ([Whitespace], Expr a) -> Suite a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> a
[_unsafeCsFundefDecorators] :: CompoundStatement a -> [Decorator a]
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   ['async' &lt;spaces&gt;]
--   </pre>
[_unsafeCsFundefAsync] :: CompoundStatement a -> Maybe (NonEmpty Whitespace)

-- | <pre>
--   'def' &lt;spaces&gt;
--   </pre>
[_unsafeCsFundefDef] :: CompoundStatement a -> NonEmpty Whitespace

-- | <pre>
--   &lt;ident&gt;
--   </pre>
[_unsafeCsFundefName] :: CompoundStatement a -> Ident '[] a

-- | <pre>
--   '(' &lt;spaces&gt;
--   </pre>
[_unsafeCsFundefLeftParen] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;parameters&gt;
--   </pre>
[_unsafeCsFundefParameters] :: CompoundStatement a -> CommaSep (Param a)

-- | <pre>
--   ')' &lt;spaces&gt;
--   </pre>
[_unsafeCsFundefRightParen] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   ['-&gt;' &lt;spaces&gt; &lt;expr&gt;]
--   </pre>
[_unsafeCsFundefReturnType] :: CompoundStatement a -> Maybe ([Whitespace], Expr a)

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsFundefBody] :: CompoundStatement a -> Suite a
If :: a -> Indents a -> [Whitespace] -> Expr a -> Suite a -> [(Indents a, [Whitespace], Expr a, Suite a)] -> Maybe (Indents a, [Whitespace], Suite a) -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> a
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'if' &lt;spaces&gt;
--   </pre>
[_unsafeCsIfIf] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_unsafeCsIfCond] :: CompoundStatement a -> Expr a

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsIfBody] :: CompoundStatement a -> Suite a

-- | <pre>
--   ('elif' &lt;spaces&gt; &lt;expr&gt; &lt;suite&gt;)*
--   </pre>
[_unsafeCsIfElifs] :: CompoundStatement a -> [(Indents a, [Whitespace], Expr a, Suite a)]

-- | <pre>
--   ['else' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsIfElse] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite a)
While :: a -> Indents a -> [Whitespace] -> Expr a -> Suite a -> Maybe (Indents a, [Whitespace], Suite a) -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> a
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'while' &lt;spaces&gt;
--   </pre>
[_unsafeCsWhileWhile] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_unsafeCsWhileCond] :: CompoundStatement a -> Expr a

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsWhileBody] :: CompoundStatement a -> Suite a

-- | <pre>
--   ['else' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsWhileElse] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite a)
TryExcept :: a -> Indents a -> [Whitespace] -> Suite a -> NonEmpty (Indents a, [Whitespace], Maybe (ExceptAs a), Suite a) -> Maybe (Indents a, [Whitespace], Suite a) -> Maybe (Indents a, [Whitespace], Suite a) -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> a
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'try' &lt;spaces&gt;
--   </pre>
[_unsafeCsTryExceptTry] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsTryExceptBody] :: CompoundStatement a -> Suite a

-- | <pre>
--   ('except' &lt;spaces&gt; &lt;except_as&gt; &lt;suite&gt;)+
--   </pre>
[_unsafeCsTryExceptExcepts] :: CompoundStatement a -> NonEmpty (Indents a, [Whitespace], Maybe (ExceptAs a), Suite a)

-- | <pre>
--   ['else' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsTryExceptElse] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite a)

-- | <pre>
--   ['finally' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsTryExceptFinally] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite a)
TryFinally :: a -> Indents a -> [Whitespace] -> Suite a -> Indents a -> [Whitespace] -> Suite a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> a
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'try' &lt;spaces&gt;
--   </pre>
[_unsafeCsTryFinallyTry] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsTryFinallyTryBody] :: CompoundStatement a -> Suite a
[_unsafeCsTryFinallyFinallyIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'finally' &lt;spaces&gt;
--   </pre>
[_unsafeCsTryFinallyFinally] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsTryFinallyFinallyBody] :: CompoundStatement a -> Suite a
For :: a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> Expr a -> [Whitespace] -> CommaSep1' (Expr a) -> Suite a -> Maybe (Indents a, [Whitespace], Suite a) -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> a
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   ['async' &lt;spaces&gt;]
--   </pre>
[_unsafeCsForAsync] :: CompoundStatement a -> Maybe (NonEmpty Whitespace)

-- | <pre>
--   'for' &lt;spaces&gt;
--   </pre>
[_unsafeCsForFor] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_unsafeCsForBinder] :: CompoundStatement a -> Expr a

-- | <pre>
--   'in' &lt;spaces&gt;
--   </pre>
[_unsafeCsForIn] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;exprs&gt;
--   </pre>
[_unsafeCsForCollection] :: CompoundStatement a -> CommaSep1' (Expr a)

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsForBody] :: CompoundStatement a -> Suite a

-- | <pre>
--   ['else' &lt;spaces&gt; &lt;suite&gt;]
--   </pre>
[_unsafeCsForElse] :: CompoundStatement a -> Maybe (Indents a, [Whitespace], Suite a)
ClassDef :: a -> [Decorator a] -> Indents a -> NonEmpty Whitespace -> Ident '[] a -> Maybe ([Whitespace], Maybe (CommaSep1' (Arg a)), [Whitespace]) -> Suite a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> a
[_unsafeCsClassDefDecorators] :: CompoundStatement a -> [Decorator a]
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   'class' &lt;spaces&gt;
--   </pre>
[_unsafeCsClassDefClass] :: CompoundStatement a -> NonEmpty Whitespace

-- | <pre>
--   &lt;ident&gt;
--   </pre>
[_unsafeCsClassDefName] :: CompoundStatement a -> Ident '[] a

-- | <pre>
--   ['(' &lt;spaces&gt; [&lt;args&gt;] ')' &lt;spaces&gt;]
--   </pre>
[_unsafeCsClassDefArguments] :: CompoundStatement a -> Maybe ([Whitespace], Maybe (CommaSep1' (Arg a)), [Whitespace])

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsClassDefBody] :: CompoundStatement a -> Suite a
With :: a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> CommaSep1 (WithItem a) -> Suite a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> a
[_csIndents] :: CompoundStatement a -> Indents a

-- | <pre>
--   ['async' &lt;spaces&gt;]
--   </pre>
[_unsafeCsWithAsync] :: CompoundStatement a -> Maybe (NonEmpty Whitespace)

-- | <pre>
--   'with' &lt;spaces&gt;
--   </pre>
[_unsafeCsWithWith] :: CompoundStatement a -> [Whitespace]

-- | <pre>
--   &lt;with_items&gt;
--   </pre>
[_unsafeCsWithItems] :: CompoundStatement a -> CommaSep1 (WithItem a)

-- | <pre>
--   &lt;suite&gt;
--   </pre>
[_unsafeCsWithBody] :: CompoundStatement a -> Suite a
data SimpleStatement a
Return :: a -> [Whitespace] -> Maybe (Expr a) -> SimpleStatement a
Expr :: a -> Expr a -> SimpleStatement a
Assign :: a -> Expr a -> NonEmpty (Equals, Expr a) -> SimpleStatement a
AugAssign :: a -> Expr a -> AugAssign a -> Expr a -> SimpleStatement a
Pass :: a -> [Whitespace] -> SimpleStatement a
Break :: a -> [Whitespace] -> SimpleStatement a
Continue :: a -> [Whitespace] -> SimpleStatement a
Global :: a -> NonEmpty Whitespace -> CommaSep1 (Ident '[] a) -> SimpleStatement a
Nonlocal :: a -> NonEmpty Whitespace -> CommaSep1 (Ident '[] a) -> SimpleStatement a
Del :: a -> [Whitespace] -> CommaSep1' (Expr a) -> SimpleStatement a
Import :: a -> NonEmpty Whitespace -> CommaSep1 (ImportAs ModuleName '[] a) -> SimpleStatement a
From :: a -> [Whitespace] -> RelativeModuleName '[] a -> [Whitespace] -> ImportTargets '[] a -> SimpleStatement a
Raise :: a -> [Whitespace] -> Maybe (Expr a, Maybe ([Whitespace], Expr a)) -> SimpleStatement a
Assert :: a -> [Whitespace] -> Expr a -> Maybe (Comma, Expr a) -> SimpleStatement a
data Param a
PositionalParam :: a -> Ident '[] a -> Maybe (Colon, Expr a) -> Param a
[_paramAnn] :: Param a -> a
[_paramName] :: Param a -> Ident '[] a
[_paramType] :: Param a -> Maybe (Colon, Expr a)
KeywordParam :: a -> Ident '[] a -> Maybe (Colon, Expr a) -> [Whitespace] -> Expr a -> Param a
[_paramAnn] :: Param a -> a
[_paramName] :: Param a -> Ident '[] a
[_paramType] :: Param a -> Maybe (Colon, Expr a)
[_unsafeKeywordParamWhitespaceRight] :: Param a -> [Whitespace]
[_unsafeKeywordParamExpr] :: Param a -> Expr a
StarParam :: a -> [Whitespace] -> Ident '[] a -> Maybe (Colon, Expr a) -> Param a
[_paramAnn] :: Param a -> a
[_unsafeStarParamWhitespace] :: Param a -> [Whitespace]
[_unsafeStarParamName] :: Param a -> Ident '[] a
[_paramType] :: Param a -> Maybe (Colon, Expr a)
UnnamedStarParam :: a -> [Whitespace] -> Param a
[_paramAnn] :: Param a -> a
[_unsafeUnnamedStarParamWhitespace] :: Param a -> [Whitespace]
DoubleStarParam :: a -> [Whitespace] -> Ident '[] a -> Maybe (Colon, Expr a) -> Param a
[_paramAnn] :: Param a -> a
[_unsafeDoubleStarParamWhitespace] :: Param a -> [Whitespace]
[_paramName] :: Param a -> Ident '[] a
[_paramType] :: Param a -> Maybe (Colon, Expr a)
data CompIf a

-- | 'if' <a>any_spaces</a> <a>expr</a>
CompIf :: a -> [Whitespace] -> Expr a -> CompIf a
data CompFor a

-- | <tt>for</tt> <a>any_spaces</a> <a>targets</a> 'in' <a>any_spaces</a>
--   <a>expr</a>
CompFor :: a -> [Whitespace] -> Expr a -> [Whitespace] -> Expr a -> CompFor a
data Comprehension e a

-- | <a>expr</a> <a>comp_for</a> (comp_for | comp_if)*
Comprehension :: a -> e a -> CompFor a -> [Either (CompFor a) (CompIf a)] -> Comprehension e a
data Subscript a
SubscriptExpr :: Expr a -> Subscript a
SubscriptSlice :: Maybe (Expr a) -> Colon -> Maybe (Expr a) -> Maybe (Colon, Maybe (Expr a)) -> Subscript a
data DictItem a
DictItem :: a -> Expr a -> Colon -> Expr a -> DictItem a
[_dictItemAnn] :: DictItem a -> a
[_unsafeDictItemKey] :: DictItem a -> Expr a
[_unsafeDictItemColon] :: DictItem a -> Colon
[_unsafeDictItemvalue] :: DictItem a -> Expr a
DictUnpack :: a -> [Whitespace] -> Expr a -> DictItem a
[_dictItemAnn] :: DictItem a -> a
[_unsafeDictItemUnpackWhitespace] :: DictItem a -> [Whitespace]
[_unsafeDictItemUnpackValue] :: DictItem a -> Expr a
data Arg a
PositionalArg :: a -> Expr a -> Arg a
[_argAnn] :: Arg a -> a
[_argExpr] :: Arg a -> Expr a
KeywordArg :: a -> Ident '[] a -> [Whitespace] -> Expr a -> Arg a
[_argAnn] :: Arg a -> a
[_unsafeKeywordArgName] :: Arg a -> Ident '[] a
[_unsafeKeywordArgWhitespaceRight] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr a
StarArg :: a -> [Whitespace] -> Expr a -> Arg a
[_argAnn] :: Arg a -> a
[_unsafeStarArgWhitespace] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr a
DoubleStarArg :: a -> [Whitespace] -> Expr a -> Arg a
[_argAnn] :: Arg a -> a
[_unsafeDoubleStarArgWhitespace] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr a
data Expr a
StarExpr :: a -> [Whitespace] -> Expr a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeStarExprWhitespace] :: Expr a -> [Whitespace]
[_unsafeStarExprValue] :: Expr a -> Expr a
Unit :: a -> [Whitespace] -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeUnitWhitespaceInner] :: Expr a -> [Whitespace]
[_unsafeUnitWhitespaceRight] :: Expr a -> [Whitespace]
Lambda :: a -> [Whitespace] -> CommaSep (Param a) -> Colon -> Expr a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeLambdaWhitespace] :: Expr a -> [Whitespace]
[_unsafeLambdaArgs] :: Expr a -> CommaSep (Param a)
[_unsafeLambdaColon] :: Expr a -> Colon
[_unsafeLambdaBody] :: Expr a -> Expr a
Yield :: a -> [Whitespace] -> CommaSep (Expr a) -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeYieldWhitespace] :: Expr a -> [Whitespace]
[_unsafeYieldValue] :: Expr a -> CommaSep (Expr a)
YieldFrom :: a -> [Whitespace] -> [Whitespace] -> Expr a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeYieldWhitespace] :: Expr a -> [Whitespace]
[_unsafeFromWhitespace] :: Expr a -> [Whitespace]
[_unsafeYieldFromValue] :: Expr a -> Expr a
Ternary :: a -> Expr a -> [Whitespace] -> Expr a -> [Whitespace] -> Expr a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeTernaryValue] :: Expr a -> Expr a
[_unsafeTernaryWhitespaceIf] :: Expr a -> [Whitespace]
[_unsafeTernaryCond] :: Expr a -> Expr a
[_unsafeTernaryWhitespaceElse] :: Expr a -> [Whitespace]
[_unsafeTernaryElse] :: Expr a -> Expr a
ListComp :: a -> [Whitespace] -> Comprehension Expr a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeListCompWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeListCompValue] :: Expr a -> Comprehension Expr a
[_unsafeListCompWhitespaceRight] :: Expr a -> [Whitespace]
List :: a -> [Whitespace] -> Maybe (CommaSep1' (Expr a)) -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeListWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeListValues] :: Expr a -> Maybe (CommaSep1' (Expr a))
[_unsafeListWhitespaceRight] :: Expr a -> [Whitespace]
DictComp :: a -> [Whitespace] -> Comprehension DictItem a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeDictCompWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeDictCompValue] :: Expr a -> Comprehension DictItem a
[_unsafeDictCompWhitespaceRight] :: Expr a -> [Whitespace]
Dict :: a -> [Whitespace] -> Maybe (CommaSep1' (DictItem a)) -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeDictWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeDictValues] :: Expr a -> Maybe (CommaSep1' (DictItem a))
[_unsafeDictWhitespaceRight] :: Expr a -> [Whitespace]
SetComp :: a -> [Whitespace] -> Comprehension Expr a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeSetCompWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeSetCompValue] :: Expr a -> Comprehension Expr a
[_unsafeSetCompWhitespaceRight] :: Expr a -> [Whitespace]
Set :: a -> [Whitespace] -> CommaSep1' (Expr a) -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeSetWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeSetValues] :: Expr a -> CommaSep1' (Expr a)
[_unsafeSetWhitespaceRight] :: Expr a -> [Whitespace]
Deref :: a -> Expr a -> [Whitespace] -> Ident '[] a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeDerefValueLeft] :: Expr a -> Expr a
[_unsafeDerefWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeDerefValueRight] :: Expr a -> Ident '[] a
Subscript :: a -> Expr a -> [Whitespace] -> CommaSep1' (Subscript a) -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeSubscriptValueLeft] :: Expr a -> Expr a
[_unsafeSubscriptWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeSubscriptValueRight] :: Expr a -> CommaSep1' (Subscript a)
[_unsafeSubscriptWhitespaceRight] :: Expr a -> [Whitespace]
Call :: a -> Expr a -> [Whitespace] -> Maybe (CommaSep1' (Arg a)) -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeCallFunction] :: Expr a -> Expr a
[_unsafeCallWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeCallArguments] :: Expr a -> Maybe (CommaSep1' (Arg a))
[_unsafeCallWhitespaceRight] :: Expr a -> [Whitespace]
None :: a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeNoneWhitespace] :: Expr a -> [Whitespace]
Ellipsis :: a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeEllipsisWhitespace] :: Expr a -> [Whitespace]
BinOp :: a -> Expr a -> BinOp a -> Expr a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeBinOpExprLeft] :: Expr a -> Expr a
[_unsafeBinOpOp] :: Expr a -> BinOp a
[_unsafeBinOpExprRight] :: Expr a -> Expr a
UnOp :: a -> UnOp a -> Expr a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeUnOpOp] :: Expr a -> UnOp a
[_unsafeUnOpValue] :: Expr a -> Expr a
Parens :: a -> [Whitespace] -> Expr a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeParensWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeParensValue] :: Expr a -> Expr a
[_unsafeParensWhitespaceAfter] :: Expr a -> [Whitespace]
Ident :: a -> Ident '[] a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeIdentValue] :: Expr a -> Ident '[] a
Int :: a -> IntLiteral a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeIntValue] :: Expr a -> IntLiteral a
[_unsafeIntWhitespace] :: Expr a -> [Whitespace]
Float :: a -> FloatLiteral a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeFloatValue] :: Expr a -> FloatLiteral a
[_unsafeFloatWhitespace] :: Expr a -> [Whitespace]
Imag :: a -> ImagLiteral a -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeImagValue] :: Expr a -> ImagLiteral a
[_unsafeImagWhitespace] :: Expr a -> [Whitespace]
Bool :: a -> Bool -> [Whitespace] -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeBoolValue] :: Expr a -> Bool
[_unsafeBoolWhitespace] :: Expr a -> [Whitespace]
String :: a -> NonEmpty (StringLiteral a) -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeStringLiteralValue] :: Expr a -> NonEmpty (StringLiteral a)
Tuple :: a -> Expr a -> Comma -> Maybe (CommaSep1' (Expr a)) -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeTupleHead] :: Expr a -> Expr a
[_unsafeTupleWhitespace] :: Expr a -> Comma
[_unsafeTupleTail] :: Expr a -> Maybe (CommaSep1' (Expr a))
Not :: a -> [Whitespace] -> Expr a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeNotWhitespace] :: Expr a -> [Whitespace]
[_unsafeNotValue] :: Expr a -> Expr a
Generator :: a -> Comprehension Expr a -> Expr a
[_exprAnn] :: Expr a -> a
[_generatorValue] :: Expr a -> Comprehension Expr a
Await :: a -> [Whitespace] -> Expr a -> Expr a
[_exprAnn] :: Expr a -> a
[_unsafeAwaitWhitespace] :: Expr a -> [Whitespace]
[_unsafeAwaitValue] :: Expr a -> Expr a
exprAnn :: Lens' (Expr a) a
data Suite a
SuiteOne :: a -> Colon -> SmallStatement a -> Suite a
SuiteMany :: a -> Colon -> Maybe (Comment a) -> Newline -> Block a -> Suite a
data Block a
Block :: [(Blank a, Newline)] -> Statement a -> [Either (Blank a, Newline) (Statement a)] -> Block a
[_blockBlankLines] :: Block a -> [(Blank a, Newline)]
[_blockHead] :: Block a -> Statement a
[_blockTail] :: Block a -> [Either (Blank a, Newline) (Statement a)]
data WithItem a
WithItem :: a -> Expr a -> Maybe ([Whitespace], Expr a) -> WithItem a
[_withItemAnn] :: WithItem a -> a
[_withItemValue] :: WithItem a -> Expr a
[_withItemBinder] :: WithItem a -> Maybe ([Whitespace], Expr a)
data Decorator a
Decorator :: a -> Indents a -> At -> Expr a -> Maybe (Comment a) -> Newline -> [(Blank a, Newline)] -> Decorator a
[_decoratorAnn] :: Decorator a -> a
[_decoratorIndents] :: Decorator a -> Indents a
[_decoratorAt] :: Decorator a -> At
[_decoratorExpr] :: Decorator a -> Expr a
[_decoratorComment] :: Decorator a -> Maybe (Comment a)
[_decoratorNewline] :: Decorator a -> Newline
[_decoratorBlankLines] :: Decorator a -> [(Blank a, Newline)]
data ExceptAs a
ExceptAs :: a -> Expr a -> Maybe ([Whitespace], Ident '[] a) -> ExceptAs a
[_exceptAsAnn] :: ExceptAs a -> a
[_exceptAsExpr] :: ExceptAs a -> Expr a
[_exceptAsName] :: ExceptAs a -> Maybe ([Whitespace], Ident '[] a)
data Module a
ModuleEmpty :: Module a
ModuleBlankFinal :: Blank a -> Module a
ModuleBlank :: Blank a -> Newline -> Module a -> Module a
ModuleStatement :: Statement a -> Module a -> Module a
data FromIRContext
FromIRContext :: Bool -> FromIRContext
[_allowStarred] :: FromIRContext -> Bool
allowStarred :: Iso' FromIRContext Bool
fromIR_expr :: AsIRError e a => Expr a -> Validation (NonEmpty e) (Expr '[] a)
fromIR_suite :: AsIRError e a => Suite a -> Validation (NonEmpty e) (Suite '[] a)
fromIR_param :: AsIRError e a => Param a -> Validation (NonEmpty e) (Param '[] a)
fromIR_arg :: AsIRError e a => Arg a -> Validation (NonEmpty e) (Arg '[] a)
fromIR_decorator :: AsIRError e a => Decorator a -> Validation (NonEmpty e) (Decorator '[] a)
fromIR_exceptAs :: AsIRError e a => ExceptAs a -> Validation (NonEmpty e) (ExceptAs '[] a)
fromIR_withItem :: AsIRError e a => WithItem a -> Validation (NonEmpty e) (WithItem '[] a)
fromIR_comprehension :: AsIRError e a => (ex a -> Validation (NonEmpty e) (ex' '[] a)) -> Comprehension ex a -> Validation (NonEmpty e) (Comprehension ex' '[] a)
fromIR_dictItem :: AsIRError e a => DictItem a -> Validation (NonEmpty e) (DictItem '[] a)
fromIR_subscript :: AsIRError e a => Subscript a -> Validation (NonEmpty e) (Subscript '[] a)
fromIR_block :: AsIRError e a => Block a -> Validation (NonEmpty e) (Block '[] a)
fromIR_compFor :: AsIRError e a => CompFor a -> Validation (NonEmpty e) (CompFor '[] a)
fromIR_compIf :: AsIRError e a => CompIf a -> Validation (NonEmpty e) (CompIf '[] a)
fromIR_smallStatement :: AsIRError e a => SmallStatement a -> Validation (NonEmpty e) (SmallStatement '[] a)
fromIR_statement :: AsIRError e a => Statement a -> Validation (NonEmpty e) (Statement '[] a)
fromIR_SimpleStatement :: AsIRError e a => SimpleStatement a -> Validation (NonEmpty e) (SimpleStatement '[] a)
fromIR_compoundStatement :: AsIRError e a => CompoundStatement a -> Validation (NonEmpty e) (CompoundStatement '[] a)
fromIR_listItem :: AsIRError e a => Expr a -> Validation (NonEmpty e) (ListItem '[] a)
fromIR_tupleItem :: AsIRError e a => Expr a -> Validation (NonEmpty e) (TupleItem '[] a)
fromIR_setItem :: AsIRError e a => Expr a -> Validation (NonEmpty e) (SetItem '[] a)
fromIR :: AsIRError e a => Module a -> Validation (NonEmpty e) (Module '[] a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.Module
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.Module
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.Module
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Module a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Module a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.Statement
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.Statement
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.Statement
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Statement a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Statement a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Block a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Block a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.Suite
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.Suite
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.Suite
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Suite a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Suite a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.CompoundStatement
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.CompoundStatement
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.CompoundStatement
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.CompoundStatement a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.CompoundStatement a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.ExceptAs
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.ExceptAs
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.ExceptAs
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.ExceptAs a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.ExceptAs a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.Decorator
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.Decorator
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.Decorator
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Decorator a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Decorator a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.WithItem
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.WithItem
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.WithItem
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.WithItem a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.WithItem a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.SmallStatement
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.SmallStatement
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.SmallStatement
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.SmallStatement a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.SmallStatement a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.SimpleStatement
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.SimpleStatement
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.SimpleStatement
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.SimpleStatement a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.SimpleStatement a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.Param
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.Param
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.Param
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Param a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Param a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.CompIf
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.CompIf
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.CompIf
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.CompIf a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.CompIf a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.CompFor
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.CompFor
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.CompFor
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.CompFor a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.CompFor a)
instance (GHC.Show.Show a, GHC.Show.Show (e a)) => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Comprehension e a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq (e a)) => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Comprehension e a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.Subscript
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.Subscript
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.Subscript
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Subscript a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Subscript a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.DictItem
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.DictItem
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.DictItem
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.DictItem a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.DictItem a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.Arg
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.Arg
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.Arg
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Arg a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Arg a)
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.Expr
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.Expr
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.Expr
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.Expr a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.Expr a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Syntax.IR.IRError a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Syntax.IR.IRError a)
instance GHC.Base.Functor Language.Python.Internal.Syntax.IR.Block
instance Data.Foldable.Foldable Language.Python.Internal.Syntax.IR.Block
instance Data.Traversable.Traversable Language.Python.Internal.Syntax.IR.Block
instance GHC.Base.Functor e => GHC.Base.Functor (Language.Python.Internal.Syntax.IR.Comprehension e)
instance Data.Foldable.Foldable e => Data.Foldable.Foldable (Language.Python.Internal.Syntax.IR.Comprehension e)
instance Data.Traversable.Traversable e => Data.Traversable.Traversable (Language.Python.Internal.Syntax.IR.Comprehension e)


-- | There are configurations of the core syntax tree which won't print to
--   valid Python if we printed them naively. Many of these we catch in the
--   <a>Syntax</a> phase, because those mistakes correspond to some Python
--   syntax error. In other cases, the mistakes are more benign and have a
--   "resonable correction" which doesn't break the "print-parse
--   idempotence" law.
--   
--   This module is where such corrections are defined
module Language.Python.Internal.Render.Correction

-- | Trailing commas can only be present in a parameter list of entirely
--   positional arguments. This removes the bad trailing comma, and appends
--   the comma's trailing whitespace to the previous token
correctParams :: CommaSep (Param v a) -> CommaSep (Param v a)
correctSpaces :: (PyToken () -> Text) -> [PyToken ()] -> [PyToken ()]
correctNewlines :: [PyToken ()] -> [PyToken ()]

-- | Two non-typed single-quoted strings cannot be lexically adjacent,
--   because this would be a parse error
--   
--   eg. '''' or """"
--   
--   we correct for this by inserting a single space where required '' ''
--   or "" ""
correctAdjacentStrings :: NonEmpty (StringLiteral a) -> NonEmpty (StringLiteral a)
quoteChar :: QuoteType -> PyChar
quote :: QuoteType -> Char

-- | When a backslash character, precedes an escape sequence it needs to be
--   escaped so that it doesn't interfere with the backslash that begins
--   the escape sequence.
--   
--   For example:
--   
--   <tt>[<a>Char_lit</a> '\\', Char_esc_n]</tt> would naively render to
--   '\\n', which would parse to <tt>[<a>Char_esc_bslash</a>,
--   <a>Char_lit</a> 'n']</tt>, breaking the <tt>parse . print</tt>
--   identity
correctBackslashEscapes :: [PyChar] -> [PyChar]
correctBackslashes :: [PyChar] -> [PyChar]

-- | <tt>(as, bs) = span p xs</tt> <tt>bs</tt> is the longest suffix that
--   satisfies the predicate, and <tt>as</tt> is the prefix up to that
--   point
--   
--   It's like the reverse of <a>span</a>
naps :: (a -> Maybe b) -> [a] -> ([a], [b])

-- | Sometimes strings need to be corrected when certain characters follow
--   a literal backslash. For example, a literal backslash followed by an
--   escape sequence means that the literal backslash actually needs to be
--   escaped, so that it doesn't get <tt>combined</tt> with the backslash
--   in the escape sequence.
correctBackslashEscapesRaw :: [PyChar] -> [PyChar]

-- | It turns out that raw strings can only ever be constructed with an
--   even number of trailing backslash characters. This functon corrects
--   raw strings with an odd number of trailing backslash characters
correctBackslashesRaw :: [PyChar] -> [PyChar]

-- | Every quote in a string of a particular quote type should be escaped
correctQuotes :: QuoteType -> [PyChar] -> [PyChar]

-- | Every quote in short raw string that isn't preceded by a backslash
--   should be escaped
correctQuotesRaw :: QuoteType -> [PyChar] -> [PyChar]

-- | Every third literal quote at the beginning of a long (non-raw) string
--   should be escaped
correctInitialQuotes :: QuoteType -> [PyChar] -> [PyChar]

-- | Literal quotes at the beginning and end of a long raw string should be
--   escaped
correctInitialFinalQuotesLongRaw :: QuoteType -> [PyChar] -> [PyChar]

-- | Literal quotes at the beginning and end of a long (non-raw) string
--   should be escaped
correctInitialFinalQuotesLong :: QuoteType -> [PyChar] -> [PyChar]

-- | It's possible that successive statements have no newlines in between
--   them. This would cause them to be displayed on the same line. In every
--   line where this would be the case, we explicitly insert a line-feed
--   character.
correctTrailingNewline :: HasTrailingNewline s => Bool -> s v a -> s v a


module Language.Python.Internal.Render

-- | Render an entire Python module to <a>Text</a>
showModule :: Module v a -> Text

-- | Render a single Python statement to <a>Text</a>
showStatement :: Statement v a -> Text

-- | Render a single Python expression to <a>Text</a>
showExpr :: Expr v a -> Text

-- | A <a>RenderOutput</a> is an intermediate form used during rendering
--   with efficient concatenation
data RenderOutput a

-- | Run a <a>RenderOutput</a> to produce a final <a>Text</a>.
--   
--   These <a>Text</a>s should then not be appended any more. All appending
--   should be done during the <a>RenderOutput</a> phase.
showRenderOutput :: RenderOutput a -> Text

-- | Render a single token as a <a>RenderOutput</a>
singleton :: PyToken () -> RenderOutput ()
renderModule :: Module v a -> RenderOutput ()
renderStatement :: Statement v a -> RenderOutput ()
renderExpr :: Expr v a -> RenderOutput ()
showQuoteType :: QuoteType -> Char
showStringPrefix :: StringPrefix -> Text
showBytesPrefix :: BytesPrefix -> Text
showToken :: PyToken a -> Text
showTokens :: [PyToken a] -> Text
expandIndents :: PyToken a -> [PyToken ()]
whitespaceTokens :: Whitespace -> [PyToken ()]
commentTokens :: Comment a -> [PyToken ()]
parens :: RenderOutput a -> RenderOutput a
braces :: RenderOutput a -> RenderOutput a
brackets :: RenderOutput a -> RenderOutput a
renderWhitespace :: Whitespace -> RenderOutput ()
renderCommaSep :: (a -> RenderOutput ()) -> CommaSep a -> RenderOutput ()
renderCommaSep1 :: (a -> RenderOutput ()) -> CommaSep1 a -> RenderOutput ()
renderCommaSep1' :: (a -> RenderOutput ()) -> CommaSep1' a -> RenderOutput ()
renderIdent :: Ident v a -> RenderOutput ()
renderComment :: Comment a -> RenderOutput ()
renderModuleName :: ModuleName v a -> RenderOutput ()
renderDot :: Dot -> RenderOutput ()
renderRelativeModuleName :: RelativeModuleName v a -> RenderOutput ()
renderImportAs :: (e v a -> RenderOutput ()) -> ImportAs e v a -> RenderOutput ()
renderImportTargets :: ImportTargets v a -> RenderOutput ()
renderSimpleStatement :: SimpleStatement v a -> RenderOutput ()
renderCompoundStatement :: CompoundStatement v a -> RenderOutput ()
renderBlock :: Block v a -> RenderOutput ()
renderIndent :: Indent -> RenderOutput ()
renderIndents :: Indents a -> RenderOutput ()
renderExceptAs :: ExceptAs v a -> RenderOutput ()
renderArg :: (Expr v a -> RenderOutput ()) -> Arg v a -> RenderOutput ()
renderParam :: Param v a -> RenderOutput ()
renderParams :: CommaSep (Param v a) -> RenderOutput ()
renderCompFor :: CompFor v a -> RenderOutput ()
renderCompIf :: CompIf v a -> RenderOutput ()
renderComprehension :: (e v a -> RenderOutput ()) -> Comprehension e v a -> RenderOutput ()
renderBinOp :: BinOp a -> RenderOutput ()
renderUnOp :: UnOp a -> RenderOutput ()
renderSubscript :: Subscript v a -> RenderOutput ()
renderPyChars :: QuoteType -> StringType -> [PyChar] -> Text
escapeChars :: [(Char, Char)]
intToHex :: Int -> Text
instance GHC.Base.Monad Language.Python.Internal.Render.RenderOutput
instance GHC.Base.Applicative Language.Python.Internal.Render.RenderOutput
instance GHC.Base.Functor Language.Python.Internal.Render.RenderOutput


module Language.Python.Render

-- | Render an entire Python module to <a>Text</a>
showModule :: Module v a -> Text

-- | Render a single Python statement to <a>Text</a>
showStatement :: Statement v a -> Text

-- | Render a single Python expression to <a>Text</a>
showExpr :: Expr v a -> Text


module Language.Python.Internal.Lexer

-- | Tokenize an input file, inserting indent/level/dedent tokens in
--   appropriate positions according to the block structure.
tokenizeWithTabs :: (AsLexicalError s Char, AsTabError s SrcInfo, AsIncorrectDedent s SrcInfo) => FilePath -> Text -> Either s [PyToken SrcInfo]
data SrcInfo
SrcInfo :: FilePath -> !Int -> !Int -> !Int -> !Int -> !Int -> !Int -> SrcInfo
[_srcInfoName] :: SrcInfo -> FilePath
[_srcInfoLineStart] :: SrcInfo -> !Int
[_srcInfoLineEnd] :: SrcInfo -> !Int
[_srcInfoColStart] :: SrcInfo -> !Int
[_srcInfoColEnd] :: SrcInfo -> !Int
[_srcInfoOffsetStart] :: SrcInfo -> !Int
[_srcInfoOffsetEnd] :: SrcInfo -> !Int
initialSrcInfo :: FilePath -> SrcInfo
withSrcInfo :: MonadParsec e s m => m (SrcInfo -> a) -> m a
class AsLexicalError s t | s -> t
_LexicalError :: AsLexicalError s t => Prism' s (NonEmpty SourcePos, Maybe (ErrorItem t), Set (ErrorItem t))

-- | Convert a concrete <a>ParseError</a> to a value that has an instance
--   of <a>AsLexicalError</a>
--   
--   This function is partial, because our parser will never use
--   <a>FancyError</a>
unsafeFromLexicalError :: (HasCallStack, AsLexicalError s t) => ParseError t Void -> s
class AsTabError s a | s -> a
_TabError :: AsTabError s a => Prism' s a
class AsIncorrectDedent s a | s -> a
_IncorrectDedent :: AsIncorrectDedent s a => Prism' s a

-- | Convert a concrete <a>TabError</a> to a value that has an instance of
--   <a>AsTabError</a>
fromTabError :: (AsTabError s a, AsIncorrectDedent s a) => TabError a -> s
data TabError a

-- | Tabs and spaces were used inconsistently
TabError :: a -> TabError a

-- | The dedent at the end of a block doesn't match and preceding indents
--   
--   e.g.
--   
--   <pre>
--   def a():
--       if b:
--           pass
--       else:
--           pass
--     pass
--   </pre>
--   
--   The final line will cause an <a>IncorrectDedent</a> error
IncorrectDedent :: a -> TabError a

-- | Convert some input to a sequence of tokens. Indent and dedent tokens
--   are not added (see <a>insertTabs</a>)
tokenize :: AsLexicalError e Char => FilePath -> Text -> Either e [PyToken SrcInfo]

-- | Insert indent and dedent tokens
--   
--   
--   <a>https://docs.python.org/3.5/reference/lexical_analysis.html#indentation</a>
insertTabs :: (Semigroup a, AsTabError s a, AsIncorrectDedent s a) => a -> [PyToken a] -> Either s [PyToken a]

-- | <tt><a>ParseError</a> t e</tt> represents a parse error parametrized
--   over the token type <tt>t</tt> and the custom data <tt>e</tt>.
--   
--   Note that the stack of source positions contains current position as
--   its head, and the rest of positions allows to track full sequence of
--   include files with topmost source file at the end of the list.
--   
--   <a>Semigroup</a> and <a>Monoid</a> instances of the data type allow to
--   merge parse errors from different branches of parsing. When merging
--   two <a>ParseError</a>s, the longest match is preferred; if positions
--   are the same, custom data sets and collections of message items are
--   combined. Note that fancy errors take precedence over trivial errors
--   in merging.
data ParseError t e

-- | Trivial errors, generated by Megaparsec's machinery. The data
--   constructor includes the stack of source positions, unexpected token
--   (if any), and expected tokens.
TrivialError :: NonEmpty SourcePos -> Maybe (ErrorItem t) -> Set (ErrorItem t) -> ParseError t e

-- | Fancy, custom errors.
FancyError :: NonEmpty SourcePos -> Set (ErrorFancy e) -> ParseError t e
instance GHC.Num.Num a => GHC.Num.Num (Language.Python.Internal.Lexer.Summed a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Language.Python.Internal.Lexer.Summed a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Lexer.Summed a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Lexer.Summed a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Lexer.TabError a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Lexer.TabError a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Lexer.IndentedLine a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Lexer.IndentedLine a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Internal.Lexer.LogicalLine a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Internal.Lexer.LogicalLine a)
instance GHC.Show.Show Language.Python.Internal.Lexer.SrcInfo
instance GHC.Classes.Eq Language.Python.Internal.Lexer.SrcInfo
instance GHC.Num.Num a => Data.FingerTree.Measured (Data.Semigroup.Internal.Sum a) (Language.Python.Internal.Lexer.Summed a)
instance GHC.Base.Semigroup Language.Python.Internal.Lexer.SrcInfo


module Language.Python.Internal.Parse
type Parser = Parsec Void PyTokens

-- | Run a parser on some input
runParser :: AsParseError e (PyToken SrcInfo) => FilePath -> Parser a -> [PyToken SrcInfo] -> Either e a
newtype PyTokens
PyTokens :: [PyToken SrcInfo] -> PyTokens
[unPyTokens] :: PyTokens -> [PyToken SrcInfo]
class AsParseError s t | s -> t
_ParseError :: AsParseError s t => Prism' s (NonEmpty SourcePos, Maybe (ErrorItem t), Set (ErrorItem t))

-- | Convert a concrete <a>ParseError</a> to a value that has an instance
--   of <a>AsParseError</a>
--   
--   This function is partial because our parser will never use
--   <a>FancyError</a>
unsafeFromParseError :: (HasCallStack, AsParseError s t) => ParseError t e -> s
token :: MonadParsec e PyTokens m => m Whitespace -> (PyToken SrcInfo -> Bool) -> String -> m (PyToken SrcInfo, [Whitespace])
at :: MonadParsec e PyTokens m => m Whitespace -> m (PyToken SrcInfo, At)
colon :: MonadParsec e PyTokens m => m Whitespace -> m (PyToken SrcInfo, Colon)
comma :: MonadParsec e PyTokens m => m Whitespace -> m (PyToken SrcInfo, Comma)
dot :: MonadParsec e PyTokens m => m Whitespace -> m (PyToken SrcInfo, Dot)
doubleStar :: MonadParsec e PyTokens m => m Whitespace -> m (PyToken SrcInfo, [Whitespace])
equals :: MonadParsec e PyTokens m => m Whitespace -> m (PyToken SrcInfo, Equals)
rightParen :: MonadParsec e PyTokens m => m Whitespace -> m (PyToken SrcInfo, [Whitespace])
semicolon :: MonadParsec e PyTokens m => m Whitespace -> m (PyToken SrcInfo, Semicolon SrcInfo)
star :: MonadParsec e PyTokens m => m Whitespace -> m (PyToken SrcInfo, [Whitespace])
identifier :: MonadParsec e PyTokens m => m Whitespace -> m (Ident '[] SrcInfo)
bool :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
none :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
ellipsis :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
integer :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
float :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
imag :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
stringOrBytes :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
arg :: MonadParsec e PyTokens m => m (Arg SrcInfo)
binOp :: MonadParsec e PyTokens m => m (BinOp SrcInfo) -> m (Expr SrcInfo) -> m (Expr SrcInfo)
commaSep :: MonadParsec e PyTokens m => m Whitespace -> m a -> m (CommaSep a)
commaSep1 :: MonadParsec e PyTokens m => m Whitespace -> m a -> m (CommaSep1 a)
commaSep1' :: MonadParsec e PyTokens m => m Whitespace -> m a -> m (CommaSep1' a)
commaSepRest :: MonadParsec e PyTokens m => m b -> m ([(Comma, b)], Maybe Comma)
compIf :: MonadParsec e PyTokens m => m (CompIf SrcInfo)
compFor :: MonadParsec e PyTokens m => m (CompFor SrcInfo)
compoundStatement :: MonadParsec e PyTokens m => m (Indents SrcInfo) -> Indents SrcInfo -> m (CompoundStatement SrcInfo)
decorator :: MonadParsec e PyTokens m => Indents SrcInfo -> m (Decorator SrcInfo)
decoratorValue :: MonadParsec e PyTokens m => m (Expr SrcInfo)
decorators :: MonadParsec e PyTokens m => m (Indents SrcInfo) -> Indents SrcInfo -> m [Decorator SrcInfo]
expr :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
exprList :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
exprListComp :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
exprNoCond :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
exprComp :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
exprOrStarList :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
lambda :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
lambdaNoCond :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
module_ :: MonadParsec e PyTokens m => m (Module SrcInfo)
orExpr :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
orExprList :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
orTest :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
smallStatement :: MonadParsec e PyTokens m => m (SmallStatement SrcInfo)
someParams :: MonadParsec e PyTokens m => m (Param SrcInfo) -> m (Param SrcInfo) -> m (Param SrcInfo) -> m (CommaSep (Param SrcInfo))
simpleStatement :: MonadParsec e PyTokens m => m (SimpleStatement SrcInfo)
starExpr :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
statement :: (Alternative m, MonadParsec e PyTokens m) => m (Indents SrcInfo) -> Indents SrcInfo -> m (Statement SrcInfo)
suite :: MonadParsec e PyTokens m => m (Suite SrcInfo)
tpPositional :: MonadParsec e PyTokens m => m (Param SrcInfo)
tpStar :: MonadParsec e PyTokens m => m (Param SrcInfo)
tpDoubleStar :: MonadParsec e PyTokens m => m (Param SrcInfo)
tyAnn :: MonadParsec e PyTokens m => m (Colon, Expr SrcInfo)
typedParams :: MonadParsec e PyTokens m => m (CommaSep (Param SrcInfo))
untypedParams :: MonadParsec e PyTokens m => m Whitespace -> m (CommaSep (Param SrcInfo))
upPositional :: MonadParsec e PyTokens m => m Whitespace -> m (Param SrcInfo)
upStar :: MonadParsec e PyTokens m => m Whitespace -> m (Param SrcInfo)
upDoubleStar :: MonadParsec e PyTokens m => m Whitespace -> m (Param SrcInfo)
yieldExpr :: MonadParsec e PyTokens m => m Whitespace -> m (Expr SrcInfo)
anySpace :: MonadParsec e PyTokens m => m Whitespace
space :: MonadParsec e PyTokens m => m Whitespace
eol :: MonadParsec e PyTokens m => m Newline
continued :: MonadParsec e PyTokens m => m Whitespace
newline :: MonadParsec e PyTokens m => m Newline
indent :: MonadParsec e PyTokens m => m (Indents SrcInfo)
dedent :: MonadParsec e PyTokens m => m ()
level :: MonadParsec s PyTokens m => m (Indents SrcInfo)
blank :: MonadParsec e PyTokens m => m (Blank SrcInfo)
comment :: MonadParsec e PyTokens m => m (Comment SrcInfo)
sepBy1' :: MonadParsec e PyTokens m => m a -> m sep -> m (a, [(sep, a)], Maybe sep)
instance GHC.Classes.Ord Language.Python.Internal.Parse.PyTokens
instance GHC.Classes.Eq Language.Python.Internal.Parse.PyTokens
instance Text.Megaparsec.Stream.Stream Language.Python.Internal.Parse.PyTokens

module Language.Python.Parse.Error
data ParseError a

-- | An error occured during tokenization (this is a re-packed megaparsec
--   error)
LexicalError :: NonEmpty SourcePos -> Maybe (ErrorItem Char) -> Set (ErrorItem Char) -> ParseError a

-- | An error occured during parsing (this is a re-packed megaparsec error)
ParseError :: NonEmpty SourcePos -> Maybe (ErrorItem (PyToken a)) -> Set (ErrorItem (PyToken a)) -> ParseError a

-- | Tabs and spaces were used inconsistently
TabError :: a -> ParseError a

-- | The dedent at the end of a block doesn't match and preceding indents
--   
--   e.g.
--   
--   <pre>
--   def a():
--       if b:
--           pass
--       else:
--           pass
--     pass
--   </pre>
--   
--   The final line will cause an <a>IncorrectDedent</a> error
IncorrectDedent :: a -> ParseError a

-- | Unpacking ( <tt>*value</tt> ) was used in an invalid position
InvalidUnpacking :: a -> ParseError a
class AsLexicalError s t | s -> t
_LexicalError :: AsLexicalError s t => Prism' s (NonEmpty SourcePos, Maybe (ErrorItem t), Set (ErrorItem t))
class AsTabError s a | s -> a
_TabError :: AsTabError s a => Prism' s a
class AsIncorrectDedent s a | s -> a
_IncorrectDedent :: AsIncorrectDedent s a => Prism' s a
class AsIRError s a | s -> a
_InvalidUnpacking :: AsIRError s a => Prism' s a
class AsParseError s t | s -> t
_ParseError :: AsParseError s t => Prism' s (NonEmpty SourcePos, Maybe (ErrorItem t), Set (ErrorItem t))

-- | Data type that is used to represent “unexpected/expected” items in
--   <a>ParseError</a>. The data type is parametrized over the token type
--   <tt>t</tt>.
data ErrorItem t

-- | Non-empty stream of tokens
Tokens :: NonEmpty t -> ErrorItem t

-- | Label (cannot be empty)
Label :: NonEmpty Char -> ErrorItem t

-- | End of input
EndOfInput :: ErrorItem t

-- | The data type <a>SourcePos</a> represents source positions. It
--   contains the name of the source file, a line number, and a column
--   number. Source line and column positions change intensively during
--   parsing, so we need to make them strict to avoid memory leaks.
data SourcePos
SourcePos :: FilePath -> !Pos -> !Pos -> SourcePos

-- | Name of source file
[sourceName] :: SourcePos -> FilePath

-- | Line number
[sourceLine] :: SourcePos -> !Pos

-- | Column number
[sourceColumn] :: SourcePos -> !Pos
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Parse.Error.ParseError a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Parse.Error.ParseError a)
instance Language.Python.Internal.Lexer.AsLexicalError (Language.Python.Parse.Error.ParseError a) GHC.Types.Char
instance Language.Python.Internal.Lexer.AsTabError (Language.Python.Parse.Error.ParseError a) a
instance Language.Python.Internal.Lexer.AsIncorrectDedent (Language.Python.Parse.Error.ParseError a) a
instance Language.Python.Internal.Parse.AsParseError (Language.Python.Parse.Error.ParseError a) (Language.Python.Internal.Token.PyToken a)
instance Language.Python.Internal.Syntax.IR.AsIRError (Language.Python.Parse.Error.ParseError a) a


module Language.Python.Parse
type Parser = Parsec Void PyTokens

-- | Parse a module
--   
--   
--   <a>https://docs.python.org/3/reference/toplevel_components.html#file-input</a>
parseModule :: (AsLexicalError e Char, AsTabError e SrcInfo, AsIncorrectDedent e SrcInfo, AsParseError e (PyToken SrcInfo), AsIRError e SrcInfo) => FilePath -> Text -> Validation (NonEmpty e) (Module '[] SrcInfo)

-- | Parse a statement
--   
--   
--   <a>https://docs.python.org/3/reference/compound_stmts.html#grammar-token-statement</a>
parseStatement :: (AsLexicalError e Char, AsTabError e SrcInfo, AsIncorrectDedent e SrcInfo, AsParseError e (PyToken SrcInfo), AsIRError e SrcInfo) => FilePath -> Text -> Validation (NonEmpty e) (Statement '[] SrcInfo)

-- | Parse an expression
--   
--   
--   <a>https://docs.python.org/3.5/reference/expressions.html#grammar-token-expression</a>
parseExpr :: (AsLexicalError e Char, AsTabError e SrcInfo, AsIncorrectDedent e SrcInfo, AsParseError e (PyToken SrcInfo), AsIRError e SrcInfo) => FilePath -> Text -> Validation (NonEmpty e) (Expr '[] SrcInfo)

-- | Parse an expression list (unparenthesised tuple)
--   
--   
--   <a>https://docs.python.org/3.5/reference/expressions.html#grammar-token-expression_list</a>
parseExprList :: (AsLexicalError e Char, AsTabError e SrcInfo, AsIncorrectDedent e SrcInfo, AsParseError e (PyToken SrcInfo), AsIRError e SrcInfo) => FilePath -> Text -> Validation (NonEmpty e) (Expr '[] SrcInfo)

-- | Parse a module from a file
--   
--   
--   <a>https://docs.python.org/3/reference/toplevel_components.html#file-input</a>
readModule :: (AsLexicalError e Char, AsTabError e SrcInfo, AsIncorrectDedent e SrcInfo, AsParseError e (PyToken SrcInfo), AsIRError e SrcInfo) => FilePath -> IO (Validation (NonEmpty e) (Module '[] SrcInfo))

-- | Parse a statement from a file
--   
--   
--   <a>https://docs.python.org/3/reference/compound_stmts.html#grammar-token-statement</a>
readStatement :: (AsLexicalError e Char, AsTabError e SrcInfo, AsIncorrectDedent e SrcInfo, AsParseError e (PyToken SrcInfo), AsIRError e SrcInfo) => FilePath -> IO (Validation (NonEmpty e) (Statement '[] SrcInfo))

-- | Parse an expression from a file
--   
--   
--   <a>https://docs.python.org/3.5/reference/expressions.html#grammar-token-expression</a>
readExpr :: (AsLexicalError e Char, AsTabError e SrcInfo, AsIncorrectDedent e SrcInfo, AsParseError e (PyToken SrcInfo), AsIRError e SrcInfo) => FilePath -> IO (Validation (NonEmpty e) (Expr '[] SrcInfo))

-- | Parse an expression list (unparenthesised tuple) from a file
--   
--   
--   <a>https://docs.python.org/3.5/reference/expressions.html#grammar-token-expression_list</a>
readExprList :: (AsLexicalError e Char, AsTabError e SrcInfo, AsIncorrectDedent e SrcInfo, AsParseError e (PyToken SrcInfo), AsIRError e SrcInfo) => FilePath -> IO (Validation (NonEmpty e) (Expr '[] SrcInfo))
data SrcInfo
SrcInfo :: FilePath -> !Int -> !Int -> !Int -> !Int -> !Int -> !Int -> SrcInfo
[_srcInfoName] :: SrcInfo -> FilePath
[_srcInfoLineStart] :: SrcInfo -> !Int
[_srcInfoLineEnd] :: SrcInfo -> !Int
[_srcInfoColStart] :: SrcInfo -> !Int
[_srcInfoColEnd] :: SrcInfo -> !Int
[_srcInfoOffsetStart] :: SrcInfo -> !Int
[_srcInfoOffsetEnd] :: SrcInfo -> !Int
initialSrcInfo :: FilePath -> SrcInfo


-- | Passing <tt>[]</tt> to a function which expects a <tt>[<a>Raw</a>
--   <a>Line</a>]</tt> is the same as passing <tt>[<a>line_</a>
--   <a>pass_</a>]</tt>
module Language.Python.DSL

-- | <a>&amp;</a> is a reverse application operator. This provides
--   notational convenience. Its precedence is one higher than that of the
--   forward application operator <a>$</a>, which allows <a>&amp;</a> to be
--   nested in <a>$</a>.
--   
--   <pre>
--   &gt;&gt;&gt; 5 &amp; (+1) &amp; show
--   "6"
--   </pre>
(&) :: () => a -> (a -> b) -> b
infixl 1 &

-- | <a>Raw</a> represents unvalidated, un-annotated terms.
type Raw f = f '[] ()

-- | A Python <a>Module</a>, which is stored as a sequence of statements. A
--   module corresponds to one source file of Python code.
data Module v a

-- | A <a>Statement</a> is either a <a>SmallStatement</a> or a
--   <a>Statement</a>
--   
--   
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#compound-statements</a>
data Statement (v :: [*]) a

-- | This large sum type covers all valid Python <i>expressions</i>
data Expr (v :: [*]) a

-- | Create a <a>Module</a>
--   
--   <pre>
--   &gt;&gt;&gt; module_
--   
--   &gt;&gt;&gt; [ line_ $ def_ "a" [] [line_ pass_]
--   
--   &gt;&gt;&gt; , blank_
--   
--   &gt;&gt;&gt; , line_ $ def_ "b" [] [line_ pass_]
--   
--   &gt;&gt;&gt; ]
--   def a():
--       pass
--   
--   def b():
--       pass
--   </pre>
module_ :: [Raw Line] -> Raw Module

-- | Create a blank <a>Line</a>
blank_ :: Raw Line

-- | Convert some data to a <a>Line</a>
class AsLine s
line_ :: AsLine s => Raw s -> Raw Line

-- | One or more lines of Python code
newtype Line v a
Line :: Either (Blank a, Newline) (Statement v a) -> Line v a
[unLine] :: Line v a -> Either (Blank a, Newline) (Statement v a)

-- | <a>Expr</a> has an <a>IsString</a> instance, but when a type class
--   dispatches on an <a>Expr</a> we will run into ambiguity if we try to
--   use <tt>OverloadedStrings</tt>. In these cases we can use <a>id_</a>
--   to provide the extra type information
id_ :: String -> Raw Ident

-- | An identifier. Like many types in hpython, it has an optional
--   annotation and tracks its trailing whitespace.
--   
--   <a>Raw</a> <a>Ident</a>s have an <a>IsString</a> instance.
--   
--   See
--   <a>https://docs.python.org/3.5/reference/lexical_analysis.html#identifiers</a>
data Ident (v :: [*]) a
MkIdent :: Ann a -> String -> [Whitespace] -> Ident a
[_identAnn] :: Ident a -> Ann a
[_identValue] :: Ident a -> String
[_identWhitespace] :: Ident a -> [Whitespace]
identAnn :: Lens (Ident v a) (Ident v a) a a
identValue :: Lens (Ident v a) (Ident '[] a) String String
identWhitespace :: Lens (Ident v a) (Ident v a) [Whitespace] [Whitespace]
class StarSyntax s t | t -> s
s_ :: StarSyntax s t => Raw s -> Raw t

-- | Unnamed starred parameter
--   
--   <pre>
--   &gt;&gt;&gt; def_ "a" [ p_ "b", star_ ] [ line_ pass_ ]
--   def a(b, *):
--       pass
--   </pre>
star_ :: Raw Param
class DoubleStarSyntax s t | t -> s
ss_ :: DoubleStarSyntax s t => Raw s -> Raw t
class As s t u | s t -> u, u -> s t
as_ :: As s t u => Raw s -> Raw t -> Raw u
class IfSyntax a
if_ :: IfSyntax a => Raw Expr -> a
class ForSyntax a x | a -> x
for_ :: ForSyntax a x => Raw x -> a
class InSyntax a x | a -> x, x -> a
in_ :: InSyntax a x => Raw Expr -> x -> Raw a
infixl 1 `in_`

-- | <pre>
--   &gt;&gt;&gt; var_ "a" `in_` var_ "b"
--   a in b
--   </pre>
data In v a
MkIn :: Expr v a -> Expr v a -> In v a

-- | <pre>
--   &gt;&gt;&gt; var_ "a" `in_` [var_ "b", var_ "c"]
--   a in b, c
--   </pre>
data InList v a
MkInList :: Expr v a -> [Expr v a] -> InList v a
class ColonSyntax s t | s -> t, t -> s
(.:) :: ColonSyntax s t => Raw s -> Raw Expr -> Raw t
infix 0 .:
comp_ :: Raw e -> Raw CompFor -> [Raw Guard] -> Raw (Comprehension e)
newtype Guard v a
MkGuard :: Either (CompFor v a) (CompIf v a) -> Guard v a
[unGuard] :: Guard v a -> Either (CompFor v a) (CompIf v a)

-- | Formal parameters for functions
--   
--   See
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#function-definitions</a>
data Param (v :: [*]) a

-- | <pre>
--   def foo(a):
--   </pre>
PositionalParam :: Ann a -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> Ann a
[_paramName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)

-- | <pre>
--   def foo(bar=None):
--   </pre>
KeywordParam :: Ann a -> Ident v a -> Maybe (Colon, Expr v a) -> [Whitespace] -> Expr v a -> Param a
[_paramAnn] :: Param a -> Ann a
[_paramName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)
[_unsafeKeywordParamWhitespaceRight] :: Param a -> [Whitespace]
[_unsafeKeywordParamExpr] :: Param a -> Expr v a

-- | <pre>
--   def foo(*xs):
--   </pre>
StarParam :: Ann a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> Ann a
[_unsafeStarParamWhitespace] :: Param a -> [Whitespace]
[_unsafeStarParamName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)

-- | <pre>
--   def foo(*):
--   </pre>
UnnamedStarParam :: Ann a -> [Whitespace] -> Param a
[_paramAnn] :: Param a -> Ann a
[_unsafeUnnamedStarParamWhitespace] :: Param a -> [Whitespace]

-- | <pre>
--   def foo(**dict):
--   </pre>
DoubleStarParam :: Ann a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> Ann a
[_unsafeDoubleStarParamWhitespace] :: Param a -> [Whitespace]
[_paramName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)
class ParametersSyntax s

-- | A faux-Lens that allows targeting <a>Param</a>s in-between existing
--   formatting, and adding appropriate formatting when extra parameters
--   are introduced.
--   
--   <pre>
--   &gt;&gt;&gt; showStatement myStatement
--   "def a(b ,  c   ):\n    pass"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; showStatement (myStatement &amp; _Fundef.parameters_ .~ [p_ "d", p_ "e"]
--   "def a(d ,  e   ):\n    pass"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; showStatement (myStatement &amp; _Fundef.parameters_ .~ [p_ "d", p_ "e", p_ "f"]
--   "def a(d ,  e   , f):\n    pass"
--   </pre>
--   
--   ---
--   
--   It's not a <tt>Lens</tt> because repeated <a>set</a>s can drop
--   trailing commas, violating the <tt>Lens</tt> laws. For example:
--   
--   <pre>
--   &gt;&gt;&gt; someFunction
--   def a(b, c,):
--       pass
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; set parameters_ [var_ "d", var_ "e"] someFunction
--   def a(d, e,):
--       pass
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; set parameters_ [] someFunction
--   def a():
--       pass
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; set parameters_ [var_ "d", var_ "e"] (set parameters_ [] someFunction)
--   def a(d, e):
--       pass
--   </pre>
parameters_ :: (ParametersSyntax s, Functor f) => ([Raw Param] -> f [Raw Param]) -> Raw s -> f (Raw s)
parameters :: ParametersSyntax s => Lens' (Raw s) (CommaSep (Raw Param))

-- | Actual parameters for functions
--   
--   In the following examples, <tt>x</tt> is an actual parameter.
--   
--   <pre>
--   y = foo(x)
--   y = bar(quux=x)
--   y = baz(*x)
--   y = flux(**x)
--   </pre>
data Arg (v :: [*]) a
PositionalArg :: Ann a -> Expr v a -> Arg a
[_argAnn] :: Arg a -> Ann a
[_argExpr] :: Arg a -> Expr v a
KeywordArg :: Ann a -> Ident v a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> Ann a
[_unsafeKeywordArgName] :: Arg a -> Ident v a
[_unsafeKeywordArgWhitespaceRight] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a
StarArg :: Ann a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> Ann a
[_unsafeStarArgWhitespace] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a
DoubleStarArg :: Ann a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> Ann a
[_unsafeDoubleStarArgWhitespace] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a
class ArgumentsSyntax s
setArguments :: ArgumentsSyntax s => [Raw Arg] -> Raw s -> Raw s
getArguments :: ArgumentsSyntax s => Raw s -> [Raw Arg]

-- | Positional parameters/arguments
--   
--   <pre>
--   p_ :: <a>Raw</a> <a>SimpleStatement</a> -&gt; <a>Raw</a> <a>Arg</a>
--   </pre>
--   
--   <pre>
--   p_ :: <a>Raw</a> <a>Expr</a> -&gt; <a>Raw</a> <a>Param</a>
--   </pre>
class PositionalSyntax p v | p -> v, v -> p
p_ :: PositionalSyntax p v => Raw v -> Raw p
data PositionalParam v a
MkPositionalParam :: Ann a -> Ident v a -> Maybe (Colon, Expr v a) -> PositionalParam v a
[_ppAnn] :: PositionalParam v a -> Ann a
[_ppName] :: PositionalParam v a -> Ident v a
[_ppType] :: PositionalParam v a -> Maybe (Colon, Expr v a)
_PositionalParam :: Prism (Param v a) (Param '[] a) (PositionalParam v a) (PositionalParam '[] a)
ppAnn :: forall v_a2Mcu a_a2Mcv. Lens' (PositionalParam v_a2Mcu a_a2Mcv) (Ann a_a2Mcv)
ppName :: forall v_a2Mcu a_a2Mcv. Lens' (PositionalParam v_a2Mcu a_a2Mcv) (Ident v_a2Mcu a_a2Mcv)
ppType :: forall v_a2Mcu a_a2Mcv. Lens' (PositionalParam v_a2Mcu a_a2Mcv) (Maybe (Colon, Expr v_a2Mcu a_a2Mcv))

-- | Keyword parameters/arguments
--   
--   <pre>
--   p_ :: <a>Raw</a> <a>SimpleStatement</a> -&gt; <a>Raw</a> <a>SimpleStatement</a> -&gt; <a>Raw</a> <a>Arg</a>
--   </pre>
--   
--   <pre>
--   p_ :: <a>Raw</a> <a>Expr</a> -&gt; <a>Raw</a> <a>SimpleStatement</a> -&gt; <a>Raw</a> <a>Param</a>
--   </pre>
class KeywordSyntax p
k_ :: KeywordSyntax p => Raw Ident -> Raw Expr -> Raw p
data KeywordParam v a
MkKeywordParam :: Ann a -> Ident v a -> Maybe (Colon, Expr v a) -> [Whitespace] -> Expr v a -> KeywordParam v a
[_kpAnn] :: KeywordParam v a -> Ann a
[_kpName] :: KeywordParam v a -> Ident v a
[_kpType] :: KeywordParam v a -> Maybe (Colon, Expr v a)
[_kpEquals] :: KeywordParam v a -> [Whitespace]
[_kpExpr] :: KeywordParam v a -> Expr v a
_KeywordParam :: Prism (Param v a) (Param '[] a) (KeywordParam v a) (KeywordParam '[] a)
kpAnn :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) (Ann a_a2LOV)
kpName :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) (Ident v_a2LOU a_a2LOV)
kpType :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) (Maybe (Colon, Expr v_a2LOU a_a2LOV))
kpEquals :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) [Whitespace]
kpExpr :: forall v_a2LOU a_a2LOV. Lens' (KeywordParam v_a2LOU a_a2LOV) (Expr v_a2LOU a_a2LOV)
decorated_ :: DecoratorsSyntax s => [Raw Expr] -> Raw s -> Raw s
class DecoratorsSyntax s
setDecorators :: DecoratorsSyntax s => [Raw Expr] -> Raw s -> Raw s
getDecorators :: DecoratorsSyntax s => Raw s -> [Raw Expr]
decorators :: DecoratorsSyntax s => Lens' (Raw s) [Raw Decorator]
class AsyncSyntax s
async_ :: AsyncSyntax s => Raw s -> Raw s
class BodySyntax s

-- | A faux-Lens that targets lines in the body of some statement-piece,
--   but does so 'around' indentation.
--   
--   <pre>
--   &gt;&gt;&gt; def_ "a" [] [ line_ pass_, line_ pass_ ]
--   def a ():
--       pass
--       pass
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; def_ "a" [] [ line_ pass_, line_ pass_ ] ^. body_
--   pass
--   pass
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; def_ "a" [] [ line_ pass_, line_ pass_ ] &amp; body_ .~ [ line_ $ var_ "b" += 1 ]
--   def a():
--       b += 1
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; def_ "a" [] [ line_ pass_, line_ pass_ ] &amp; body_ &lt;&gt;~ [ line_ $ var_ "b" += 1 ]
--   def a():
--       pass
--       pass
--       b += 1
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; def_ "a" [] [ line_ pass_, line_ pass_ ] &amp; body_ .~ []
--   def a():
--       pass
--   </pre>
--   
--   ---
--   
--   It's a fake <tt>Lens</tt> because it violates some of the laws. The
--   most obvious violation is that setting the <a>body_</a> to the empty
--   list actually sets it to a singleton list containing <a>pass_</a>.
--   (This is because blocks must contain one or more statements)
body_ :: (BodySyntax s, Functor f) => ([Raw Line] -> f [Raw Line]) -> Raw s -> f (Raw s)
body :: BodySyntax s => Lens' (Raw s) (Raw Suite)

-- | <pre>
--   &gt;&gt;&gt; def_ "f" [p_ "x"] [line_ $ return_ "x"]
--   def f(x):
--       return x
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; def_ "f" [p_ "x", k_ "y" 2] [line_ $ return_ "x"]
--   def f(x, y=2):
--       return x
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; def_ "f" [p_ "x", k_ "y" 2, s_ "z"] [line_ $ return_ "x"]
--   def f(x, y=2, *z):
--       return x
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; def_ "f" [p_ "x", k_ "y" 2, s_ "z", ss_ "w"] [line_ $ return_ "x"]
--   def f(x, y=2, *z, **w)
--       return x
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; def_ "f" [p_ "x" .: "String"] [line_ $ return_ "x"]
--   def f(x: String):
--       return x
--   </pre>
def_ :: Raw Ident -> [Raw Param] -> [Raw Line] -> Raw Fundef
data Fundef v a
MkFundef :: Ann a -> [Decorator v a] -> Indents a -> Maybe (NonEmpty Whitespace) -> NonEmpty Whitespace -> Ident v a -> [Whitespace] -> CommaSep (Param v a) -> [Whitespace] -> Maybe ([Whitespace], Expr v a) -> Suite v a -> Fundef v a
[_fdAnn] :: Fundef v a -> Ann a
[_fdDecorators] :: Fundef v a -> [Decorator v a]
[_fdIndents] :: Fundef v a -> Indents a
[_fdAsync] :: Fundef v a -> Maybe (NonEmpty Whitespace)
[_fdDefSpaces] :: Fundef v a -> NonEmpty Whitespace
[_fdName] :: Fundef v a -> Ident v a
[_fdLeftParenSpaces] :: Fundef v a -> [Whitespace]
[_fdParameters] :: Fundef v a -> CommaSep (Param v a)
[_fdRightParenSpaces] :: Fundef v a -> [Whitespace]
[_fdReturnType] :: Fundef v a -> Maybe ([Whitespace], Expr v a)
[_fdBody] :: Fundef v a -> Suite v a

-- | Create a minimal valid function definition
mkFundef :: Raw Ident -> [Raw Line] -> Raw Fundef
fdAnn :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Ann a_a2KCQ)
fdDecorators :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) [Decorator v_a2KCP a_a2KCQ]
fdIndents :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Indents a_a2KCQ)
fdAsync :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Maybe (NonEmpty Whitespace))
fdDefSpaces :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (NonEmpty Whitespace)
fdName :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Ident v_a2KCP a_a2KCQ)
fdLeftParenSpaces :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) [Whitespace]
fdParameters :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (CommaSep (Param v_a2KCP a_a2KCQ))
fdRightParenSpaces :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) [Whitespace]
fdReturnType :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Maybe ([Whitespace], Expr v_a2KCP a_a2KCQ))
fdBody :: forall v_a2KCP a_a2KCQ. Lens' (Fundef v_a2KCP a_a2KCQ) (Suite v_a2KCP a_a2KCQ)

-- | <pre>
--   &gt;&gt;&gt; class_ "A" [] [line_ pass_]
--   class A:
--       pass
--   </pre>
class_ :: Raw Ident -> [Raw Arg] -> [Raw Line] -> Raw ClassDef
data ClassDef v a
MkClassDef :: Ann a -> [Decorator v a] -> Indents a -> NonEmpty Whitespace -> Ident v a -> Maybe ([Whitespace], Maybe (CommaSep1' (Arg v a)), [Whitespace]) -> Suite v a -> ClassDef v a
[_cdAnn] :: ClassDef v a -> Ann a
[_cdDecorators] :: ClassDef v a -> [Decorator v a]
[_cdIndents] :: ClassDef v a -> Indents a
[_cdClass] :: ClassDef v a -> NonEmpty Whitespace
[_cdName] :: ClassDef v a -> Ident v a
[_cdArguments] :: ClassDef v a -> Maybe ([Whitespace], Maybe (CommaSep1' (Arg v a)), [Whitespace])
[_cdBody] :: ClassDef v a -> Suite v a

-- | Create a minimal <a>ClassDef</a>
mkClassDef :: Raw Ident -> [Raw Line] -> Raw ClassDef
cdAnn :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Ann a_a2PY5)
cdDecorators :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) [Decorator v_a2PY4 a_a2PY5]
cdIndents :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Indents a_a2PY5)
cdClass :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (NonEmpty Whitespace)
cdName :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Ident v_a2PY4 a_a2PY5)
cdArguments :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Maybe ([Whitespace], Maybe (CommaSep1' (Arg v_a2PY4 a_a2PY5)), [Whitespace]))
cdBody :: forall v_a2PY4 a_a2PY5. Lens' (ClassDef v_a2PY4 a_a2PY5) (Suite v_a2PY4 a_a2PY5)

-- | Chained assignment
--   
--   <pre>
--   &gt;&gt;&gt; chainEq (var_ "a") []
--   a
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; chainEq (var_ "a") [var_ "b", var_ "c"]
--   a = b = c
--   </pre>
chainEq :: Raw Expr -> [Raw Expr] -> Raw Statement

-- | <pre>
--   a = b
--   </pre>
(.=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .=

-- | <pre>
--   a += b
--   </pre>
(.+=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .+=

-- | <pre>
--   a -= b
--   </pre>
(.-=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .-=

-- | <pre>
--   a *= b
--   </pre>
(.*=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .*=

-- | <tt>a </tt>= b@
(.@=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .@=

-- | <pre>
--   a /= b
--   </pre>
(./=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 ./=

-- | <pre>
--   a %= b
--   </pre>
(.%=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .%=

-- | <pre>
--   a &amp;= b
--   </pre>
(.&=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .&=

-- | <pre>
--   a |= b
--   </pre>
(.|=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .|=

-- | <pre>
--   a ^= b
--   </pre>
(.^=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .^=

-- | <pre>
--   a &lt;&lt;= b
--   </pre>
(.<<=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .<<=

-- | <pre>
--   a &gt;&gt;= b
--   </pre>
(.>>=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .>>=

-- | <pre>
--   a **= b
--   </pre>
(.**=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .**=

-- | <pre>
--   a //= b
--   </pre>
(.//=) :: Raw Expr -> Raw Expr -> Raw Statement
infix 0 .//=

-- | <tt>try ... except</tt> with optional <tt>else</tt> and optional
--   <tt>finally</tt>
--   
--   <pre>
--   &gt;&gt;&gt; tryE_ [line_ pass_] [line_ ("a" .+= 1)]
--   try:
--       pass
--   except
--       a += 1
--   </pre>
tryE_ :: [Raw Line] -> Raw Except -> Raw TryExcept

-- | <pre>
--   try ... finally
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; tryF_ [line_ pass_] [line_ ("a" .+= 1)]
--   try:
--       pass
--   finally:
--       a += 1
--   </pre>
tryF_ :: [Raw Line] -> [Raw Line] -> Raw TryFinally
class ExceptSyntax s
except_ :: ExceptSyntax s => [Raw Line] -> s -> Raw TryExcept

-- | You can use <a>exceptAs_</a> without a binder:
--   
--   <pre>
--   <a>exceptAs_</a> :: <a>Raw</a> <a>SimpleStatement</a> -&gt; [<a>Raw</a> <a>Line</a>] -&gt; <a>Raw</a> s -&gt; <a>Raw</a> <a>TryExcept</a>
--   </pre>
--   
--   <pre>
--   <a>exceptAs_</a> (<a>var_</a> "Exception") body
--   </pre>
--   
--   or with a binder:
--   
--   <pre>
--   <a>exceptAs_</a> :: <a>Raw</a> <a>ExceptAs</a> -&gt; [<a>Raw</a> <a>Line</a>] -&gt; <a>Raw</a> s -&gt; <a>Raw</a> <a>TryExcept</a>
--   </pre>
--   
--   <pre>
--   <a>exceptAs_</a> (<a>var_</a> "Exception" `<a>as_</a>` <a>id_</a> "a") body
--   </pre>
exceptAs_ :: (ExceptSyntax s, AsExceptAs e) => Raw e -> [Raw Line] -> s -> Raw TryExcept
class FinallySyntax s t | s -> t
finally_ :: FinallySyntax s t => [Raw Line] -> s -> Raw t
data TryExcept v a
MkTryExcept :: Ann a -> Indents a -> [Whitespace] -> Suite v a -> NonEmpty (Except v a) -> Maybe (Else v a) -> Maybe (Finally v a) -> TryExcept v a
[_teAnn] :: TryExcept v a -> Ann a
[_teIndents] :: TryExcept v a -> Indents a
[_teTry] :: TryExcept v a -> [Whitespace]
[_teBody] :: TryExcept v a -> Suite v a
[_teExcepts] :: TryExcept v a -> NonEmpty (Except v a)
[_teElse] :: TryExcept v a -> Maybe (Else v a)
[_teFinally] :: TryExcept v a -> Maybe (Finally v a)

-- | Create a minimal valid <a>TryExcept</a>
mkTryExcept :: [Raw Line] -> Raw Except -> Raw TryExcept
data TryFinally v a
MkTryFinally :: Ann a -> Indents a -> [Whitespace] -> Suite v a -> Finally v a -> TryFinally v a
[_tfAnn] :: TryFinally v a -> Ann a
[_tfIndents] :: TryFinally v a -> Indents a
[_tfTry] :: TryFinally v a -> [Whitespace]
[_tfBody] :: TryFinally v a -> Suite v a
[_tfFinally] :: TryFinally v a -> Finally v a

-- | Create a minimal valid <a>TryFinally</a>
mkTryFinally :: [Raw Line] -> [Raw Line] -> Raw TryFinally

-- | See
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-try-statement</a>
data ExceptAs (v :: [*]) a
ExceptAs :: Ann a -> Expr v a -> Maybe ([Whitespace], Ident v a) -> ExceptAs a
[_exceptAsAnn] :: ExceptAs a -> Ann a

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_exceptAsExpr] :: ExceptAs a -> Expr v a

-- | <pre>
--   ['as' &lt;ident&gt;]
--   </pre>
[_exceptAsName] :: ExceptAs a -> Maybe ([Whitespace], Ident v a)
class AsExceptAs s
toExceptAs :: AsExceptAs s => Raw s -> Raw ExceptAs
data Except v a
MkExcept :: Indents a -> [Whitespace] -> Maybe (ExceptAs v a) -> Suite v a -> Except v a
[_exceptIndents] :: Except v a -> Indents a
[_exceptExcept] :: Except v a -> [Whitespace]
[_exceptExceptAs] :: Except v a -> Maybe (ExceptAs v a)
[_exceptBody] :: Except v a -> Suite v a

-- | Create a minimal valid <a>Except</a>
mkExcept :: [Raw Line] -> Raw Except
data Finally v a
MkFinally :: Indents a -> [Whitespace] -> Suite v a -> Finally v a
[_finallyIndents] :: Finally v a -> Indents a
[_finallyFinally] :: Finally v a -> [Whitespace]
[_finallyBody] :: Finally v a -> Suite v a

-- | Create a minimal valid <a>Finally</a>
mkFinally :: [Raw Line] -> Raw Finally
teAnn :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Ann a_a2Pc1)
teIndents :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Indents a_a2Pc1)
teTry :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) [Whitespace]
teBody :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Suite v_a2Pc0 a_a2Pc1)
teExcepts :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (NonEmpty (Except v_a2Pc0 a_a2Pc1))
teElse :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Maybe (Else v_a2Pc0 a_a2Pc1))
teFinally :: forall v_a2Pc0 a_a2Pc1. Lens' (TryExcept v_a2Pc0 a_a2Pc1) (Maybe (Finally v_a2Pc0 a_a2Pc1))
exceptIndents :: forall v_a2OUh a_a2OUi. Lens' (Except v_a2OUh a_a2OUi) (Indents a_a2OUi)
exceptExcept :: forall v_a2OUh a_a2OUi. Lens' (Except v_a2OUh a_a2OUi) [Whitespace]
exceptExceptAs :: forall v_a2OUh a_a2OUi. Lens' (Except v_a2OUh a_a2OUi) (Maybe (ExceptAs v_a2OUh a_a2OUi))
exceptBody :: forall v_a2OUh a_a2OUi. Lens' (Except v_a2OUh a_a2OUi) (Suite v_a2OUh a_a2OUi)
finallyIndents :: forall v_a2OBq a_a2OBr. Lens' (Finally v_a2OBq a_a2OBr) (Indents a_a2OBr)
finallyFinally :: forall v_a2OBq a_a2OBr. Lens' (Finally v_a2OBq a_a2OBr) [Whitespace]
finallyBody :: forall v_a2OBq a_a2OBr v_a2OTS. Lens (Finally v_a2OBq a_a2OBr) (Finally v_a2OTS a_a2OBr) (Suite v_a2OBq a_a2OBr) (Suite v_a2OTS a_a2OBr)

-- | <pre>
--   with_ :: <a>NonEmpty</a> (<a>Raw</a> <a>SimpleStatement</a>) -&gt; [<a>Raw</a> <a>Line</a>] -&gt; <a>Raw</a> <a>Statement</a>
--   with_ :: <a>NonEmpty</a> (<a>Raw</a> <a>WithItem</a>) -&gt; [<a>Raw</a> <a>Line</a>] -&gt; <a>Raw</a> <a>Statement</a>
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; with_ [var_ "a"] [line_ $ var_ "b"]
--   with a:
--       b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; with_ [var_ "a" `as_` id_ "name"] [line_ $ var_ "b"]
--   with a as name:
--       b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; with_ [withItem_ e Nothing] [line_ $ var_ "b"]
--   with a:
--       b
--   </pre>
with_ :: AsWithItem e => NonEmpty (Raw e) -> [Raw Line] -> Raw With
withItem_ :: Raw Expr -> Maybe (Raw Expr) -> Raw WithItem
data With v a
MkWith :: Ann a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> CommaSep1 (WithItem v a) -> Suite v a -> With v a
[_withAnn] :: With v a -> Ann a
[_withIndents] :: With v a -> Indents a
[_withAsync] :: With v a -> Maybe (NonEmpty Whitespace)
[_withWith] :: With v a -> [Whitespace]
[_withItems] :: With v a -> CommaSep1 (WithItem v a)
[_withBody] :: With v a -> Suite v a

-- | Create a minimal valid <a>With</a>
mkWith :: NonEmpty (Raw WithItem) -> [Raw Line] -> Raw With
class AsWithItem s
toWithItem :: AsWithItem s => Raw s -> Raw WithItem

-- | See
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-with-statement</a>
data WithItem (v :: [*]) a
WithItem :: Ann a -> Expr v a -> Maybe ([Whitespace], Expr v a) -> WithItem a
[_withItemAnn] :: WithItem a -> Ann a

-- | <pre>
--   &lt;expr&gt;
--   </pre>
[_withItemValue] :: WithItem a -> Expr v a

-- | <pre>
--   ['as' &lt;spaces&gt; &lt;expr&gt;]
--   </pre>
[_withItemBinder] :: WithItem a -> Maybe ([Whitespace], Expr v a)
withAnn :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (Ann a_a2Qsc)
withIndents :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (Indents a_a2Qsc)
withAsync :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (Maybe (NonEmpty Whitespace))
withWith :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) [Whitespace]
withItems :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (CommaSep1 (WithItem v_a2Qsb a_a2Qsc))
withBody :: forall v_a2Qsb a_a2Qsc. Lens' (With v_a2Qsb a_a2Qsc) (Suite v_a2Qsb a_a2Qsc)
else_ :: ElseSyntax s => [Raw Line] -> Raw s -> Raw s
class ElseSyntax s
getElse :: ElseSyntax s => Raw s -> Maybe (Raw Else)
setElse :: ElseSyntax s => [Whitespace] -> Maybe (Raw Else) -> Raw s -> Raw s
break_ :: Raw Statement
forSt_ :: Raw Expr -> [Raw Expr] -> [Raw Line] -> Raw For
data For v a
MkFor :: Ann a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> Expr v a -> [Whitespace] -> CommaSep1' (Expr v a) -> Suite v a -> Maybe (Else v a) -> For v a
[_forAnn] :: For v a -> Ann a
[_forIndents] :: For v a -> Indents a
[_forAsync] :: For v a -> Maybe (NonEmpty Whitespace)
[_forFor] :: For v a -> [Whitespace]
[_forBinder] :: For v a -> Expr v a
[_forIn] :: For v a -> [Whitespace]
[_forCollection] :: For v a -> CommaSep1' (Expr v a)
[_forBody] :: For v a -> Suite v a
[_forElse] :: For v a -> Maybe (Else v a)
_For :: HasFor s => Prism (s v a) (s '[] a) (For v a) (For '[] a)
mkFor :: Raw Expr -> [Raw Expr] -> [Raw Line] -> Raw For
ifThen_ :: Raw Expr -> [Raw Line] -> Raw If
elif_ :: Raw Expr -> [Raw Line] -> Raw If -> Raw If
data If v a
MkIf :: Ann a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> [Elif v a] -> Maybe (Else v a) -> If v a
[_ifAnn] :: If v a -> Ann a
[_ifIndents] :: If v a -> Indents a
[_ifIf] :: If v a -> [Whitespace]
[_ifCond] :: If v a -> Expr v a
[_ifBody] :: If v a -> Suite v a
[_ifElifs] :: If v a -> [Elif v a]
[_ifElse] :: If v a -> Maybe (Else v a)

-- | Create a minimal valid <a>If</a>
mkIf :: Raw Expr -> [Raw Line] -> Raw If
data Elif v a
MkElif :: Indents a -> [Whitespace] -> Expr v a -> Suite v a -> Elif v a
[_elifIndents] :: Elif v a -> Indents a
[_elifElif] :: Elif v a -> [Whitespace]
[_elifCond] :: Elif v a -> Expr v a
[_elifBody] :: Elif v a -> Suite v a

-- | Create a minimal valid <a>Elif</a>
mkElif :: Raw Expr -> [Raw Line] -> Raw Elif
data Else v a
MkElse :: Indents a -> [Whitespace] -> Suite v a -> Else v a
[_elseIndents] :: Else v a -> Indents a
[_elseElse] :: Else v a -> [Whitespace]
[_elseBody] :: Else v a -> Suite v a

-- | Create a minimal valid <a>Else</a>
mkElse :: [Raw Line] -> Raw Else
ifAnn :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Ann a_a2NHj)
ifIndents :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Indents a_a2NHj)
ifIf :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) [Whitespace]
ifCond :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Expr v_a2NHi a_a2NHj)
ifBody :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Suite v_a2NHi a_a2NHj)
ifElifs :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) [Elif v_a2NHi a_a2NHj]
ifElse :: forall v_a2NHi a_a2NHj. Lens' (If v_a2NHi a_a2NHj) (Maybe (Else v_a2NHi a_a2NHj))
elifIndents :: forall v_a2Noq a_a2Nor. Lens' (Elif v_a2Noq a_a2Nor) (Indents a_a2Nor)
elifElif :: forall v_a2Noq a_a2Nor. Lens' (Elif v_a2Noq a_a2Nor) [Whitespace]
elifCond :: forall v_a2Noq a_a2Nor. Lens' (Elif v_a2Noq a_a2Nor) (Expr v_a2Noq a_a2Nor)
elifBody :: forall v_a2Noq a_a2Nor. Lens' (Elif v_a2Noq a_a2Nor) (Suite v_a2Noq a_a2Nor)
elseIndents :: forall v_a2L90 a_a2L91. Lens' (Else v_a2L90 a_a2L91) (Indents a_a2L91)
elseElse :: forall v_a2L90 a_a2L91. Lens' (Else v_a2L90 a_a2L91) [Whitespace]
elseBody :: forall v_a2L90 a_a2L91 v_a2Lsw. Lens (Else v_a2L90 a_a2L91) (Else v_a2Lsw a_a2L91) (Suite v_a2L90 a_a2L91) (Suite v_a2Lsw a_a2L91)

-- | <pre>
--   &gt;&gt;&gt; pass_
--   pass
--   </pre>
pass_ :: Raw Statement

-- | <pre>
--   &gt;&gt;&gt; return_ (var_ "a")
--   return a
--   </pre>
return_ :: Raw Expr -> Raw Statement
while_ :: Raw Expr -> [Raw Line] -> Raw While
data While v a
MkWhile :: Ann a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> Maybe (Else v a) -> While v a
[_whileAnn] :: While v a -> Ann a
[_whileIndents] :: While v a -> Indents a
[_whileWhile] :: While v a -> [Whitespace]
[_whileCond] :: While v a -> Expr v a
[_whileBody] :: While v a -> Suite v a
[_whileElse] :: While v a -> Maybe (Else v a)

-- | Create a minimal valid <a>While</a>
mkWhile :: Raw Expr -> [Raw Line] -> Raw While
whileAnn :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) (Ann a_a2LsY)
whileIndents :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) (Indents a_a2LsY)
whileWhile :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) [Whitespace]
whileCond :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) (Expr v_a2LsX a_a2LsY)
whileBody :: forall v_a2LsX a_a2LsY. Lens' (While v_a2LsX a_a2LsY) (Suite v_a2LsX a_a2LsY)

-- | Turns an <a>SimpleStatement</a> into a <a>Statement</a>
--   
--   <pre>
--   &gt;&gt;&gt; expr_ (int_ 3)
--   3
--   </pre>
expr_ :: Raw Expr -> Raw Statement
var_ :: String -> Raw Expr

-- | <pre>
--   &gt;&gt;&gt; await (var_ "a")
--   await a
--   </pre>
await_ :: Raw Expr -> Raw Expr

-- | <pre>
--   &gt;&gt;&gt; ifThenElse_ (var_ "a") (var_ "b") (var_ "c")
--   a if b else c
--   </pre>
ifThenElse_ :: Raw Expr -> Raw Expr -> Raw Expr -> Raw Expr

-- | <pre>
--   &gt;&gt;&gt; gen_ $ comp_ (var_ "a") (for_ $ var_ "a" `in_` list_ [li_ $ int_ 1, li_ $ int_ 2, li_ $ int_ 3]) [if_ $ var_ "a" .== 2]
--   (a for a in [1, 2, 3] if a == 2)
--   </pre>
gen_ :: Raw (Comprehension Expr) -> Raw Expr

-- | <pre>
--   &gt;&gt;&gt; yield_ []
--   yield
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; yield_ [var_ "a"]
--   yield a
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; yield_ [var_ "a", var_ "b"]
--   yield a, b
--   </pre>
yield_ :: [Raw Expr] -> Raw Expr

-- | <pre>
--   &gt;&gt;&gt; yieldFrom_ (var_ "a")
--   yield from a
--   </pre>
yieldFrom_ :: Raw Expr -> Raw Expr

-- | <pre>
--   &gt;&gt;&gt; tuple_ []
--   ()
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; tuple_ [ti_ $ var_ "a"]
--   a,
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; tuple_ [s_ $ var_ "a"]
--   (*a),
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; tuple_ [ti_ $ var_ "a", ti_ $ var_ "b"]
--   a, b
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; tuple_ [ti_ $ var_ "a", s_ $ var_ "b"]
--   a, *b
--   </pre>
tuple_ :: [Raw TupleItem] -> Raw Expr
data Tuple v a
MkTuple :: Ann a -> TupleItem v a -> Comma -> Maybe (CommaSep1' (TupleItem v a)) -> Tuple v a
[_tupleAnn] :: Tuple v a -> Ann a
[_tupleHead] :: Tuple v a -> TupleItem v a
[_tupleComma] :: Tuple v a -> Comma
[_tupleTail] :: Tuple v a -> Maybe (CommaSep1' (TupleItem v a))
class AsTupleItem e

-- | Create a <a>TupleItem</a>
ti_ :: AsTupleItem e => Raw e -> Raw TupleItem

-- | <tt>a</tt> or <tt>*a</tt>
--   
--   Used to construct tuples, e.g. <tt>(1, <tt>x</tt>, **c)</tt>
data TupleItem (v :: [*]) a

-- | <pre>
--   &gt;&gt;&gt; call_ "f" [p_ $ var_ "x"]
--   f(x)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; call_ "f" [p_ $ var_ "x", k_ "y" 2]
--   f(x, y=2)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; call_ "f" [p_ $ var_ "x", k_ "y" 2, s_ "z"]
--   f(x, y=2, *z)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; call_ "f" [p_ $ var_ "x", k_ "y" 2, s_ "z", ss_ "w"]
--   f(x, y=2, *z, **w)
--   </pre>
call_ :: Raw Expr -> [Raw Arg] -> Raw Expr
data Call v a
MkCall :: Ann a -> Expr v a -> [Whitespace] -> Maybe (CommaSep1' (Arg v a)) -> [Whitespace] -> Call v a
[_callAnn] :: Call v a -> Ann a
[_callFunction] :: Call v a -> Expr v a
[_callLeftParen] :: Call v a -> [Whitespace]
[_callArguments] :: Call v a -> Maybe (CommaSep1' (Arg v a))
[_callRightParen] :: Call v a -> [Whitespace]

-- | Create a minimal valid <a>Call</a>
mkCall :: Raw Expr -> Raw Call
callAnn :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) (Ann a_a2N4c)
callFunction :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) (Expr v_a2N4b a_a2N4c)
callLeftParen :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) [Whitespace]
callArguments :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) (Maybe (CommaSep1' (Arg v_a2N4b a_a2N4c)))
callRightParen :: forall v_a2N4b a_a2N4c. Lens' (Call v_a2N4b a_a2N4c) [Whitespace]

-- | <pre>
--   &gt;&gt;&gt; none_
--   None
--   </pre>
none_ :: Raw Expr
data None (v :: [*]) a
MkNone :: Ann a -> [Whitespace] -> None a
[_noneAnn] :: None a -> Ann a
[_noneWhitespace] :: None a -> [Whitespace]
_None :: Prism (Expr v a) (Expr '[] a) (None v a) (None '[] a)
noneAnn :: forall v_a2RLO a_a2RLP v_a2RZS a_a2RZT. Lens (None v_a2RLO a_a2RLP) (None v_a2RZS a_a2RZT) (Ann a_a2RLP) (Ann a_a2RZT)
noneWhitespace :: forall v_a2RLO a_a2RLP v_a2RZU. Lens (None v_a2RLO a_a2RLP) (None v_a2RZU a_a2RLP) [Whitespace] [Whitespace]

-- | Double-quoted string
--   
--   <pre>
--   &gt;&gt;&gt; str_ "asdf"
--   "asdf"
--   </pre>
str_ :: String -> Raw Expr

-- | Single-quoted string
--   
--   <pre>
--   &gt;&gt;&gt; str_ "asdf"
--   'asdf'
--   </pre>
str'_ :: String -> Raw Expr

-- | Long double-quoted string
--   
--   <pre>
--   &gt;&gt;&gt; longStr_ "asdf"
--   """asdf"""
--   </pre>
longStr_ :: String -> Raw Expr

-- | Long single-quoted string
--   
--   <pre>
--   &gt;&gt;&gt; longStr'_ "asdf"
--   '''asdf'''
--   </pre>
longStr'_ :: String -> Raw Expr

-- | <tt><a>Raw</a> <a>SimpleStatement</a></tt> has a <a>Num</a> instance,
--   but sometimes we need to name integers explicitly
--   
--   <pre>
--   &gt;&gt;&gt; int_ 10
--   10
--   </pre>
int_ :: Integer -> Raw Expr

-- | <pre>
--   &gt;&gt;&gt; true_
--   True
--   </pre>
true_ :: Raw Expr

-- | <pre>
--   &gt;&gt;&gt; false_
--   False
--   </pre>
false_ :: Raw Expr

-- | <pre>
--   &gt;&gt;&gt; ellipsis_
--   ...
--   </pre>
ellipsis_ :: Raw Expr

-- | <pre>
--   &gt;&gt;&gt; list_ [li_ $ var_ "a"]
--   [a]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; list_ [s_ $ var_ "a"]
--   [*a]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; list_ [li_ $ var_ "a", s_ $ var_ "b"]
--   [a, *b]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; list_ $ comp_ (var_ "a") (for_ $ var_ "a" `in_` list_ [li_ $ int_ 1, li_ $ int_ 2, li_ $ int_ 3]) [if_ $ var_ "a" .== 2]
--   [a for a in [1, 2, 3] if a == 2]
--   </pre>
class AsList s
list_ :: AsList s => s -> Raw Expr
class AsListItem s

-- | Create a <a>ListItem</a>
li_ :: AsListItem s => Raw s -> Raw ListItem

-- | <tt>a</tt> or <tt>*a</tt>
--   
--   Used to construct lists, e.g. <tt>[ 1, <tt>x</tt>, **c ]</tt>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#list-displays</a>
data ListItem (v :: [*]) a

-- | <pre>
--   &gt;&gt;&gt; dict_ [var_ "a" .: 1]
--   {a: 1}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; dict_ [ss_ $ var_ "a"]
--   {**a}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; dict_ [var_ "a" .: 1, ss_ $ var_ "b"]
--   {a: 1, **b}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; dict_ $ comp_ (var_ "a" .: 1) (for_ $ var_ "a" `in_` list_ [li_ $ int_ 1, li_ $ int_ 2, li_ $ int_ 3]) [if_ $ var_ "a" .== 2]
--   {a: 1 for a in [1, 2, 3] if a == 2}
--   </pre>
class AsDict s
dict_ :: AsDict s => s -> Raw Expr

-- | <tt>a : b</tt> or <tt>**a</tt>
--   
--   Used to construct dictionaries, e.g. <tt>{ 1: a, 2: b, **c }</tt>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#dictionary-displays</a>
data DictItem (v :: [*]) a

-- | <pre>
--   &gt;&gt;&gt; set_ []
--   set()
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; set_ [si_ $ var_ "a"]
--   {a}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; set_ [s_ $ var_ "a"]
--   {*a}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; set_ [si_ $ var_ "a", s_ $ var_ "b"]
--   {a, *b}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; set_ $ comp_ (var_ "a") (for_ $ var_ "a" `in_` set_ [si_ $ int_ 1, si_ $ int_ 2, si_ $ int_ 3]) [if_ $ var_ "a" .== 2]
--   {a for a in [1, 2, 3] if a == 2}
--   </pre>
class AsSet s
set_ :: AsSet s => s -> Raw Expr
class AsSetItem s

-- | Create a <a>SetItem</a>
si_ :: AsSetItem s => Raw s -> Raw SetItem

-- | <tt>a</tt> or <tt>*a</tt>
--   
--   Used to construct sets, e.g. <tt>{ 1, <tt>x</tt>, **c }</tt>
--   
--   
--   <a>https://docs.python.org/3/reference/expressions.html#set-displays</a>
data SetItem (v :: [*]) a

-- | <pre>
--   &gt;&gt;&gt; lambda_ [p_ "x"] "x"
--   lambda x: x
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lambda_ [p_ "x", k_ "y" 2] ("x" .+ "y")
--   lambda x, y=2: x + y
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lambda_ [p_ "x", k_ "y" 2, s_ "z"] "a"
--   lambda x, y=2, *z: a
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lambda_ [p_ "x", k_ "y" 2, s_ "z", ss_ "w"] "a"
--   lambda x, y=2, *z, **w: a
--   </pre>
lambda_ :: [Raw Param] -> Raw Expr -> Raw Expr

-- | <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (int_ 1)
--   a[1]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (tuple_ [ti_ $ int_ 1])
--   a[1,]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (tuple_ [ti_ $ int_ 1, ti_ $ int_ 2])
--   a[1, 2]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (tuple_ [s_ $ var_ "b"])
--   a[((*b),)]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (tuple_ [ti_ $ int_ 1, s_ $ var_ "b"])
--   a[(1, *b)]
--   </pre>
subs_ :: Raw Expr -> Raw Expr -> Raw Expr

-- | Slice *from* <tt>x</tt>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (sliceF_ $ int_ 0)
--   a[1:]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; sliceF_ $ int_ 0
--   slice(1, None, None)
--   </pre>
sliceF_ :: Raw Expr -> Raw Expr

-- | Slice *from* <tt>x</tt>, with *step* <tt>y</tt>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (sliceFS_ (int_ 0) (int_ 2))
--   a[1::2]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; sliceFS_ (int_ 0) (int_ 2)
--   slice(1, None, 2)
--   </pre>
sliceFS_ :: Raw Expr -> Raw Expr -> Raw Expr

-- | Slice <i>To</i> <tt>x</tt>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (sliceT_ $ int_ 10)
--   a[:10]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; sliceT_ $ int_ 10
--   slice(None, 10, None)
--   </pre>
sliceT_ :: Raw Expr -> Raw Expr

-- | Slice <i>To</i> <tt>x</tt>, with <i>Step</i> <tt>y</tt>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (sliceTS_ (int_ 10) (int_ 2))
--   a[:10:2]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; sliceTS_ (int_ 10) (int_ 2)
--   slice(None, 10, 2)
--   </pre>
sliceTS_ :: Raw Expr -> Raw Expr -> Raw Expr

-- | Slice <i>From</i> <tt>x</tt> <i>To</i> <tt>y</tt>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (sliceFT_ (int_ 1) (int_ 10))
--   a[1:10]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; sliceFT_ (int_ 1) (int_ 10)
--   slice(1, 10, None)
--   </pre>
sliceFT_ :: Raw Expr -> Raw Expr -> Raw Expr

-- | Slice <i>From</i> <tt>x</tt> <i>To</i> <tt>y</tt>, with <i>Step</i>
--   <tt>z</tt>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (sliceFTS_ (int_ 1) (int_ 10) (int_ 2))
--   a[1:10:2]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; sliceFTS_ (int_ 1) (int_ 10) (int_ 2)
--   slice(1, 10, 2)
--   </pre>
sliceFTS_ :: Raw Expr -> Raw Expr -> Raw Expr -> Raw Expr

-- | Slice with *step* <tt>x</tt>
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") (sliceS_ $ int_ (-1))
--   a[::-1]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; sliceS_ $ int_ (-1)
--   slice(None, None, -1)
--   </pre>
sliceS_ :: Raw Expr -> Raw Expr

-- | The slice with no bounds
--   
--   <pre>
--   &gt;&gt;&gt; subs_ (var_ "a") fullSlice_
--   a[:]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; fullSlice_
--   slice(None, None, None)
--   </pre>
fullSlice_ :: Raw Expr

-- | A slice object
--   
--   Represents a call to a function named <tt>slice</tt>, with 3
--   arguments. If an argument is a <a>Nothing</a> then it becomes
--   <a>None</a>, and if the argument is a <a>Just</a> then the contents
--   are extracted.
slice_ :: Maybe (Raw Expr) -> Maybe (Raw Expr) -> Maybe (Raw Expr) -> Raw Expr

-- | <pre>
--   &gt;&gt;&gt; var_ "a" /&gt; var_ "b"
--   a.b
--   </pre>
(/>) :: Raw Expr -> Raw Ident -> Raw Expr
infixl 9 />

-- | <pre>
--   not a
--   </pre>
not_ :: Raw Expr -> Raw Expr

-- | <pre>
--   -a
--   </pre>
neg_ :: Raw Expr -> Raw Expr

-- | <pre>
--   +a
--   </pre>
pos_ :: Raw Expr -> Raw Expr

-- | <pre>
--   ~a
--   </pre>
compl_ :: Raw Expr -> Raw Expr

-- | <pre>
--   a or b
--   </pre>
--   
--   Does not have a precedence
or_ :: Raw Expr -> Raw Expr -> Raw Expr

-- | <pre>
--   a and b
--   </pre>
--   
--   Does not have a precedence
and_ :: Raw Expr -> Raw Expr -> Raw Expr

-- | <pre>
--   a is b
--   </pre>
is_ :: Raw Expr -> Raw Expr -> Raw Expr
infixl 1 `is_`

-- | <pre>
--   a is not b
--   </pre>
isNot_ :: Raw Expr -> Raw Expr -> Raw Expr
infixl 1 `isNot_`

-- | <pre>
--   a not in b
--   </pre>
notIn_ :: Raw Expr -> Raw Expr -> Raw Expr
infixl 1 `notIn_`

-- | <pre>
--   a == b
--   </pre>
(.==) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 1 .==

-- | <pre>
--   a &gt; b
--   </pre>
(.>) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 1 .>

-- | <pre>
--   a &gt;= b
--   </pre>
(.>=) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 1 .>=

-- | <pre>
--   a &lt; b
--   </pre>
(.<) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 1 .<

-- | <pre>
--   a &lt;= b
--   </pre>
(.<=) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 1 .<=

-- | <pre>
--   a != b
--   </pre>
(.!=) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 1 .!=

-- | <pre>
--   a | b
--   </pre>
(.|) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 2 .|

-- | <pre>
--   a ^ b
--   </pre>
(.^) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 3 .^

-- | <pre>
--   a &amp; b
--   </pre>
(.&) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 4 .&

-- | <pre>
--   a &lt;&lt; b
--   </pre>
(.<<) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 5 .<<

-- | <pre>
--   a &gt;&gt; b
--   </pre>
(.>>) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 5 .>>

-- | <pre>
--   a - b
--   </pre>
(.-) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 6 .-

-- | <pre>
--   a + b
--   </pre>
(.+) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 6 .+

-- | <pre>
--   a * b
--   </pre>
(.*) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 7 .*

-- | <pre>
--   a @ b
--   </pre>
(.@) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 7 .@

-- | <pre>
--   a / b
--   </pre>
(./) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 7 ./

-- | <pre>
--   a // b
--   </pre>
(.//) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 7 .//

-- | <pre>
--   a % b
--   </pre>
(.%) :: Raw Expr -> Raw Expr -> Raw Expr
infixl 7 .%

-- | <pre>
--   a ** b
--   </pre>
(.**) :: Raw Expr -> Raw Expr -> Raw Expr
infixr 8 .**

-- | Convert a list of <a>Line</a>s to a <a>Block</a>, without indenting
--   them
linesToBlock :: [Raw Line] -> Raw Block
blockToLines :: Raw Block -> [Raw Line]
instance Language.Python.DSL.AsTupleItem Language.Python.Syntax.Expr.Expr
instance Language.Python.DSL.AsTupleItem Language.Python.Syntax.Expr.TupleItem
instance Language.Python.DSL.AsWithItem Language.Python.Syntax.Expr.Expr
instance Language.Python.DSL.AsWithItem Language.Python.Syntax.Statement.WithItem
instance Language.Python.DSL.As Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Ident.Ident Language.Python.Syntax.Statement.ExceptAs
instance Language.Python.DSL.As Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Statement.WithItem
instance (e Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Types.Except, s Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Types.TryExcept) => Language.Python.DSL.ExceptSyntax (e -> s)
instance Language.Python.DSL.ExceptSyntax (Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Types.TryExcept)
instance Language.Python.DSL.ExceptSyntax (Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Types.TryFinally)
instance Language.Python.DSL.AsExceptAs Language.Python.Syntax.Statement.ExceptAs
instance Language.Python.DSL.AsExceptAs Language.Python.Syntax.Expr.Expr
instance Language.Python.DSL.FinallySyntax (Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Types.TryExcept) Language.Python.Syntax.Types.TryExcept
instance Language.Python.DSL.FinallySyntax (Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Types.TryFinally) Language.Python.Syntax.Types.TryFinally
instance (a Data.Type.Equality.~ [Language.Python.Syntax.Raw.Raw Language.Python.DSL.Line], b Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Types.TryFinally) => Language.Python.DSL.FinallySyntax (a -> b) Language.Python.Syntax.Types.TryFinally
instance Language.Python.DSL.AsyncSyntax Language.Python.Syntax.Types.Fundef
instance Language.Python.DSL.AsyncSyntax Language.Python.Syntax.Types.For
instance Language.Python.DSL.AsyncSyntax Language.Python.Syntax.Types.With
instance Language.Python.DSL.ElseSyntax Language.Python.Syntax.Types.While
instance Language.Python.DSL.ElseSyntax Language.Python.Syntax.Types.For
instance Language.Python.DSL.ElseSyntax Language.Python.Syntax.Types.If
instance Language.Python.DSL.ElseSyntax Language.Python.Syntax.Types.TryExcept
instance Language.Python.DSL.InSyntax Language.Python.Syntax.Expr.Expr (Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Expr.Expr)
instance (e Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Expr.Expr) => Language.Python.DSL.InSyntax Language.Python.DSL.InList [e]
instance (l Data.Type.Equality.~ [Language.Python.Syntax.Raw.Raw Language.Python.DSL.Line], s Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Types.For) => Language.Python.DSL.ForSyntax (l -> s) Language.Python.DSL.InList
instance Language.Python.DSL.ForSyntax (Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Expr.CompFor) Language.Python.DSL.In
instance Language.Python.DSL.ForSyntax (Language.Python.Syntax.Raw.Raw Language.Python.DSL.Guard) Language.Python.DSL.In
instance (e Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Expr.DictItem) => Language.Python.DSL.AsDict [e]
instance (e Data.Type.Equality.~ Language.Python.Syntax.Expr.Comprehension Language.Python.Syntax.Expr.DictItem) => Language.Python.DSL.AsDict (Language.Python.Syntax.Raw.Raw e)
instance Language.Python.DSL.AsSetItem Language.Python.Syntax.Expr.SetItem
instance Language.Python.DSL.AsSetItem Language.Python.Syntax.Expr.Expr
instance (e Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Expr.SetItem) => Language.Python.DSL.AsSet [e]
instance (e Data.Type.Equality.~ Language.Python.Syntax.Expr.Comprehension Language.Python.Syntax.Expr.SetItem) => Language.Python.DSL.AsSet (Language.Python.Syntax.Raw.Raw e)
instance Language.Python.DSL.IfSyntax (Language.Python.Syntax.Raw.Raw Language.Python.DSL.Guard)
instance (l Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.DSL.Line, s Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Types.If) => Language.Python.DSL.IfSyntax ([l] -> s)
instance Language.Python.DSL.AsListItem Language.Python.Syntax.Expr.ListItem
instance Language.Python.DSL.AsListItem Language.Python.Syntax.Expr.Expr
instance (e Data.Type.Equality.~ Language.Python.Syntax.Raw.Raw Language.Python.Syntax.Expr.ListItem) => Language.Python.DSL.AsList [e]
instance (e Data.Type.Equality.~ Language.Python.Syntax.Expr.Comprehension Language.Python.Syntax.Expr.Expr) => Language.Python.DSL.AsList (Language.Python.Syntax.Raw.Raw e)
instance Language.Python.DSL.DecoratorsSyntax Language.Python.Syntax.Types.Fundef
instance Language.Python.DSL.DecoratorsSyntax Language.Python.Syntax.Types.ClassDef
instance Language.Python.DSL.ArgumentsSyntax Language.Python.Syntax.Types.Call
instance Language.Python.DSL.ArgumentsSyntax Language.Python.Syntax.Types.ClassDef
instance Language.Python.DSL.ParametersSyntax Language.Python.Syntax.Types.Fundef
instance Language.Python.DSL.DoubleStarSyntax Language.Python.Syntax.Ident.Ident Language.Python.Syntax.Expr.Param
instance Language.Python.DSL.DoubleStarSyntax Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Expr.Arg
instance Language.Python.DSL.DoubleStarSyntax Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Expr.DictItem
instance Language.Python.DSL.KeywordSyntax Language.Python.Syntax.Expr.Param
instance Language.Python.DSL.KeywordSyntax Language.Python.Syntax.Expr.Arg
instance Language.Python.DSL.StarSyntax Language.Python.Syntax.Ident.Ident Language.Python.Syntax.Expr.Param
instance Language.Python.DSL.StarSyntax Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Expr.Arg
instance Language.Python.DSL.StarSyntax Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Expr.ListItem
instance Language.Python.DSL.StarSyntax Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Expr.SetItem
instance Language.Python.DSL.StarSyntax Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Expr.TupleItem
instance Language.Python.DSL.PositionalSyntax Language.Python.Syntax.Expr.Param Language.Python.Syntax.Ident.Ident
instance Language.Python.DSL.PositionalSyntax Language.Python.Syntax.Expr.Arg Language.Python.Syntax.Expr.Expr
instance Language.Python.DSL.ColonSyntax Language.Python.Syntax.Expr.Expr Language.Python.Syntax.Expr.DictItem
instance Language.Python.DSL.ColonSyntax Language.Python.Syntax.Expr.Param Language.Python.Syntax.Expr.Param
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.Fundef
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.While
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.Elif
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.Else
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.If
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.For
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.TryExcept
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.TryFinally
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.ClassDef
instance Language.Python.DSL.BodySyntax Language.Python.Syntax.Types.With
instance Language.Python.DSL.AsLine Language.Python.Syntax.Statement.SmallStatement
instance Language.Python.DSL.AsLine Language.Python.Syntax.Statement.SimpleStatement
instance Language.Python.DSL.AsLine Language.Python.Syntax.Statement.CompoundStatement
instance Language.Python.DSL.AsLine Language.Python.Syntax.Types.ClassDef
instance Language.Python.DSL.AsLine Language.Python.Syntax.Types.Fundef
instance Language.Python.DSL.AsLine Language.Python.Syntax.Types.If
instance Language.Python.DSL.AsLine Language.Python.Syntax.Types.While
instance Language.Python.DSL.AsLine Language.Python.Syntax.Types.With
instance Language.Python.DSL.AsLine Language.Python.Syntax.Statement.Statement
instance Language.Python.DSL.AsLine Language.Python.Syntax.Expr.Expr
instance Language.Python.DSL.AsLine Language.Python.Syntax.Types.For
instance Language.Python.DSL.AsLine Language.Python.Syntax.Types.TryExcept
instance Language.Python.DSL.AsLine Language.Python.Syntax.Types.TryFinally
instance (Language.Python.DSL.Line v1 a1 Data.Type.Equality.~ t) => Control.Lens.Wrapped.Rewrapped (Language.Python.DSL.Line v2 a2) t
instance Control.Lens.Wrapped.Wrapped (Language.Python.DSL.Line v a)
instance Language.Python.Syntax.Expr.HasExprs Language.Python.DSL.Line
instance Language.Python.Syntax.Statement.HasStatements Language.Python.DSL.Line
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.DSL.Line v a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.DSL.Line v a)


module Language.Python.Validate.Indentation.Error
data IndentationError a
IndentationTabError :: a -> IndentationError a
ExpectedGreaterThan :: [Indent] -> Indents a -> IndentationError a
ExpectedEqualTo :: [Indent] -> Indents a -> IndentationError a
EmptyContinuedLine :: a -> IndentationError a
class AsTabError s a | s -> a
_TabError :: AsTabError s a => Prism' s a
class AsTabError s a => AsIndentationError s a | s -> a
_IndentationError :: AsIndentationError s a => Prism' s (IndentationError a)
_ExpectedGreaterThan :: AsIndentationError s a => Prism' s ([Indent], Indents a)
_ExpectedEqualTo :: AsIndentationError s a => Prism' s ([Indent], Indents a)
_EmptyContinuedLine :: AsIndentationError s a => Prism' s a
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Validate.Indentation.Error.IndentationError a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Validate.Indentation.Error.IndentationError a)
instance Language.Python.Validate.Indentation.Error.AsIndentationError (Language.Python.Validate.Indentation.Error.IndentationError a) a
instance Language.Python.Internal.Lexer.AsTabError (Language.Python.Validate.Indentation.Error.IndentationError a) a


module Language.Python.Validate.Indentation
data Indentation
type ValidateIndentation e = ValidateM (NonEmpty e) (State (NextIndent, [Indent]))
runValidateIndentation :: ValidateIndentation e a -> Validation (NonEmpty e) a
validateModuleIndentation :: AsIndentationError e a => Module v a -> ValidateIndentation e (Module (Nub (Indentation : v)) a)
validateStatementIndentation :: AsIndentationError e a => Statement v a -> ValidateIndentation e (Statement (Nub (Indentation : v)) a)
validateExprIndentation :: AsIndentationError e a => Expr v a -> ValidateIndentation e (Expr (Nub (Indentation : v)) a)

-- | "The next line must be..."
data NextIndent
GreaterThan :: NextIndent
EqualTo :: NextIndent
equivalentIndentation :: [Whitespace] -> [Whitespace] -> Bool
runValidateIndentation' :: NextIndent -> [Indent] -> ValidateIndentation e a -> Validation (NonEmpty e) a
validateArgsIndentation :: AsIndentationError e a => CommaSep (Arg v a) -> ValidateIndentation e (CommaSep (Arg (Nub (Indentation : v)) a))
validateBlockIndentation :: forall e v a. AsIndentationError e a => Block v a -> ValidateIndentation e (Block (Nub (Indentation : v)) a)
validateCompoundStatementIndentation :: forall e v a. AsIndentationError e a => CompoundStatement v a -> ValidateIndentation e (CompoundStatement (Nub (Indentation : v)) a)
validateDecoratorIndentation :: AsIndentationError e a => Decorator v a -> ValidateIndentation e (Decorator (Nub (Indentation : v)) a)
validateExceptAsIndentation :: AsIndentationError e a => ExceptAs v a -> ValidateIndentation e (ExceptAs (Nub (Indentation : v)) a)
validateParamsIndentation :: AsIndentationError e a => CommaSep (Param v a) -> ValidateIndentation e (CommaSep (Param (Nub (Indentation : v)) a))
validateSuiteIndentation :: AsIndentationError e a => Indents a -> Suite v a -> ValidateIndentation e (Suite (Nub (Indentation : v)) a)
instance GHC.Show.Show Language.Python.Validate.Indentation.NextIndent
instance GHC.Classes.Eq Language.Python.Validate.Indentation.NextIndent


module Language.Python.Validate.Scope.Error
data ScopeError a

-- | Using <tt>nonlocal</tt> to modify function scopes makes scope checking
--   intractible
FoundNonlocal :: a -> ScopeError a

-- | Using <tt>global</tt> to add identifiers to the global scope makes
--   scope checking intractible
FoundGlobal :: a -> ScopeError a

-- | Using <tt>del</tt> to remove identifiers from scope makes scope
--   checking intractible
DeletedIdent :: a -> ScopeError a

-- | Variable assignments deep in control flow can modify the scope outside
--   the control flow. For example:
--   
--   <pre>
--   if a:
--       x = 0
--   else:
--       pass
--   
--   print(x)
--   </pre>
--   
--   <tt>x</tt> will be in scope if the <tt>True</tt> branch was entered,
--   but not if the <tt>False</tt> branch was entered. This kind of
--   behaviour makes scope checking intractible, so programs like this are
--   considered scope errors.
FoundDynamic :: a -> Ident '[] a -> ScopeError a

-- | An identifier is not in scope
NotInScope :: Ident '[] a -> ScopeError a

-- | For loops don't execute in a fresh scope, so if the <tt>counter</tt>
--   of the loop shadows a variable, then that variable will be mutated.
--   
--   e.g.
--   
--   <pre>
--   x = 0
--   for x in 1, 2, 3:
--      pass
--   print(x)
--   </pre>
--   
--   outputs <tt>3</tt>
--   
--   This error occurs when we spot this pattern.
BadShadowing :: Ident '[] a -> ScopeError a
class AsScopeError r_a5SBa a_a5SvC | r_a5SBa -> a_a5SvC
_ScopeError :: AsScopeError r_a5SBa a_a5SvC => Prism' r_a5SBa (ScopeError a_a5SvC)
_FoundNonlocal :: AsScopeError r_a5SBa a_a5SvC => Prism' r_a5SBa a_a5SvC
_FoundGlobal :: AsScopeError r_a5SBa a_a5SvC => Prism' r_a5SBa a_a5SvC
_DeletedIdent :: AsScopeError r_a5SBa a_a5SvC => Prism' r_a5SBa a_a5SvC
_FoundDynamic :: AsScopeError r_a5SBa a_a5SvC => Prism' r_a5SBa (a_a5SvC, Ident ('[] :: [Type]) a_a5SvC)
_NotInScope :: AsScopeError r_a5SBa a_a5SvC => Prism' r_a5SBa (Ident ('[] :: [Type]) a_a5SvC)
_BadShadowing :: AsScopeError r_a5SBa a_a5SvC => Prism' r_a5SBa (Ident ('[] :: [Type]) a_a5SvC)
instance Language.Python.Validate.Scope.Error.AsScopeError (Language.Python.Validate.Scope.Error.ScopeError a) a
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Validate.Scope.Error.ScopeError a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Validate.Scope.Error.ScopeError a)


module Language.Python.Validate.Scope
data Scope
type ValidateScope ann e = ValidateM (NonEmpty e) (State (ScopeContext ann))
runValidateScope :: ValidateScope ann e a -> Validation (NonEmpty e) a
validateModuleScope :: AsScopeError e a => Module v a -> ValidateScope a e (Module (Nub (Scope : v)) a)
validateStatementScope :: AsScopeError e a => Statement v a -> ValidateScope a e (Statement (Nub (Scope : v)) a)
validateExprScope :: AsScopeError e a => Expr v a -> ValidateScope a e (Expr (Nub (Scope : v)) a)
data ScopeContext a
ScopeContext :: !Map ByteString a -> !Map ByteString a -> !Map ByteString a -> ScopeContext a
[_scGlobalScope] :: ScopeContext a -> !Map ByteString a
[_scLocalScope] :: ScopeContext a -> !Map ByteString a
[_scImmediateScope] :: ScopeContext a -> !Map ByteString a
scGlobalScope :: forall a_a5TRu. Lens' (ScopeContext a_a5TRu) (Map ByteString a_a5TRu)
scLocalScope :: forall a_a5TRu. Lens' (ScopeContext a_a5TRu) (Map ByteString a_a5TRu)
scImmediateScope :: forall a_a5TRu. Lens' (ScopeContext a_a5TRu) (Map ByteString a_a5TRu)
runValidateScope' :: ScopeContext ann -> ValidateScope ann e a -> Validation (NonEmpty e) a
initialScopeContext :: ScopeContext a
data Binding
Clean :: Binding
Dirty :: Binding
inScope :: MonadState (ScopeContext ann) m => String -> m (Maybe (Binding, ann))
extendScope :: Setter' (ScopeContext ann) (Map ByteString ann) -> [(ann, String)] -> ValidateScope ann e ()
locallyOver :: Lens' (ScopeContext ann) b -> (b -> b) -> ValidateScope ann e a -> ValidateScope ann e a
locallyExtendOver :: Lens' (ScopeContext ann) (Map ByteString ann) -> [(ann, String)] -> ValidateScope ann e a -> ValidateScope ann e a
validateArgScope :: AsScopeError e a => Arg v a -> ValidateScope a e (Arg (Nub (Scope : v)) a)
validateAssignExprScope :: AsScopeError e a => Expr v a -> ValidateScope a e (Expr (Nub (Scope : v)) a)
validateBlockScope :: AsScopeError e a => Block v a -> ValidateScope a e (Block (Nub (Scope : v)) a)
validateCompoundStatementScope :: forall e v a. AsScopeError e a => CompoundStatement v a -> ValidateScope a e (CompoundStatement (Nub (Scope : v)) a)
validateComprehensionScope :: AsScopeError e a => (ex v a -> ValidateScope a e (ex (Nub (Scope : v)) a)) -> Comprehension ex v a -> ValidateScope a e (Comprehension ex (Nub (Scope : v)) a)
validateDecoratorScope :: AsScopeError e a => Decorator v a -> ValidateScope a e (Decorator (Nub (Scope : v)) a)
validateDictItemScope :: AsScopeError e a => DictItem v a -> ValidateScope a e (DictItem (Nub (Scope : v)) a)
validateExceptAsScope :: AsScopeError e a => ExceptAs v a -> ValidateScope a e (ExceptAs (Nub (Scope : v)) a)
validateIdentScope :: AsScopeError e a => Ident v a -> ValidateScope a e (Ident (Nub (Scope : v)) a)
validateListItemScope :: AsScopeError e a => ListItem v a -> ValidateScope a e (ListItem (Nub (Scope : v)) a)
validateParamScope :: AsScopeError e a => Param v a -> ValidateScope a e (Param (Nub (Scope : v)) a)
validateSetItemScope :: AsScopeError e a => SetItem v a -> ValidateScope a e (SetItem (Nub (Scope : v)) a)
validateSimpleStatementScope :: AsScopeError e a => SimpleStatement v a -> ValidateScope a e (SimpleStatement (Nub (Scope : v)) a)
validateSubscriptScope :: AsScopeError e a => Subscript v a -> ValidateScope a e (Subscript (Nub (Scope : v)) a)
validateSuiteScope :: AsScopeError e a => Suite v a -> ValidateScope a e (Suite (Nub (Scope : v)) a)
validateTupleItemScope :: AsScopeError e a => TupleItem v a -> ValidateScope a e (TupleItem (Nub (Scope : v)) a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Validate.Scope.ScopeContext a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Validate.Scope.ScopeContext a)
instance GHC.Show.Show Language.Python.Validate.Scope.Binding
instance GHC.Classes.Ord Language.Python.Validate.Scope.Binding
instance GHC.Classes.Eq Language.Python.Validate.Scope.Binding


module Language.Python.Validate.Syntax.Error
data SyntaxError a
PositionalAfterKeywordArg :: a -> Expr '[] a -> SyntaxError a
PositionalAfterKeywordUnpacking :: a -> Expr '[] a -> SyntaxError a
CannotAssignTo :: a -> Expr '[] a -> SyntaxError a
CannotDelete :: a -> Expr '[] a -> SyntaxError a
CannotAugAssignTo :: a -> Expr '[] a -> SyntaxError a
NoBindingNonlocal :: Ident '[] a -> SyntaxError a
PositionalAfterKeywordParam :: a -> String -> SyntaxError a
UnexpectedDoubleStarParam :: a -> String -> SyntaxError a
DuplicateArgument :: a -> String -> SyntaxError a
UnexpectedNewline :: a -> SyntaxError a
UnexpectedComment :: a -> SyntaxError a
IdentifierReservedWord :: a -> String -> SyntaxError a
EmptyIdentifier :: a -> SyntaxError a
BadCharacter :: a -> String -> SyntaxError a
BreakOutsideLoop :: a -> SyntaxError a
ContinueOutsideLoop :: a -> SyntaxError a
ReturnOutsideFunction :: a -> SyntaxError a
NonlocalOutsideFunction :: a -> SyntaxError a
ParametersNonlocal :: a -> [String] -> SyntaxError a
Can'tJoinStringAndBytes :: a -> SyntaxError a
YieldOutsideGenerator :: a -> SyntaxError a
MalformedDecorator :: a -> SyntaxError a
InvalidDictUnpacking :: a -> SyntaxError a
InvalidSetUnpacking :: a -> SyntaxError a
TypedParamInLambda :: a -> SyntaxError a
AsyncWithOutsideCoroutine :: a -> SyntaxError a
AsyncForOutsideCoroutine :: a -> SyntaxError a
YieldFromInsideCoroutine :: a -> SyntaxError a
YieldInsideCoroutine :: a -> SyntaxError a
AwaitOutsideCoroutine :: a -> SyntaxError a
AwaitInsideComprehension :: a -> SyntaxError a
NullByte :: a -> SyntaxError a
NonAsciiInBytes :: a -> Char -> SyntaxError a
DefaultExceptMustBeLast :: a -> SyntaxError a
WildcardImportInDefinition :: a -> SyntaxError a
NoKeywordsAfterEmptyStarArg :: a -> SyntaxError a
ManyStarredTargets :: a -> SyntaxError a
ManyStarredParams :: a -> SyntaxError a
ContinueInsideFinally :: a -> SyntaxError a
ParameterMarkedGlobal :: a -> String -> SyntaxError a
class AsSyntaxError r_a64u8 a_a644s | r_a64u8 -> a_a644s
_SyntaxError :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (SyntaxError a_a644s)
_PositionalAfterKeywordArg :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, Expr ('[] :: [Type]) a_a644s)
_PositionalAfterKeywordUnpacking :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, Expr ('[] :: [Type]) a_a644s)
_CannotAssignTo :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, Expr ('[] :: [Type]) a_a644s)
_CannotDelete :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, Expr ('[] :: [Type]) a_a644s)
_CannotAugAssignTo :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, Expr ('[] :: [Type]) a_a644s)
_NoBindingNonlocal :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (Ident ('[] :: [Type]) a_a644s)
_PositionalAfterKeywordParam :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, String)
_UnexpectedDoubleStarParam :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, String)
_DuplicateArgument :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, String)
_UnexpectedNewline :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_UnexpectedComment :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_IdentifierReservedWord :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, String)
_EmptyIdentifier :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_BadCharacter :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, String)
_BreakOutsideLoop :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_ContinueOutsideLoop :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_ReturnOutsideFunction :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_NonlocalOutsideFunction :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_ParametersNonlocal :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, [String])
_Can'tJoinStringAndBytes :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_YieldOutsideGenerator :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_MalformedDecorator :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_InvalidDictUnpacking :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_InvalidSetUnpacking :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_TypedParamInLambda :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_AsyncWithOutsideCoroutine :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_AsyncForOutsideCoroutine :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_YieldFromInsideCoroutine :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_YieldInsideCoroutine :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_AwaitOutsideCoroutine :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_AwaitInsideComprehension :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_NullByte :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_NonAsciiInBytes :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, Char)
_DefaultExceptMustBeLast :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_WildcardImportInDefinition :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_NoKeywordsAfterEmptyStarArg :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_ManyStarredTargets :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_ManyStarredParams :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_ContinueInsideFinally :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 a_a644s
_ParameterMarkedGlobal :: AsSyntaxError r_a64u8 a_a644s => Prism' r_a64u8 (a_a644s, String)
instance Language.Python.Validate.Syntax.Error.AsSyntaxError (Language.Python.Validate.Syntax.Error.SyntaxError a) a
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Validate.Syntax.Error.SyntaxError a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Validate.Syntax.Error.SyntaxError a)


module Language.Python.Validate.Syntax
data Syntax
type ValidateSyntax e = ValidateM (NonEmpty e) (ReaderT SyntaxContext (State [String]))
runValidateSyntax :: ValidateSyntax e a -> Validation (NonEmpty e) a
validateModuleSyntax :: (AsSyntaxError e a, Member Indentation v) => Module v a -> ValidateSyntax e (Module (Nub (Syntax : v)) a)
validateStatementSyntax :: (AsSyntaxError e a, Member Indentation v) => Statement v a -> ValidateSyntax e (Statement (Nub (Syntax : v)) a)
validateExprSyntax :: (AsSyntaxError e a, Member Indentation v) => Expr v a -> ValidateSyntax e (Expr (Nub (Syntax : v)) a)
data SyntaxContext
SyntaxContext :: Bool -> Bool -> Maybe FunctionInfo -> Bool -> Bool -> Bool -> SyntaxContext
[_inLoop] :: SyntaxContext -> Bool
[_inFinally] :: SyntaxContext -> Bool
[_inFunction] :: SyntaxContext -> Maybe FunctionInfo
[_inGenerator] :: SyntaxContext -> Bool
[_inClass] :: SyntaxContext -> Bool
[_inParens] :: SyntaxContext -> Bool
data FunctionInfo
FunctionInfo :: [String] -> Bool -> FunctionInfo
[_functionParams] :: FunctionInfo -> [String]
[_asyncFunction] :: FunctionInfo -> Bool
inLoop :: Lens' SyntaxContext Bool
inFunction :: Lens' SyntaxContext (Maybe FunctionInfo)
inGenerator :: Lens' SyntaxContext Bool
inParens :: Lens' SyntaxContext Bool
runValidateSyntax' :: SyntaxContext -> [String] -> ValidateSyntax e a -> Validation (NonEmpty e) a
initialSyntaxContext :: SyntaxContext
reservedWords :: [String]
canAssignTo :: Expr v a -> Bool
deleteBy' :: (a -> b -> Bool) -> a -> [b] -> [b]
deleteFirstsBy' :: (a -> b -> Bool) -> [a] -> [b] -> [a]
localNonlocals :: ([String] -> [String]) -> ValidateSyntax e a -> ValidateSyntax e a
validateArgsSyntax :: (AsSyntaxError e a, Member Indentation v) => CommaSep1' (Arg v a) -> ValidateSyntax e (CommaSep1' (Arg (Nub (Syntax : v)) a))
validateBlockSyntax :: (AsSyntaxError e a, Member Indentation v) => Block v a -> ValidateSyntax e (Block (Nub (Syntax : v)) a)
validateCompoundStatementSyntax :: forall e v a. (AsSyntaxError e a, Member Indentation v) => CompoundStatement v a -> ValidateSyntax e (CompoundStatement (Nub (Syntax : v)) a)
validateComprehensionSyntax :: (AsSyntaxError e a, Member Indentation v) => (ex v a -> ValidateSyntax e (ex (Nub (Syntax : v)) a)) -> Comprehension ex v a -> ValidateSyntax e (Comprehension ex (Nub (Syntax : v)) a)
validateDecoratorSyntax :: (AsSyntaxError e a, Member Indentation v) => Decorator v a -> ValidateSyntax e (Decorator (Nub (Syntax : v)) a)
validateDictItemSyntax :: (AsSyntaxError e a, Member Indentation v) => DictItem v a -> ValidateSyntax e (DictItem (Nub (Syntax : v)) a)
validateExceptAsSyntax :: (AsSyntaxError e a, Member Indentation v) => ExceptAs v a -> ValidateSyntax e (ExceptAs (Nub (Syntax : v)) a)
validateIdentSyntax :: (AsSyntaxError e a, Member Indentation v) => Ident v a -> ValidateSyntax e (Ident (Nub (Syntax : v)) a)
validateImportAsSyntax :: (AsSyntaxError e a, Member Indentation v) => (t v a -> ValidateSyntax e (t' (Nub (Syntax : v)) a)) -> ImportAs t v a -> ValidateSyntax e (ImportAs t' (Nub (Syntax : v)) a)
validateImportTargetsSyntax :: (AsSyntaxError e a, Member Indentation v) => ImportTargets v a -> ValidateSyntax e (ImportTargets (Nub (Syntax : v)) a)
validateListItemSyntax :: (AsSyntaxError e a, Member Indentation v) => ListItem v a -> ValidateSyntax e (ListItem (Nub (Syntax : v)) a)
validateParamsSyntax :: forall e v a. (AsSyntaxError e a, Member Indentation v) => Bool -> CommaSep (Param v a) -> ValidateSyntax e (CommaSep (Param (Nub (Syntax : v)) a))
validateSetItemSyntax :: (AsSyntaxError e a, Member Indentation v) => SetItem v a -> ValidateSyntax e (SetItem (Nub (Syntax : v)) a)
validateSimpleStatementSyntax :: forall e a v. (AsSyntaxError e a, Member Indentation v) => SimpleStatement v a -> ValidateSyntax e (SimpleStatement (Nub (Syntax : v)) a)
validateStringLiteralSyntax :: AsSyntaxError e a => StringLiteral a -> ValidateSyntax e (StringLiteral a)
validateSubscriptSyntax :: (AsSyntaxError e a, Member Indentation v) => Subscript v a -> ValidateSyntax e (Subscript (Nub (Syntax : v)) a)
validateSuiteSyntax :: (AsSyntaxError e a, Member Indentation v) => Suite v a -> ValidateSyntax e (Suite (Nub (Syntax : v)) a)
validateTupleItemSyntax :: (AsSyntaxError e a, Member Indentation v) => TupleItem v a -> ValidateSyntax e (TupleItem (Nub (Syntax : v)) a)
validateWhitespace :: (AsSyntaxError e a, Foldable f) => a -> f Whitespace -> ValidateSyntax e (f Whitespace)

module Language.Python.Validate.Error
data ValidationError a
IndentationError :: IndentationError a -> ValidationError a
ScopeError :: ScopeError a -> ValidationError a
SyntaxError :: SyntaxError a -> ValidationError a
instance GHC.Show.Show a => GHC.Show.Show (Language.Python.Validate.Error.ValidationError a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Python.Validate.Error.ValidationError a)
instance Language.Python.Internal.Lexer.AsTabError (Language.Python.Validate.Error.ValidationError a) a
instance Language.Python.Validate.Indentation.Error.AsIndentationError (Language.Python.Validate.Error.ValidationError a) a
instance Language.Python.Validate.Scope.Error.AsScopeError (Language.Python.Validate.Error.ValidationError a) a
instance Language.Python.Validate.Syntax.Error.AsSyntaxError (Language.Python.Validate.Error.ValidationError a) a


module Language.Python.Validate
validateModuleAll :: (AsIndentationError e a, AsSyntaxError e a, AsScopeError e a) => Module '[] a -> Validation (NonEmpty e) (Module '[Scope, Syntax, Indentation] a)
validateStatementAll :: (AsIndentationError e a, AsSyntaxError e a, AsScopeError e a) => Statement '[] a -> Validation (NonEmpty e) (Statement '[Scope, Syntax, Indentation] a)
validateExprAll :: (AsIndentationError e a, AsSyntaxError e a, AsScopeError e a) => Expr '[] a -> Validation (NonEmpty e) (Expr '[Scope, Syntax, Indentation] a)

-- | Validate a datatype for indentation, syntax, and scope correctness
--   
--   e.g.
--   
--   <pre>
--   <a>validateModuleAll</a> =
--     <a>validateAll</a>
--       <a>validateModuleIndentation</a>
--       <a>validateModuleSyntax</a>
--       <a>validateModuleScope</a>
--   </pre>
validateAll :: (AsIndentationError e a, AsSyntaxError e a, AsScopeError e a) => (s '[] a -> ValidateIndentation e (s '[Indentation] a)) -> (s '[Indentation] a -> ValidateSyntax e (s '[Syntax, Indentation] a)) -> (s '[Syntax, Indentation] a -> ValidateScope a e (s '[Scope, Syntax, Indentation] a)) -> s '[] a -> Validation (NonEmpty e) (s '[Scope, Syntax, Indentation] a)


-- | <tt>hpython</tt> provides tools for working with Python source code.
--   
--   <a>Language.Python.DSL</a>: A DSL for writing Python programs
--   
--   <a>Language.Python.Optics</a>: Optics for working with Python syntax
--   trees
--   
--   <a>Language.Python.Parse</a>: Parse Python source into a syntax tree
--   
--   <a>Language.Python.Render</a>: Pretty print Python syntax trees
--   
--   <a>Language.Python.Syntax</a>: The data structures that represent
--   Python programs, like <a>Statement</a> and <a>SimpleStatement</a>
--   
--   <a>Language.Python.Validate</a>: Validate aspects of Python syntax
--   trees, like indentation, syntax, or scope
module Language.Python