pyre-ast 0.1.2 · OCaml Package

This module provides a type that represents a Python expression.

type ('arguments, 'bin_op, 'bool_op, 'compare, 'comprehension, 'constant, 'expr_context, 'identifier, 'keyword, 'location, 'unary_op, 'expr)
  t =
  private {

bool_op : location:'location -> op:'bool_op -> values:'expr list -> 'expr;
(*
Represents a boolean expression.
- Example: a and b
- Example: a or b or c
*)
named_expr : location:'location -> target:'expr -> value:'expr -> 'expr;
(*
Represents an assignment expression, a.k.a. the "walrus" operator. See PEP 572.
- Example: (a := b)
*)
bin_op : location:'location -> left:'expr -> op:'bin_op -> right:'expr -> 'expr;
(*
Represents a numerical binary expression.
- Example: a + b
*)
unary_op : location:'location -> op:'unary_op -> operand:'expr -> 'expr;
(*
Represents an unary expression.
- Example: not a
*)
lambda : location:'location -> args:'arguments -> body:'expr -> 'expr;
(*
Represents a lambda expression. See PEP 312.
- Example: lambda x, /, y, *, z: x + y + z
*)
if_exp : location:'location -> test:'expr -> body:'expr -> orelse:'expr -> 'expr;
(*
Represents a conditional expression. See PEP 308.
- Example: x if x > 0 else None
*)
dict : location:'location -> keys:'expr option list -> values:'expr list -> 'expr;
(*
Represents a Python dictionary display.
- Example: {}
- Example: { "a": 1, "b": 2 }
- Example: { "a": 1, **b }. The element **b here will be represented with a None key and a value of b.
*)
set : location:'location -> elts:'expr list -> 'expr;
(*
Represents a Python set display.
- Example: { "a", "b" }
*)
list_comp : location:'location -> elt:'expr -> generators:'comprehension list -> 'expr;
(*
Represents a list comprehension.
- Example: [y for x in l if len(x) > 1 for y in x if y < 4]
*)
set_comp : location:'location -> elt:'expr -> generators:'comprehension list -> 'expr;
(*
Represents a set comprehension.
- Example: {x for x in l}
*)
dict_comp : location:'location -> key:'expr -> value:'expr -> generators:'comprehension list -> 'expr;
(*
Represents a dict comprehension.
- Example: {x:y for x, y in l}
*)
generator_exp : location:'location -> elt:'expr -> generators:'comprehension list -> 'expr;
(*
Represents a generator expression.
- Example: (x for x in l)
*)
await : location:'location -> value:'expr -> 'expr;
(*
Represents an await expression.
- Example: await foo
*)
yield : location:'location -> value:'expr option -> 'expr;
(*
Represents a yield expression.
- Example: (yield)
- Example: (yield x)
*)
yield_from : location:'location -> value:'expr -> 'expr;
(*
Represents a yield from expression.
- Example: (yield from x)
*)
compare : location:'location -> left:'expr -> ops:'compare list -> comparators:'expr list -> 'expr;
(*
Represents a comparison expression.
- Example: x is y
- Example: x > y > z
*)
call : location:'location -> func:'expr -> args:'expr list -> keywords:'keyword list -> 'expr;
(*
Represents a call expression, where args is the list of positionally-specified arguments, and keywords is the list of keyword-specified arguments.
- Example: foo(x, y=1)
- Example: foo(x, *y, **z)
*)
formatted_value : location:'location -> value:'expr -> conversion:int -> format_spec:'expr option -> 'expr;
(*
Represents the expression component of an f-string. See PEP 498. conversion is an integer representing the type conversion operator:
- -1 means no formatting.
- 115 means !s string formatting.
- 114 means !r repr formatting
- 97 means !a ascii formatting
format_spec represents the format specifier. This is always going to be a joined_str expression.
- Example: f"derp={a+b:{foo}}". The entire expression will be a joined_str but the a+b part will be represented as a formatted_value with the foo part as its format specifier.
*)
joined_str : location:'location -> values:'expr list -> 'expr;
(*
Represents an f-string. See PEP 498.
- Example: f"a={b}"
*)
constant : location:'location -> value:'constant -> kind:string option -> 'expr;
(*
Represents a constant expression.
- Example: 42
*)
attribute : location:'location -> value:'expr -> attr:'identifier -> ctx:'expr_context -> 'expr;
(*
Represents an attribute access expression.
- Example: a.b
*)
subscript : location:'location -> value:'expr -> slice:'expr -> ctx:'expr_context -> 'expr;
(*
Represents a subscript access expression.
- Example: a[b]
*)
starred : location:'location -> value:'expr -> ctx:'expr_context -> 'expr;
(*
Represents an starred expression, which is used to represent iterable unpacking (inside call, list, or comprehension expressions, for example). See PEP 448.
*)
name : location:'location -> id:'identifier -> ctx:'expr_context -> 'expr;
(*
Represents a simple identifier.
- Example: a
*)
list : location:'location -> elts:'expr list -> ctx:'expr_context -> 'expr;
(*
Represents a Python list display.
- Example: []
- Example: [a, b]
- Example: [a, *b]
*)
tuple : location:'location -> elts:'expr list -> ctx:'expr_context -> 'expr;
(*
Represents a Python tuple display.
- Example: ()
- Example: (a, b)
- Example: (a, *b)
*)
slice : location:'location -> lower:'expr option -> upper:'expr option -> step:'expr option -> 'expr;
(*
Represents a slice expression. This kind of expression can only appear within the slice field of the subscript expression, either directly or as an element of a tuple expression.
- Example: a[:]
- Example: a[1:2, 3:4]
*)

}

