-- 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.1


-- | 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.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 :: a -> String -> Comment a
[_commentAnn] :: Comment a -> 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 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)


-- | 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 :: a -> NonEmpty DecDigit -> IntLiteral a
[_intLiteralAnn] :: IntLiteral a -> a
[_unsafeIntLiteralDecValue] :: IntLiteral a -> NonEmpty DecDigit

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

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

-- | Mixed-case hexadecimal
--   
--   <pre>
--   0x18B4f
--   </pre>
IntLiteralHex :: a -> Bool -> NonEmpty HeXDigit -> IntLiteral a
[_intLiteralAnn] :: IntLiteral a -> 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 :: a -> NonEmpty DecDigit -> Maybe (These (NonEmpty DecDigit) FloatExponent) -> FloatLiteral a
[_floatLiteralAnn] :: FloatLiteral a -> 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 :: a -> NonEmpty DecDigit -> Maybe FloatExponent -> FloatLiteral a
[_floatLiteralAnn] :: FloatLiteral a -> a
[_floatLiteralPointRight] :: FloatLiteral a -> NonEmpty DecDigit
[_floatLiteralPointExponent] :: FloatLiteral a -> Maybe FloatExponent

-- | Floats with no decimal points
--   
--   <pre>
--   12e34
--   </pre>
FloatLiteralWhole :: a -> NonEmpty DecDigit -> FloatExponent -> FloatLiteral a
[_floatLiteralAnn] :: FloatLiteral a -> 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 :: a -> NonEmpty DecDigit -> Bool -> ImagLiteral a
[_imagLiteralAnn] :: ImagLiteral a -> 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 :: a -> FloatLiteral a -> Bool -> ImagLiteral a
[_imagLiteralAnn] :: ImagLiteral a -> 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 Data.Functor.Classes.Eq1 Language.Python.Syntax.Numbers.ImagLiteral
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 Data.Functor.Classes.Eq1 Language.Python.Syntax.Numbers.FloatLiteral
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.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.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.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 Data.Functor.Classes.Eq1 Language.Python.Syntax.Numbers.IntLiteral
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 :: a -> [Whitespace] -> Maybe (Comment a) -> Blank a
[_blankAnn] :: Blank a -> 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] -> a -> Indents a
[_indentsValue] :: Indents a -> [Indent]
[_indentsAnn] :: Indents a -> a
indentsValue :: forall a_av5Q. Lens' (Indents a_av5Q) [Indent]
indentsAnn :: forall a_av5Q a_awRJ. Lens (Indents a_av5Q) (Indents a_awRJ) a_av5Q a_awRJ

-- | 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 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 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 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.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 :: a -> RawStringPrefix -> StringType -> QuoteType -> [PyChar] -> [Whitespace] -> StringLiteral a
[_stringLiteralAnn] :: StringLiteral a -> a
[_unsafeRawStringLiteralPrefix] :: StringLiteral a -> RawStringPrefix
[_stringLiteralStringType] :: StringLiteral a -> StringType
[_stringLiteralQuoteType] :: StringLiteral a -> QuoteType
[_stringLiteralValue] :: StringLiteral a -> [PyChar]
[_stringLiteralWhitespace] :: StringLiteral a -> [Whitespace]
StringLiteral :: a -> Maybe StringPrefix -> StringType -> QuoteType -> [PyChar] -> [Whitespace] -> StringLiteral a
[_stringLiteralAnn] :: StringLiteral a -> a
[_unsafeStringLiteralPrefix] :: StringLiteral a -> Maybe StringPrefix
[_stringLiteralStringType] :: StringLiteral a -> StringType
[_stringLiteralQuoteType] :: StringLiteral a -> QuoteType
[_stringLiteralValue] :: StringLiteral a -> [PyChar]
[_stringLiteralWhitespace] :: StringLiteral a -> [Whitespace]
RawBytesLiteral :: a -> RawBytesPrefix -> StringType -> QuoteType -> [PyChar] -> [Whitespace] -> StringLiteral a
[_stringLiteralAnn] :: StringLiteral a -> a
[_unsafeRawBytesLiteralPrefix] :: StringLiteral a -> RawBytesPrefix
[_stringLiteralStringType] :: StringLiteral a -> StringType
[_stringLiteralQuoteType] :: StringLiteral a -> QuoteType
[_stringLiteralValue] :: StringLiteral a -> [PyChar]
[_stringLiteralWhitespace] :: StringLiteral a -> [Whitespace]
BytesLiteral :: a -> BytesPrefix -> StringType -> QuoteType -> [PyChar] -> [Whitespace] -> StringLiteral a
[_stringLiteralAnn] :: StringLiteral a -> a
[_unsafeBytesLiteralPrefix] :: StringLiteral a -> BytesPrefix
[_stringLiteralStringType] :: StringLiteral a -> StringType
[_stringLiteralQuoteType] :: StringLiteral a -> QuoteType
[_stringLiteralValue] :: StringLiteral a -> [PyChar]
[_stringLiteralWhitespace] :: StringLiteral a -> [Whitespace]
stringLiteralStringType :: forall a_aAPr. Lens' (StringLiteral a_aAPr) StringType
stringLiteralQuoteType :: forall a_aAPr. Lens' (StringLiteral a_aAPr) QuoteType
stringLiteralValue :: forall a_aAPr. Lens' (StringLiteral a_aAPr) [PyChar]
stringLiteralWhitespace :: forall a_aAPr. Lens' (StringLiteral a_aAPr) [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 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.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.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.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.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.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.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.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.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.
data Dot
MkDot :: [Whitespace] -> Dot

-- | The venerable comma separator
newtype Comma
MkComma :: [Whitespace] -> Comma
newtype Colon
MkColon :: [Whitespace] -> Colon
data Semicolon a
MkSemicolon :: 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 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.Show.Show Language.Python.Syntax.Punctuation.Colon
instance GHC.Classes.Eq Language.Python.Syntax.Punctuation.Colon
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.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 :: a -> [Whitespace] -> UnOp a

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

-- | <pre>
--   ~a
--   </pre>
Complement :: a -> [Whitespace] -> 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.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>
--   
--   The type variable allows annotations, but it can simply be made
--   <tt>()</tt> for an unannotated <tt>BinOp</tt>.
data BinOp a

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | <tt>a </tt> b@
At :: 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 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.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 :: a -> String -> [Whitespace] -> Ident a
[_identAnn] :: Ident a -> 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 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 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 :: a -> Ident v a -> ModuleName v a
ModuleNameMany :: 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 :: [Dot] -> ModuleName v a -> RelativeModuleName v a
Relative :: NonEmpty Dot -> RelativeModuleName v a

