Skip to content

synt.expr.list ¤

list_ module-attribute ¤

1
list_ = ListVerbatim

Alias ListVerbatim.

Notes

list is a built-in type in Python, so it's renamed to list_ with a suffix.

list_comp module-attribute ¤

1
list_comp = ListComprehension

Alias ListComprehension.

ListDisplay ¤

Bases: Expression

Literal list expression.

References

list display.

Source code in synt/expr/list.py 
19
20
21
22
23
24
25
26
27
class ListDisplay(expr.Expression, metaclass=ABCMeta):
    r"""Literal list expression.

    References:
        [list display](https://docs.python.org/3/reference/expressions.html#list-displays).
    """

    precedence = expr.ExprPrecedence.Atom
    expr_type = expr.ExprType.List

precedence class-attribute instance-attribute ¤

1
precedence = Atom

expr_type class-attribute instance-attribute ¤

1
expr_type = List

ListVerbatim ¤

Bases: ListDisplay

Verbatim list expression, aka starred-list.

Examples:

1
2
l = list_(litstr("a"), id_("b"))
assert l.into_code() == "['a', b]"
References

starred-list.

Source code in synt/expr/list.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
class ListVerbatim(ListDisplay):
    r"""Verbatim list expression, aka `starred-list`.

    Examples:
        ```python
        l = list_(litstr("a"), id_("b"))
        assert l.into_code() == "['a', b]"
        ```

    References:
        [`starred-list`](https://docs.python.org/3/reference/expressions.html#grammar-token-python-grammar-starred_list).
    """

    items: list[expr.Expression]
    """list items."""

    def __init__(self, *items: expr.IntoExpression):
        """Initialize a new verbatim list expression.

        Args:
            items: list items.
        """
        self.items = [x.into_expression() for x in items]

    def into_code(self) -> str:
        item_text = ", ".join(x.into_code() for x in self.items)
        return f"[{item_text}]"

items instance-attribute ¤

1
2
3
items: list[Expression] = [
    into_expression() for x in items
]

list items.

__init__ ¤

1
__init__(*items: IntoExpression)

Initialize a new verbatim list expression.

Parameters:

Name Type Description Default
items IntoExpression

list items.

 ()
Source code in synt/expr/list.py 
46
47
48
49
50
51
52
def __init__(self, *items: expr.IntoExpression):
    """Initialize a new verbatim list expression.

    Args:
        items: list items.
    """
    self.items = [x.into_expression() for x in items]

into_code ¤

1
into_code() -> str
Source code in synt/expr/list.py 
54
55
56
def into_code(self) -> str:
    item_text = ", ".join(x.into_code() for x in self.items)
    return f"[{item_text}]"

ListComprehension ¤

Bases: ListDisplay

list comprehension expression.

Examples:

1
2
l = list_comp(id_("x").expr().for_(id_("x")).in_(id_("range").expr().call(litint(5))))
assert l.into_code() == "[x for x in range(5)]"
References

comprehension.

Source code in synt/expr/list.py 
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
class ListComprehension(ListDisplay):
    r"""list comprehension expression.

    Examples:
        ```python
        l = list_comp(id_("x").expr().for_(id_("x")).in_(id_("range").expr().call(litint(5))))
        assert l.into_code() == "[x for x in range(5)]"
        ```

    References:
        [`comprehension`](https://docs.python.org/3/reference/
        expressions.html#grammar-tokens-python-grammar-comprehension).
    """

    comprehension: comp_expr.Comprehension
    """Internal comprehension expression."""

    def __init__(
        self,
        comprehension: comp_expr.Comprehension
        | comp_expr.ComprehensionBuilder
        | comp_expr.ComprehensionNodeBuilder,
    ):
        """Initialize a new list comprehension expression.

        Args:
            comprehension: Internal comprehension expression.

        Raises:
            ExpressionTypeException: Invalid list comprehension result type,
                typically a [`KVPair`][synt.tokens.kv_pair.KVPair].
        """
        if isinstance(comprehension, comp_expr.Comprehension):
            comp = comprehension
        elif isinstance(comprehension, comp_expr.ComprehensionBuilder):
            comp = comprehension.build()
        elif isinstance(comprehension, comp_expr.ComprehensionNodeBuilder):
            comp = comprehension.build_comp()
        else:
            raise ValueError(
                "Expect expression of type `Comprehension`, found `Unknown`."
            )

        if comp.elt.expr_type == expr.ExprType.KeyValuePair:
            raise ValueError("Expect expression of type `Atom`, found `KeyValuePair`.")
        self.comprehension = comp

    def into_code(self) -> str:
        return f"[{self.comprehension.into_code()}]"

comprehension instance-attribute ¤

1
comprehension: Comprehension = comp

Internal comprehension expression.

__init__ ¤

1
2
3
4
5
6
7
__init__(
    comprehension: (
        Comprehension
        | ComprehensionBuilder
        | ComprehensionNodeBuilder
    ),
)

Initialize a new list comprehension expression.

Parameters:

Name Type Description Default
comprehension Comprehension | ComprehensionBuilder | ComprehensionNodeBuilder

Internal comprehension expression.

 required

Raises:

Type Description
ExpressionTypeException

Invalid list comprehension result type, typically a KVPair.
Source code in synt/expr/list.py 
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def __init__(
    self,
    comprehension: comp_expr.Comprehension
    | comp_expr.ComprehensionBuilder
    | comp_expr.ComprehensionNodeBuilder,
):
    """Initialize a new list comprehension expression.

    Args:
        comprehension: Internal comprehension expression.

    Raises:
        ExpressionTypeException: Invalid list comprehension result type,
            typically a [`KVPair`][synt.tokens.kv_pair.KVPair].
    """
    if isinstance(comprehension, comp_expr.Comprehension):
        comp = comprehension
    elif isinstance(comprehension, comp_expr.ComprehensionBuilder):
        comp = comprehension.build()
    elif isinstance(comprehension, comp_expr.ComprehensionNodeBuilder):
        comp = comprehension.build_comp()
    else:
        raise ValueError(
            "Expect expression of type `Comprehension`, found `Unknown`."
        )

    if comp.elt.expr_type == expr.ExprType.KeyValuePair:
        raise ValueError("Expect expression of type `Atom`, found `KeyValuePair`.")
    self.comprehension = comp

into_code ¤

1
into_code() -> str
Source code in synt/expr/list.py 
114
115
def into_code(self) -> str:
    return f"[{self.comprehension.into_code()}]"