Skip to content

synt.expr.wrapped ¤

wrapped module-attribute ¤

1
wrapped = Wrapped

Alias Wrapped.

wrap module-attribute ¤

1
wrap = Wrapped

Alias Wrapped.

par module-attribute ¤

1
par = Wrapped

Alias Wrapped.

Wrapped ¤

Bases: Expression

A wrapped expression, aka ( expr ), which is always an atomic expression.

Examples:

1
2
wp = wrapped(litint(1) + litint(2)) * litint(3)
assert wp.into_code() == "(1 + 2) * 3"
Notes

Most plain expressions have their own expression precedence, and will be wrapped automatically by Synt. However, for those atomic expressions, some of them does have different parser precedence which is hard to represent beforehand. Thus, you must explicitly wrap them manually.

Source code in synt/expr/wrapped.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class Wrapped(expr.Expression):
    r"""A wrapped expression, aka `( expr )`, which is always an atomic expression.

    Examples:
        ```python
        wp = wrapped(litint(1) + litint(2)) * litint(3)
        assert wp.into_code() == "(1 + 2) * 3"
        ```

    Notes:
        Most plain expressions have their own expression precedence, and will be wrapped
        automatically by Synt.
        However, for those atomic expressions, some of them does have different parser precedence
        which is hard to represent beforehand. Thus, you must explicitly wrap them manually.
    """

    inner: expr.Expression
    """Inner expression."""

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

    def __init__(self, inner: expr.IntoExpression):
        """Initialize a wrapped expression.

        Args:
            inner: Inner expression.
        """
        self.inner = inner.into_expression()

    def into_code(self) -> str:
        return f"({self.inner.into_code()})"

precedence class-attribute instance-attribute ¤

1
precedence = Atom

expr_type class-attribute instance-attribute ¤

1
expr_type = Wrapped

inner instance-attribute ¤

1
inner: Expression = into_expression()

Inner expression.

__init__ ¤

1
__init__(inner: IntoExpression)

Initialize a wrapped expression.

Parameters:

Name Type Description Default
inner IntoExpression

Inner expression.

 required
Source code in synt/expr/wrapped.py 
37
38
39
40
41
42
43
def __init__(self, inner: expr.IntoExpression):
    """Initialize a wrapped expression.

    Args:
        inner: Inner expression.
    """
    self.inner = inner.into_expression()

into_code ¤

1
into_code() -> str
Source code in synt/expr/wrapped.py 
45
46
def into_code(self) -> str:
    return f"({self.inner.into_code()})"