-- | Convenience constructor for <a>ModuleName</a>
makeModuleName :: Ident v a -> [([Whitespace], Ident v a)] -> ModuleName v a

-- | Get the annotation from a <a>ModuleName</a>
_moduleNameAnn :: ModuleName v a -> 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 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.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.ModuleNames.RelativeModuleName v a)
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 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 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 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 :: a -> e a -> Maybe (NonEmpty Whitespace, Ident v a) -> ImportAs e v a
[_importAsAnn] :: ImportAs e v a -> a
[_importAsName] :: ImportAs e v a -> e 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 :: a -> [Whitespace] -> ImportTargets v a

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

-- | <pre>
--   from x import (a, b, c)
--   </pre>
ImportSomeParens :: a -> [Whitespace] -> CommaSep1' (ImportAs (Ident v) v a) -> [Whitespace] -> ImportTargets v a
importAsAnn :: Lens' (ImportAs e v a) a
importAsName :: Lens (ImportAs e v a) (ImportAs e' '[] a) (e a) (e' a)
importAsQual :: Lens (ImportAs e v a) (ImportAs e '[] a) (Maybe (NonEmpty Whitespace, Ident v a)) (Maybe (NonEmpty Whitespace, Ident '[] 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 Data.Traversable.Traversable e => Data.Traversable.Traversable (Language.Python.Syntax.Import.ImportAs e v)
instance Data.Foldable.Foldable e => Data.Foldable.Foldable (Language.Python.Syntax.Import.ImportAs e v)
instance GHC.Base.Functor e => GHC.Base.Functor (Language.Python.Syntax.Import.ImportAs e v)
instance (GHC.Show.Show a, GHC.Show.Show (e a)) => GHC.Show.Show (Language.Python.Syntax.Import.ImportAs e v a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq (e a)) => GHC.Classes.Eq (Language.Python.Syntax.Import.ImportAs e v a)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Import.ImportTargets v a)
instance Language.Python.Optics.Validated.Validated (Language.Python.Syntax.Import.ImportAs e)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (e 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 :: a -> [Whitespace] -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> CommaSep (Param v a) -> Colon -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> CommaSep (Expr v a) -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> [Whitespace] -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> Expr v a -> [Whitespace] -> Expr v a -> [Whitespace] -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> Comprehension Expr v a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> Maybe (CommaSep1' (ListItem v a)) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> Comprehension DictItem v a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> Maybe (CommaSep1' (DictItem v a)) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> Comprehension SetItem v a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> CommaSep1' (SetItem v a) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> Expr v a -> [Whitespace] -> Ident v a -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> Expr v a -> [Whitespace] -> CommaSep1' (Subscript v a) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> Expr v a -> [Whitespace] -> Maybe (CommaSep1' (Arg v a)) -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeNoneWhitespace] :: Expr a -> [Whitespace]

-- | <pre>
--   ...
--   </pre>
--   
--   <a>https://docs.python.org/3/library/constants.html#Ellipsis</a>
Ellipsis :: a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> Expr v a -> BinOp a -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> UnOp a -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeUnOpOp] :: Expr a -> UnOp a
[_unsafeUnOpValue] :: Expr a -> Expr v a
Parens :: a -> [Whitespace] -> Expr v a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: Ident v a -> Expr 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 :: a -> IntLiteral a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> FloatLiteral a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> ImagLiteral a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> Bool -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> NonEmpty (StringLiteral a) -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> TupleItem v a -> Comma -> Maybe (CommaSep1' (TupleItem v a)) -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> [Whitespace] -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> 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 :: a -> Comprehension Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_generatorValue] :: Expr a -> Comprehension Expr v a

-- | <pre>
--   await a
--   </pre>
--   
--   <a>https://docs.python.org/3/reference/expressions.html#await</a>
Await :: a -> [Whitespace] -> Expr v a -> Expr a
[_unsafeExprAnn] :: Expr a -> 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)

-- | Lens on the top-level annotation in an expression
exprAnn :: Lens' (Expr v a) 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 :: a -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> a
[_paramName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)

-- | <pre>
--   def foo(bar=None):
--   </pre>
KeywordParam :: a -> Ident v a -> Maybe (Colon, Expr v a) -> [Whitespace] -> Expr v a -> Param a
[_paramAnn] :: Param a -> 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 :: a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> a
[_unsafeStarParamWhitespace] :: Param a -> [Whitespace]
[_unsafeStarParamName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)

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

-- | <pre>
--   def foo(**dict):
--   </pre>
DoubleStarParam :: a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> 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 :: a -> Expr v a -> Arg a
[_argAnn] :: Arg a -> a
[_argExpr] :: Arg a -> Expr v a
KeywordArg :: a -> Ident v a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> a
[_unsafeKeywordArgName] :: Arg a -> Ident v a
[_unsafeKeywordArgWhitespaceRight] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a
StarArg :: a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> a
[_unsafeStarArgWhitespace] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a
DoubleStarArg :: a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> 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 :: 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 :: 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 :: 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 :: a -> Expr v a -> Colon -> Expr v a -> DictItem a
[_dictItemAnn] :: DictItem a -> a
[_unsafeDictItemKey] :: DictItem a -> Expr v a
[_unsafeDictItemColon] :: DictItem a -> Colon
[_unsafeDictItemValue] :: DictItem a -> Expr v a
DictUnpack :: a -> [Whitespace] -> Expr v a -> DictItem a
[_dictItemAnn] :: DictItem a -> 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 :: a -> Expr v a -> ListItem a
[_listItemAnn] :: ListItem a -> a
[_unsafeListItemValue] :: ListItem a -> Expr v a
ListUnpack :: a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> ListItem a
[_listItemAnn] :: ListItem a -> 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 :: a -> Expr v a -> SetItem a
[_setItemAnn] :: SetItem a -> a
[_unsafeSetItemValue] :: SetItem a -> Expr v a
SetUnpack :: a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> SetItem a
[_setItemAnn] :: SetItem a -> 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 :: a -> Expr v a -> TupleItem a
[_tupleItemAnn] :: TupleItem a -> a
[_unsafeTupleItemValue] :: TupleItem a -> Expr v a
TupleUnpack :: a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> TupleItem a
[_tupleItemAnn] :: TupleItem a -> 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 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 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 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 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.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 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 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 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 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 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 Data.String.IsString (Language.Python.Syntax.Expr.Param '[] ())
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.Param v a)
instance Data.String.IsString (Language.Python.Syntax.Expr.Arg '[] ())
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.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.CompIf v a)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.CompFor v a)
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.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.ListItem v a)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.SetItem v a)
instance Language.Python.Syntax.Whitespace.HasTrailingWhitespace (Language.Python.Syntax.Expr.TupleItem v a)
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 :: AugAssignOp -> a -> [Whitespace] -> AugAssign a
[_augAssignType] :: AugAssign a -> AugAssignOp
[_augAssignAnn] :: AugAssign a -> a
[_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 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.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 :: a -> Indents a -> At -> Expr v a -> Maybe (Comment a) -> Newline -> [(Blank a, Newline)] -> Decorator a
[_decoratorAnn] :: Decorator a -> 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 :: 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 -> 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 :: 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 -> 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 :: a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> Maybe (Indents a, [Whitespace], Suite v a) -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> 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 :: 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 -> 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 :: a -> Indents a -> [Whitespace] -> Suite v a -> Indents a -> [Whitespace] -> Suite v a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> 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 :: 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 -> 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 :: 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 -> 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 :: a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> CommaSep1 (WithItem v a) -> Suite v a -> CompoundStatement a
[_csAnn] :: CompoundStatement a -> 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: a -> NonEmpty Whitespace -> CommaSep1 (ImportAs (ModuleName v) 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 :: 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 :: 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 :: 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 :: a -> Expr v a -> Maybe ([Whitespace], Expr v a) -> WithItem a
[_withItemAnn] :: WithItem a -> 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_a1Kcs a_a1Kct. Lens' (WithItem v_a1Kcs a_a1Kct) a_a1Kct
withItemValue :: forall v_a1Kcs a_a1Kct. Lens' (WithItem v_a1Kcs a_a1Kct) (Expr v_a1Kcs a_a1Kct)
withItemBinder :: forall v_a1Kcs a_a1Kct. Lens' (WithItem v_a1Kcs a_a1Kct) (Maybe ([Whitespace], Expr v_a1Kcs a_a1Kct))

-- | See
--   <a>https://docs.python.org/3.5/reference/compound_stmts.html#the-try-statement</a>
data ExceptAs (v :: [*]) a
ExceptAs :: a -> Expr v a -> Maybe ([Whitespace], Ident v a) -> ExceptAs a
[_exceptAsAnn] :: ExceptAs a -> 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_a1Kcw a_a1Kcx. Lens' (ExceptAs v_a1Kcw a_a1Kcx) a_a1Kcx
exceptAsExpr :: forall v_a1Kcw a_a1Kcx. Lens' (ExceptAs v_a1Kcw a_a1Kcx) (Expr v_a1Kcw a_a1Kcx)
exceptAsName :: forall v_a1Kcw a_a1Kcx. Lens' (ExceptAs v_a1Kcw a_a1Kcx) (Maybe ([Whitespace], Ident v_a1Kcw a_a1Kcx))

-- | A compound statement consists of one or more clauses. A clause
--   consists of a header and a suite.
data Suite (v :: [*]) a
SuiteOne :: a -> Colon -> SmallStatement v a -> Suite a
SuiteMany :: 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_a1KcH a_a1KcI. Lens' (Block v_a1KcH a_a1KcI) [(Blank a_a1KcI, Newline)]
blockHead :: forall v_a1KcH a_a1KcI. Lens' (Block v_a1KcH a_a1KcI) (Statement v_a1KcH a_a1KcI)
blockTail :: forall v_a1KcH a_a1KcI. Lens' (Block v_a1KcH a_a1KcI) [Either (Blank a_a1KcI, Newline) (Statement v_a1KcH a_a1KcI)]
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 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.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 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 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 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 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 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 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 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.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.Expr.HasExprs Language.Python.Syntax.Statement.Decorator
instance Language.Python.Optics.Validated.Validated Language.Python.Syntax.Statement.WithItem
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.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 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 :: a -> Ident v a -> Maybe (Colon, Expr v a) -> PositionalParam v a
[_ppAnn] :: PositionalParam v a -> a
[_ppName] :: PositionalParam v a -> Ident v a
[_ppType] :: PositionalParam v a -> Maybe (Colon, Expr v a)
ppAnn :: forall v_a2iUO a_a2iUP. Lens' (PositionalParam v_a2iUO a_a2iUP) a_a2iUP
ppName :: forall v_a2iUO a_a2iUP. Lens' (PositionalParam v_a2iUO a_a2iUP) (Ident v_a2iUO a_a2iUP)
ppType :: forall v_a2iUO a_a2iUP. Lens' (PositionalParam v_a2iUO a_a2iUP) (Maybe (Colon, Expr v_a2iUO a_a2iUP))
data StarParam v a
MkStarParam :: a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> StarParam v a
[_spAnn] :: StarParam v a -> 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_a2j1d a_a2j1e. Lens' (StarParam v_a2j1d a_a2j1e) a_a2j1e
spWhitespace :: forall v_a2j1d a_a2j1e. Lens' (StarParam v_a2j1d a_a2j1e) [Whitespace]
spName :: forall v_a2j1d a_a2j1e. Lens' (StarParam v_a2j1d a_a2j1e) (Ident v_a2j1d a_a2j1e)
spType :: forall v_a2j1d a_a2j1e. Lens' (StarParam v_a2j1d a_a2j1e) (Maybe (Colon, Expr v_a2j1d a_a2j1e))
data UnnamedStarParam (v :: [*]) a
MkUnnamedStarParam :: a -> [Whitespace] -> UnnamedStarParam a
[_uspAnn] :: UnnamedStarParam a -> a
[_uspWhitespace] :: UnnamedStarParam a -> [Whitespace]
uspAnn :: forall v_a2j79 a_a2j7a v_a2jc8 a_a2jc9. Lens (UnnamedStarParam v_a2j79 a_a2j7a) (UnnamedStarParam v_a2jc8 a_a2jc9) a_a2j7a a_a2jc9
uspWhitespace :: forall v_a2j79 a_a2j7a v_a2jca. Lens (UnnamedStarParam v_a2j79 a_a2j7a) (UnnamedStarParam v_a2jca a_a2j7a) [Whitespace] [Whitespace]
data KeywordParam v a
MkKeywordParam :: a -> Ident v a -> Maybe (Colon, Expr v a) -> [Whitespace] -> Expr v a -> KeywordParam v a
[_kpAnn] :: KeywordParam v a -> 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_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) a_a2iMG
kpName :: forall v_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) (Ident v_a2iMF a_a2iMG)
kpType :: forall v_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) (Maybe (Colon, Expr v_a2iMF a_a2iMG))
kpEquals :: forall v_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) [Whitespace]
kpExpr :: forall v_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) (Expr v_a2iMF a_a2iMG)
data Fundef v a
MkFundef :: 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 -> 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_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) a_a2im3
fdDecorators :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) [Decorator v_a2im2 a_a2im3]
fdIndents :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Indents a_a2im3)
fdAsync :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Maybe (NonEmpty Whitespace))
fdDefSpaces :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (NonEmpty Whitespace)
fdName :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Ident v_a2im2 a_a2im3)
fdLeftParenSpaces :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) [Whitespace]
fdParameters :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (CommaSep (Param v_a2im2 a_a2im3))
fdRightParenSpaces :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) [Whitespace]
fdReturnType :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Maybe ([Whitespace], Expr v_a2im2 a_a2im3))
fdBody :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Suite v_a2im2 a_a2im3)
data ClassDef v a
MkClassDef :: 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 -> 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_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) a_a2keL
cdDecorators :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) [Decorator v_a2keK a_a2keL]
cdIndents :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (Indents a_a2keL)
cdClass :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (NonEmpty Whitespace)
cdName :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (Ident v_a2keK a_a2keL)
cdArguments :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (Maybe ([Whitespace], Maybe (CommaSep1' (Arg v_a2keK a_a2keL)), [Whitespace]))
cdBody :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (Suite v_a2keK a_a2keL)
data If v a
MkIf :: a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> [Elif v a] -> Maybe (Else v a) -> If v a
[_ifAnn] :: If v a -> 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_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) a_a2jpA
ifIndents :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) (Indents a_a2jpA)
ifIf :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) [Whitespace]
ifCond :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) (Expr v_a2jpz a_a2jpA)
ifBody :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) (Suite v_a2jpz a_a2jpA)
ifElifs :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) [Elif v_a2jpz a_a2jpA]
ifElse :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) (Maybe (Else v_a2jpz a_a2jpA))
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_a2jiC a_a2jiD. Lens' (Elif v_a2jiC a_a2jiD) (Indents a_a2jiD)
elifElif :: forall v_a2jiC a_a2jiD. Lens' (Elif v_a2jiC a_a2jiD) [Whitespace]
elifCond :: forall v_a2jiC a_a2jiD. Lens' (Elif v_a2jiC a_a2jiD) (Expr v_a2jiC a_a2jiD)
elifBody :: forall v_a2jiC a_a2jiD. Lens' (Elif v_a2jiC a_a2jiD) (Suite v_a2jiC a_a2jiD)
data For v a
MkFor :: 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 -> 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_a2jxY a_a2jxZ. Lens' (For v_a2jxY a_a2jxZ) a_a2jxZ
forIndents :: forall v_a2jxY a_a2jxZ. Lens' (For v_a2jxY a_a2jxZ) (Indents a_a2jxZ)
forAsync :: forall v_a2jxY a_a2jxZ. Lens' (For v_a2jxY a_a2jxZ) (Maybe (NonEmpty Whitespace))
forFor :: forall v_a2jxY a_a2jxZ. Lens' (For v_a2jxY a_a2jxZ) [Whitespace]
forBinder :: forall v_a2jxY a_a2jxZ. Lens' (For v_a2jxY a_a2jxZ) (Expr v_a2jxY a_a2jxZ)
forIn :: forall v_a2jxY a_a2jxZ. Lens' (For v_a2jxY a_a2jxZ) [Whitespace]
forCollection :: forall v_a2jxY a_a2jxZ. Lens' (For v_a2jxY a_a2jxZ) (CommaSep1' (Expr v_a2jxY a_a2jxZ))
forBody :: forall v_a2jxY a_a2jxZ. Lens' (For v_a2jxY a_a2jxZ) (Suite v_a2jxY a_a2jxZ)
forElse :: forall v_a2jxY a_a2jxZ. Lens' (For v_a2jxY a_a2jxZ) (Maybe (Else v_a2jxY a_a2jxZ))
data While v a
MkWhile :: a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> Maybe (Else v a) -> While v a
[_whileAnn] :: While v a -> 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_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) a_a2iFx
whileIndents :: forall v_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) (Indents a_a2iFx)
whileWhile :: forall v_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) [Whitespace]
whileCond :: forall v_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) (Expr v_a2iFw a_a2iFx)
whileBody :: forall v_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) (Suite v_a2iFw a_a2iFx)
whileElse :: forall v_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) (Maybe (Else v_a2iFw a_a2iFx))
data TryExcept v a
MkTryExcept :: 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 -> 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_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) a_a2jXO
teIndents :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (Indents a_a2jXO)
teTry :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) [Whitespace]
teBody :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (Suite v_a2jXN a_a2jXO)
teExcepts :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (NonEmpty (Except v_a2jXN a_a2jXO))
teElse :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (Maybe (Else v_a2jXN a_a2jXO))
teFinally :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (Maybe (Finally v_a2jXN a_a2jXO))
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_a2jRM a_a2jRN. Lens' (Except v_a2jRM a_a2jRN) (Indents a_a2jRN)
exceptExcept :: forall v_a2jRM a_a2jRN. Lens' (Except v_a2jRM a_a2jRN) [Whitespace]
exceptExceptAs :: forall v_a2jRM a_a2jRN. Lens' (Except v_a2jRM a_a2jRN) (Maybe (ExceptAs v_a2jRM a_a2jRN))
exceptBody :: forall v_a2jRM a_a2jRN. Lens' (Except v_a2jRM a_a2jRN) (Suite v_a2jRM a_a2jRN)
data TryFinally v a
MkTryFinally :: a -> Indents a -> [Whitespace] -> Suite v a -> Finally v a -> TryFinally v a
[_tfAnn] :: TryFinally v a -> 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_a2k6c a_a2k6d. Lens' (TryFinally v_a2k6c a_a2k6d) a_a2k6d
tfIndents :: forall v_a2k6c a_a2k6d. Lens' (TryFinally v_a2k6c a_a2k6d) (Indents a_a2k6d)
tfTry :: forall v_a2k6c a_a2k6d. Lens' (TryFinally v_a2k6c a_a2k6d) [Whitespace]
tfBody :: forall v_a2k6c a_a2k6d. Lens' (TryFinally v_a2k6c a_a2k6d) (Suite v_a2k6c a_a2k6d)
tfFinally :: forall v_a2k6c a_a2k6d. Lens' (TryFinally v_a2k6c a_a2k6d) (Finally v_a2k6c a_a2k6d)
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_a2jJi a_a2jJj. Lens' (Finally v_a2jJi a_a2jJj) (Indents a_a2jJj)
finallyFinally :: forall v_a2jJi a_a2jJj. Lens' (Finally v_a2jJi a_a2jJj) [Whitespace]
finallyBody :: forall v_a2jJi a_a2jJj v_a2jRn. Lens (Finally v_a2jJi a_a2jJj) (Finally v_a2jRn a_a2jJj) (Suite v_a2jJi a_a2jJj) (Suite v_a2jRn a_a2jJj)
data With v a
MkWith :: a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> CommaSep1 (WithItem v a) -> Suite v a -> With v a
[_withAnn] :: With v a -> 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_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) a_a2knY
withIndents :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) (Indents a_a2knY)
withAsync :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) (Maybe (NonEmpty Whitespace))
withWith :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) [Whitespace]
withItems :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) (CommaSep1 (WithItem v_a2knX a_a2knY))
withBody :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) (Suite v_a2knX a_a2knY)
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_a2ivn a_a2ivo. Lens' (Else v_a2ivn a_a2ivo) (Indents a_a2ivo)
elseElse :: forall v_a2ivn a_a2ivo. Lens' (Else v_a2ivn a_a2ivo) [Whitespace]
elseBody :: forall v_a2ivn a_a2ivo v_a2iF5. Lens (Else v_a2ivn a_a2ivo) (Else v_a2iF5 a_a2ivo) (Suite v_a2ivn a_a2ivo) (Suite v_a2iF5 a_a2ivo)
data None (v :: [*]) a
MkNone :: a -> [Whitespace] -> None a
[_noneAnn] :: None a -> a
[_noneWhitespace] :: None a -> [Whitespace]
noneAnn :: forall v_a2kRA a_a2kRB v_a2kWD a_a2kWE. Lens (None v_a2kRA a_a2kRB) (None v_a2kWD a_a2kWE) a_a2kRB a_a2kWE
noneWhitespace :: forall v_a2kRA a_a2kRB v_a2kWF. Lens (None v_a2kRA a_a2kRB) (None v_a2kWF a_a2kRB) [Whitespace] [Whitespace]
data Call v a
MkCall :: a -> Expr v a -> [Whitespace] -> Maybe (CommaSep1' (Arg v a)) -> [Whitespace] -> Call v a
[_callAnn] :: Call v a -> 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_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) a_a2jct
callFunction :: forall v_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) (Expr v_a2jcs a_a2jct)
callLeftParen :: forall v_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) [Whitespace]
callArguments :: forall v_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) (Maybe (CommaSep1' (Arg v_a2jcs a_a2jct)))
callRightParen :: forall v_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) [Whitespace]
data Tuple v a
MkTuple :: a -> TupleItem v a -> Comma -> Maybe (CommaSep1' (TupleItem v a)) -> Tuple v a
[_tupleAnn] :: Tuple v a -> 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_a2kxd a_a2kxe. Lens' (Tuple v_a2kxd a_a2kxe) a_a2kxe
tupleHead :: forall v_a2kxd a_a2kxe. Lens' (Tuple v_a2kxd a_a2kxe) (TupleItem v_a2kxd a_a2kxe)
tupleComma :: forall v_a2kxd a_a2kxe. Lens' (Tuple v_a2kxd a_a2kxe) Comma
tupleTail :: forall v_a2kxd a_a2kxe. Lens' (Tuple v_a2kxd a_a2kxe) (Maybe (CommaSep1' (TupleItem v_a2kxd a_a2kxe)))
data TupleUnpack v a
MkTupleUnpack :: a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> TupleUnpack v a
[_tupleUnpackAnn] :: TupleUnpack v a -> a
[_tupleUnpackParens] :: TupleUnpack v a -> [([Whitespace], [Whitespace])]
[_tupleUnpackWhitespace] :: TupleUnpack v a -> [Whitespace]
[_tupleUnpackValue] :: TupleUnpack v a -> Expr v a
tupleUnpackAnn :: forall v_a2kWW a_a2kWX. Lens' (TupleUnpack v_a2kWW a_a2kWX) a_a2kWX
tupleUnpackParens :: forall v_a2kWW a_a2kWX. Lens' (TupleUnpack v_a2kWW a_a2kWX) [([Whitespace], [Whitespace])]
tupleUnpackWhitespace :: forall v_a2kWW a_a2kWX. Lens' (TupleUnpack v_a2kWW a_a2kWX) [Whitespace]
tupleUnpackValue :: forall v_a2kWW a_a2kWX v_a2l21. Lens (TupleUnpack v_a2kWW a_a2kWX) (TupleUnpack v_a2l21 a_a2kWX) (Expr v_a2kWW a_a2kWX) (Expr v_a2l21 a_a2kWX)
data List v a
MkList :: a -> [Whitespace] -> Maybe (CommaSep1' (ListItem v a)) -> [Whitespace] -> List v a
[_listAnn] :: List v a -> a
[_listWhitespaceLeft] :: List v a -> [Whitespace]
[_listBody] :: List v a -> Maybe (CommaSep1' (ListItem v a))
[_listWhitespaceRight] :: List v a -> [Whitespace]
listAnn :: forall v_a2kEA a_a2kEB. Lens' (List v_a2kEA a_a2kEB) a_a2kEB
listWhitespaceLeft :: forall v_a2kEA a_a2kEB. Lens' (List v_a2kEA a_a2kEB) [Whitespace]
listBody :: forall v_a2kEA a_a2kEB v_a2kKt. Lens (List v_a2kEA a_a2kEB) (List v_a2kKt a_a2kEB) (Maybe (CommaSep1' (ListItem v_a2kEA a_a2kEB))) (Maybe (CommaSep1' (ListItem v_a2kKt a_a2kEB)))
listWhitespaceRight :: forall v_a2kEA a_a2kEB. Lens' (List v_a2kEA a_a2kEB) [Whitespace]
data ListUnpack v a
MkListUnpack :: a -> [([Whitespace], [Whitespace])] -> [Whitespace] -> Expr v a -> ListUnpack v a
[_listUnpackAnn] :: ListUnpack v a -> a
[_listUnpackParens] :: ListUnpack v a -> [([Whitespace], [Whitespace])]
[_listUnpackWhitespace] :: ListUnpack v a -> [Whitespace]
[_listUnpackValue] :: ListUnpack v a -> Expr v a
listUnpackAnn :: forall v_a2kL2 a_a2kL3. Lens' (ListUnpack v_a2kL2 a_a2kL3) a_a2kL3
listUnpackParens :: forall v_a2kL2 a_a2kL3. Lens' (ListUnpack v_a2kL2 a_a2kL3) [([Whitespace], [Whitespace])]
listUnpackWhitespace :: forall v_a2kL2 a_a2kL3. Lens' (ListUnpack v_a2kL2 a_a2kL3) [Whitespace]
listUnpackValue :: forall v_a2kL2 a_a2kL3 v_a2kR3. Lens (ListUnpack v_a2kL2 a_a2kL3) (ListUnpack v_a2kR3 a_a2kL3) (Expr v_a2kL2 a_a2kL3) (Expr v_a2kR3 a_a2kL3)
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 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 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 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 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 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 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 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 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.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.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 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 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.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 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 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 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 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 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 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.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 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 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


-- | 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 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.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)
_Ident :: Prism (Expr v a) (Expr '[] a) (Ident v a) (Ident '[] 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
[_unsafeExprAnn] :: Expr a -> a
[_unsafeStarExprWhitespace] :: Expr a -> [Whitespace]
[_unsafeStarExprValue] :: Expr a -> Expr a
Unit :: a -> [Whitespace] -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeUnitWhitespaceInner] :: Expr a -> [Whitespace]
[_unsafeUnitWhitespaceRight] :: Expr a -> [Whitespace]
Lambda :: a -> [Whitespace] -> CommaSep (Param a) -> Colon -> Expr a -> Expr a
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: Expr a -> a
[_unsafeYieldWhitespace] :: Expr a -> [Whitespace]
[_unsafeYieldValue] :: Expr a -> CommaSep (Expr a)
YieldFrom :: a -> [Whitespace] -> [Whitespace] -> Expr a -> Expr a
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: Expr a -> a
[_unsafeNoneWhitespace] :: Expr a -> [Whitespace]
Ellipsis :: a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeEllipsisWhitespace] :: Expr a -> [Whitespace]
BinOp :: a -> Expr a -> BinOp a -> Expr a -> Expr a
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: Expr a -> a
[_unsafeUnOpOp] :: Expr a -> UnOp a
[_unsafeUnOpValue] :: Expr a -> Expr a
Parens :: a -> [Whitespace] -> Expr a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeParensWhitespaceLeft] :: Expr a -> [Whitespace]
[_unsafeParensValue] :: Expr a -> Expr a
[_unsafeParensWhitespaceAfter] :: Expr a -> [Whitespace]
Ident :: Ident '[] a -> Expr a
[_unsafeIdentValue] :: Expr a -> Ident '[] a
Int :: a -> IntLiteral a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeIntValue] :: Expr a -> IntLiteral a
[_unsafeIntWhitespace] :: Expr a -> [Whitespace]
Float :: a -> FloatLiteral a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeFloatValue] :: Expr a -> FloatLiteral a
[_unsafeFloatWhitespace] :: Expr a -> [Whitespace]
Imag :: a -> ImagLiteral a -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeImagValue] :: Expr a -> ImagLiteral a
[_unsafeImagWhitespace] :: Expr a -> [Whitespace]
Bool :: a -> Bool -> [Whitespace] -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeBoolValue] :: Expr a -> Bool
[_unsafeBoolWhitespace] :: Expr a -> [Whitespace]
String :: a -> NonEmpty (StringLiteral a) -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_unsafeStringLiteralValue] :: Expr a -> NonEmpty (StringLiteral a)
Tuple :: a -> Expr a -> Comma -> Maybe (CommaSep1' (Expr a)) -> Expr a
[_unsafeExprAnn] :: 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
[_unsafeExprAnn] :: Expr a -> a
[_unsafeNotWhitespace] :: Expr a -> [Whitespace]
[_unsafeNotValue] :: Expr a -> Expr a
Generator :: a -> Comprehension Expr a -> Expr a
[_unsafeExprAnn] :: Expr a -> a
[_generatorValue] :: Expr a -> Comprehension Expr a
Await :: a -> [Whitespace] -> Expr a -> Expr a
[_unsafeExprAnn] :: 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 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)
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 :: a -> String -> [Whitespace] -> Ident a
[_identAnn] :: Ident a -> 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 :: a -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> a
[_paramName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)