val make : 
  bool_op:(location:'a -> op:'b -> values:'c list -> 'c) ->
  named_expr:(location:'a -> target:'c -> value:'c -> 'c) ->
  bin_op:(location:'a -> left:'c -> op:'d -> right:'c -> 'c) ->
  unary_op:(location:'a -> op:'e -> operand:'c -> 'c) ->
  lambda:(location:'a -> args:'f -> body:'c -> 'c) ->
  if_exp:(location:'a -> test:'c -> body:'c -> orelse:'c -> 'c) ->
  dict:(location:'a -> keys:'c option list -> values:'c list -> 'c) ->
  set:(location:'a -> elts:'c list -> 'c) ->
  list_comp:(location:'a -> elt:'c -> generators:'g list -> 'c) ->
  set_comp:(location:'a -> elt:'c -> generators:'g list -> 'c) ->
  dict_comp:(location:'a -> key:'c -> value:'c -> generators:'g list -> 'c) ->
  generator_exp:(location:'a -> elt:'c -> generators:'g list -> 'c) ->
  await:(location:'a -> value:'c -> 'c) ->
  yield:(location:'a -> value:'c option -> 'c) ->
  yield_from:(location:'a -> value:'c -> 'c) ->
  compare:(location:'a -> left:'c -> ops:'h list -> comparators:'c list -> 'c) ->
  call:(location:'a -> func:'c -> args:'c list -> keywords:'i list -> 'c) ->
  formatted_value:
    (location:'a -> value:'c -> conversion:int -> format_spec:'c option -> 'c) ->
  joined_str:(location:'a -> values:'c list -> 'c) ->
  constant:(location:'a -> value:'j -> kind:string option -> 'c) ->
  attribute:(location:'a -> value:'c -> attr:'k -> ctx:'l -> 'c) ->
  subscript:(location:'a -> value:'c -> slice:'c -> ctx:'l -> 'c) ->
  starred:(location:'a -> value:'c -> ctx:'l -> 'c) ->
  name:(location:'a -> id:'k -> ctx:'l -> 'c) ->
  list:(location:'a -> elts:'c list -> ctx:'l -> 'c) ->
  tuple:(location:'a -> elts:'c list -> ctx:'l -> 'c) ->
  slice:
    (location:'a -> lower:'c option -> upper:'c option -> step:'c option -> 'c) ->
  unit ->
  ('f, 'd, 'b, 'h, 'g, 'j, 'l, 'k, 'i, 'a, 'e, 'c) t

Constructor of t.

package pyre-ast