-- | <pre>
--   def foo(bar=None):
--   </pre>
KeywordParam :: a -> Ident v a -> Maybe (Colon, Expr v a) -> [Whitespace] -> Expr v a -> Param a
[_paramAnn] :: Param a -> 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 :: a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> a
[_unsafeStarParamWhitespace] :: Param a -> [Whitespace]
[_unsafeStarParamName] :: Param a -> Ident v a
[_paramType] :: Param a -> Maybe (Colon, Expr v a)

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

-- | <pre>
--   def foo(**dict):
--   </pre>
DoubleStarParam :: a -> [Whitespace] -> Ident v a -> Maybe (Colon, Expr v a) -> Param a
[_paramAnn] :: Param a -> 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 :: a -> Expr v a -> Arg a
[_argAnn] :: Arg a -> a
[_argExpr] :: Arg a -> Expr v a
KeywordArg :: a -> Ident v a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> a
[_unsafeKeywordArgName] :: Arg a -> Ident v a
[_unsafeKeywordArgWhitespaceRight] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a
StarArg :: a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> a
[_unsafeStarArgWhitespace] :: Arg a -> [Whitespace]
[_argExpr] :: Arg a -> Expr v a
DoubleStarArg :: a -> [Whitespace] -> Expr v a -> Arg a
[_argAnn] :: Arg a -> 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 :: a -> Ident v a -> Maybe (Colon, Expr v a) -> PositionalParam v a
[_ppAnn] :: PositionalParam v a -> 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_a2iUO a_a2iUP. Lens' (PositionalParam v_a2iUO a_a2iUP) a_a2iUP
ppName :: forall v_a2iUO a_a2iUP. Lens' (PositionalParam v_a2iUO a_a2iUP) (Ident v_a2iUO a_a2iUP)
ppType :: forall v_a2iUO a_a2iUP. Lens' (PositionalParam v_a2iUO a_a2iUP) (Maybe (Colon, Expr v_a2iUO a_a2iUP))

-- | 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 :: a -> Ident v a -> Maybe (Colon, Expr v a) -> [Whitespace] -> Expr v a -> KeywordParam v a
[_kpAnn] :: KeywordParam v a -> 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_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) a_a2iMG
kpName :: forall v_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) (Ident v_a2iMF a_a2iMG)
kpType :: forall v_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) (Maybe (Colon, Expr v_a2iMF a_a2iMG))
kpEquals :: forall v_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) [Whitespace]
kpExpr :: forall v_a2iMF a_a2iMG. Lens' (KeywordParam v_a2iMF a_a2iMG) (Expr v_a2iMF a_a2iMG)
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 :: 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 -> 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_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) a_a2im3
fdDecorators :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) [Decorator v_a2im2 a_a2im3]
fdIndents :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Indents a_a2im3)
fdAsync :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Maybe (NonEmpty Whitespace))
fdDefSpaces :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (NonEmpty Whitespace)
fdName :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Ident v_a2im2 a_a2im3)
fdLeftParenSpaces :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) [Whitespace]
fdParameters :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (CommaSep (Param v_a2im2 a_a2im3))
fdRightParenSpaces :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) [Whitespace]
fdReturnType :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Maybe ([Whitespace], Expr v_a2im2 a_a2im3))
fdBody :: forall v_a2im2 a_a2im3. Lens' (Fundef v_a2im2 a_a2im3) (Suite v_a2im2 a_a2im3)

-- | <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 :: 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 -> 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_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) a_a2keL
cdDecorators :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) [Decorator v_a2keK a_a2keL]
cdIndents :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (Indents a_a2keL)
cdClass :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (NonEmpty Whitespace)
cdName :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (Ident v_a2keK a_a2keL)
cdArguments :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (Maybe ([Whitespace], Maybe (CommaSep1' (Arg v_a2keK a_a2keL)), [Whitespace]))
cdBody :: forall v_a2keK a_a2keL. Lens' (ClassDef v_a2keK a_a2keL) (Suite v_a2keK a_a2keL)

-- | 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 :: 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 -> 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 :: a -> Indents a -> [Whitespace] -> Suite v a -> Finally v a -> TryFinally v a
[_tfAnn] :: TryFinally v a -> 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 :: a -> Expr v a -> Maybe ([Whitespace], Ident v a) -> ExceptAs a
[_exceptAsAnn] :: ExceptAs a -> 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_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) a_a2jXO
teIndents :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (Indents a_a2jXO)
teTry :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) [Whitespace]
teBody :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (Suite v_a2jXN a_a2jXO)
teExcepts :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (NonEmpty (Except v_a2jXN a_a2jXO))
teElse :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (Maybe (Else v_a2jXN a_a2jXO))
teFinally :: forall v_a2jXN a_a2jXO. Lens' (TryExcept v_a2jXN a_a2jXO) (Maybe (Finally v_a2jXN a_a2jXO))
exceptIndents :: forall v_a2jRM a_a2jRN. Lens' (Except v_a2jRM a_a2jRN) (Indents a_a2jRN)
exceptExcept :: forall v_a2jRM a_a2jRN. Lens' (Except v_a2jRM a_a2jRN) [Whitespace]
exceptExceptAs :: forall v_a2jRM a_a2jRN. Lens' (Except v_a2jRM a_a2jRN) (Maybe (ExceptAs v_a2jRM a_a2jRN))
exceptBody :: forall v_a2jRM a_a2jRN. Lens' (Except v_a2jRM a_a2jRN) (Suite v_a2jRM a_a2jRN)
finallyIndents :: forall v_a2jJi a_a2jJj. Lens' (Finally v_a2jJi a_a2jJj) (Indents a_a2jJj)
finallyFinally :: forall v_a2jJi a_a2jJj. Lens' (Finally v_a2jJi a_a2jJj) [Whitespace]
finallyBody :: forall v_a2jJi a_a2jJj v_a2jRn. Lens (Finally v_a2jJi a_a2jJj) (Finally v_a2jRn a_a2jJj) (Suite v_a2jJi a_a2jJj) (Suite v_a2jRn a_a2jJj)

-- | <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 :: a -> Indents a -> Maybe (NonEmpty Whitespace) -> [Whitespace] -> CommaSep1 (WithItem v a) -> Suite v a -> With v a
[_withAnn] :: With v a -> 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 :: a -> Expr v a -> Maybe ([Whitespace], Expr v a) -> WithItem a
[_withItemAnn] :: WithItem a -> 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_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) a_a2knY
withIndents :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) (Indents a_a2knY)
withAsync :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) (Maybe (NonEmpty Whitespace))
withWith :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) [Whitespace]
withItems :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) (CommaSep1 (WithItem v_a2knX a_a2knY))
withBody :: forall v_a2knX a_a2knY. Lens' (With v_a2knX a_a2knY) (Suite v_a2knX a_a2knY)
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 :: 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 -> 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 :: a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> [Elif v a] -> Maybe (Else v a) -> If v a
[_ifAnn] :: If v a -> 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_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) a_a2jpA
ifIndents :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) (Indents a_a2jpA)
ifIf :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) [Whitespace]
ifCond :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) (Expr v_a2jpz a_a2jpA)
ifBody :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) (Suite v_a2jpz a_a2jpA)
ifElifs :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) [Elif v_a2jpz a_a2jpA]
ifElse :: forall v_a2jpz a_a2jpA. Lens' (If v_a2jpz a_a2jpA) (Maybe (Else v_a2jpz a_a2jpA))
elifIndents :: forall v_a2jiC a_a2jiD. Lens' (Elif v_a2jiC a_a2jiD) (Indents a_a2jiD)
elifElif :: forall v_a2jiC a_a2jiD. Lens' (Elif v_a2jiC a_a2jiD) [Whitespace]
elifCond :: forall v_a2jiC a_a2jiD. Lens' (Elif v_a2jiC a_a2jiD) (Expr v_a2jiC a_a2jiD)
elifBody :: forall v_a2jiC a_a2jiD. Lens' (Elif v_a2jiC a_a2jiD) (Suite v_a2jiC a_a2jiD)
elseIndents :: forall v_a2ivn a_a2ivo. Lens' (Else v_a2ivn a_a2ivo) (Indents a_a2ivo)
elseElse :: forall v_a2ivn a_a2ivo. Lens' (Else v_a2ivn a_a2ivo) [Whitespace]
elseBody :: forall v_a2ivn a_a2ivo v_a2iF5. Lens (Else v_a2ivn a_a2ivo) (Else v_a2iF5 a_a2ivo) (Suite v_a2ivn a_a2ivo) (Suite v_a2iF5 a_a2ivo)

-- | <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 :: a -> Indents a -> [Whitespace] -> Expr v a -> Suite v a -> Maybe (Else v a) -> While v a
[_whileAnn] :: While v a -> 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_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) a_a2iFx
whileIndents :: forall v_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) (Indents a_a2iFx)
whileWhile :: forall v_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) [Whitespace]
whileCond :: forall v_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) (Expr v_a2iFw a_a2iFx)
whileBody :: forall v_a2iFw a_a2iFx. Lens' (While v_a2iFw a_a2iFx) (Suite v_a2iFw a_a2iFx)

-- | 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 :: a -> TupleItem v a -> Comma -> Maybe (CommaSep1' (TupleItem v a)) -> Tuple v a
[_tupleAnn] :: Tuple v a -> 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 :: a -> Expr v a -> [Whitespace] -> Maybe (CommaSep1' (Arg v a)) -> [Whitespace] -> Call v a
[_callAnn] :: Call v a -> 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_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) a_a2jct
callFunction :: forall v_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) (Expr v_a2jcs a_a2jct)
callLeftParen :: forall v_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) [Whitespace]
callArguments :: forall v_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) (Maybe (CommaSep1' (Arg v_a2jcs a_a2jct)))
callRightParen :: forall v_a2jcs a_a2jct. Lens' (Call v_a2jcs a_a2jct) [Whitespace]

-- | <pre>
--   &gt;&gt;&gt; none_
--   None
--   </pre>
none_ :: Raw Expr
data None (v :: [*]) a
MkNone :: a -> [Whitespace] -> None a
[_noneAnn] :: None a -> a
[_noneWhitespace] :: None a -> [Whitespace]
_None :: Prism (Expr v a) (Expr '[] a) (None v a) (None '[] a)
noneAnn :: forall v_a2kRA a_a2kRB v_a2kWD a_a2kWE. Lens (None v_a2kRA a_a2kRB) (None v_a2kWD a_a2kWE) a_a2kRB a_a2kWE
noneWhitespace :: forall v_a2kRA a_a2kRB v_a2kWF. Lens (None v_a2kRA a_a2kRB) (None v_a2kWF a_a2kRB) [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_a4JhC a_a4Jc4 | r_a4JhC -> a_a4Jc4
_ScopeError :: AsScopeError r_a4JhC a_a4Jc4 => Prism' r_a4JhC (ScopeError a_a4Jc4)
_FoundNonlocal :: AsScopeError r_a4JhC a_a4Jc4 => Prism' r_a4JhC a_a4Jc4
_FoundGlobal :: AsScopeError r_a4JhC a_a4Jc4 => Prism' r_a4JhC a_a4Jc4
_DeletedIdent :: AsScopeError r_a4JhC a_a4Jc4 => Prism' r_a4JhC a_a4Jc4
_FoundDynamic :: AsScopeError r_a4JhC a_a4Jc4 => Prism' r_a4JhC (a_a4Jc4, Ident ('[] :: [Type]) a_a4Jc4)
_NotInScope :: AsScopeError r_a4JhC a_a4Jc4 => Prism' r_a4JhC (Ident ('[] :: [Type]) a_a4Jc4)
_BadShadowing :: AsScopeError r_a4JhC a_a4Jc4 => Prism' r_a4JhC (Ident ('[] :: [Type]) a_a4Jc4)
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_a4KxZ. Lens' (ScopeContext a_a4KxZ) (Map ByteString a_a4KxZ)
scLocalScope :: forall a_a4KxZ. Lens' (ScopeContext a_a4KxZ) (Map ByteString a_a4KxZ)
scImmediateScope :: forall a_a4KxZ. Lens' (ScopeContext a_a4KxZ) (Map ByteString a_a4KxZ)
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_a4UZX a_a4UAh | r_a4UZX -> a_a4UAh
_SyntaxError :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (SyntaxError a_a4UAh)
_PositionalAfterKeywordArg :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, Expr ('[] :: [Type]) a_a4UAh)
_PositionalAfterKeywordUnpacking :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, Expr ('[] :: [Type]) a_a4UAh)
_CannotAssignTo :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, Expr ('[] :: [Type]) a_a4UAh)
_CannotDelete :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, Expr ('[] :: [Type]) a_a4UAh)
_CannotAugAssignTo :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, Expr ('[] :: [Type]) a_a4UAh)
_NoBindingNonlocal :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (Ident ('[] :: [Type]) a_a4UAh)
_PositionalAfterKeywordParam :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, String)
_UnexpectedDoubleStarParam :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, String)
_DuplicateArgument :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, String)
_UnexpectedNewline :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_UnexpectedComment :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_IdentifierReservedWord :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, String)
_EmptyIdentifier :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_BadCharacter :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, String)
_BreakOutsideLoop :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_ContinueOutsideLoop :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_ReturnOutsideFunction :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_NonlocalOutsideFunction :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_ParametersNonlocal :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, [String])
_Can'tJoinStringAndBytes :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_YieldOutsideGenerator :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_MalformedDecorator :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_InvalidDictUnpacking :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_InvalidSetUnpacking :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_TypedParamInLambda :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_AsyncWithOutsideCoroutine :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_AsyncForOutsideCoroutine :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_YieldFromInsideCoroutine :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_YieldInsideCoroutine :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_AwaitOutsideCoroutine :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_AwaitInsideComprehension :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_NullByte :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_NonAsciiInBytes :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, Char)
_DefaultExceptMustBeLast :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_WildcardImportInDefinition :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_NoKeywordsAfterEmptyStarArg :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_ManyStarredTargets :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_ManyStarredParams :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_ContinueInsideFinally :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX a_a4UAh
_ParameterMarkedGlobal :: AsSyntaxError r_a4UZX a_a4UAh => Prism' r_a4UZX (a_a4UAh, 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 a -> ValidateSyntax e (t' 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 :: (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