Skip to content

synt.tokens.lit ¤

litstr module-attribute ¤

1
litstr = str_

Alias for str_.

litint module-attribute ¤

1
litint = int_

Alias for int_.

litfloat module-attribute ¤

1
litfloat = float_

Alias for float_.

litbool module-attribute ¤

1
litbool = bool_

Alias for bool_.

TRUE module-attribute ¤

1
TRUE = bool_(True)

Alias for bool_(True).

FALSE module-attribute ¤

1
FALSE = bool_(False)

Alias for bool_(False).

NONE module-attribute ¤

1
NONE = Literal('None')

Alias for a literal None.

ELLIPSIS module-attribute ¤

1
ELLIPSIS = Literal('...')

Alias for a literal ellipsis ....

UNDERSCORE module-attribute ¤

1
UNDERSCORE = Literal('_')

Alias for a literal underscore _.

ELIDE module-attribute ¤

1
ELIDE = Literal('_')

Alias for a literal underscore _.

Literal ¤

Bases: Expression

Literal Python expression.

Source code in synt/tokens/lit.py 
 24
 25
 26
 27
 28
 29
 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
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
class Literal(Expression):
    r"""Literal Python expression."""

    lit: str
    """Source code of the literal."""

    precedence = ExprPrecedence.Atom
    expr_type = ExprType.Literal

    def __init__(self, src: str):
        """Initialize a Literal value.

        **DO NOT USE THIS IN YOUR CODE!** Use other entry points instead.

        Args:
            src: Source code of the literal.
        """
        self.lit = src

    @staticmethod
    def bool_(b: bool) -> Literal:
        """Initialize a literal boolean.

        Notes:
            `bool` is a built-in type, so this function is suffixed with a `_`.

        Args:
            b: Original boolean.

        Examples:
            ```python
            a = litbool(True)
            assert a.into_code() == "True"
            ```
        """
        if b:
            return Literal("True")
        else:
            return Literal("False")

    @staticmethod
    def str_(s: str) -> Literal:
        """Initialize a literal string.

        Notes:
            `str` is a built-in type, so this function is suffixed with a `_`.

        Args:
            s: Original string.

        Examples:
            ```python
            a = litstr("abc")
            assert a.into_code() == "'abc'"
            ```
        """
        return Literal._repr(s)

    @staticmethod
    def int_(s: int) -> Literal:
        """Initialize a literal integer.

        Notes:
            `int` is a built-in type, so this function is suffixed with a `_`.

        Args:
            s: Original integer.

        Examples:
            ```python
            a = litint(1)
            assert a.into_code() == "1"
            ```
        """
        return Literal._repr(s)

    @staticmethod
    def float_(s: float) -> Literal:
        """Initialize a literal float.

        Args:
            s: Original float.

        Notes:
            `float` is a built-in type, so this function is suffixed with a `_`.

        Examples:
            ```python
            a = litfloat(0.24)
            assert a.into_code() == "0.24"
            ```
        """
        return Literal._repr(s)

    @staticmethod
    def _repr(mr: Any) -> Literal:
        """Initialize a literal value with the `__repr__` method of the given value.

        Args:
            mr: Value to be represented.

        Raises:
            AttributeError: `__repr__` is not found for the given value.
        """
        return Literal(repr(mr))

    @staticmethod
    def _str(s: Any) -> Literal:
        """Initialize a literal value with the `__str__` method of the given value.

        Args:
            s: Value to be represented.

        Raises:
            AttributeError: `__str__` is not found for the given value.
        """
        return Literal(str(s))

    def into_code(self) -> str:
        return self.lit

precedence class-attribute instance-attribute ¤

1
precedence = Atom

expr_type class-attribute instance-attribute ¤

1
expr_type = Literal

lit instance-attribute ¤

1
lit: str = src

Source code of the literal.

__init__ ¤

1
__init__(src: str)

Initialize a Literal value.

DO NOT USE THIS IN YOUR CODE! Use other entry points instead.

Parameters:

Name Type Description Default
src str

Source code of the literal.

 required
Source code in synt/tokens/lit.py 
33
34
35
36
37
38
39
40
41
def __init__(self, src: str):
    """Initialize a Literal value.

    **DO NOT USE THIS IN YOUR CODE!** Use other entry points instead.

    Args:
        src: Source code of the literal.
    """
    self.lit = src

bool_ staticmethod ¤

1
bool_(b: bool) -> Literal

Initialize a literal boolean.

Notes

bool is a built-in type, so this function is suffixed with a _.

Parameters:

Name Type Description Default
b bool

Original boolean.

 required

Examples:

1
2
a = litbool(True)
assert a.into_code() == "True"
Source code in synt/tokens/lit.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
@staticmethod
def bool_(b: bool) -> Literal:
    """Initialize a literal boolean.

    Notes:
        `bool` is a built-in type, so this function is suffixed with a `_`.

    Args:
        b: Original boolean.

    Examples:
        ```python
        a = litbool(True)
        assert a.into_code() == "True"
        ```
    """
    if b:
        return Literal("True")
    else:
        return Literal("False")

str_ staticmethod ¤

1
str_(s: str) -> Literal

Initialize a literal string.

Notes

str is a built-in type, so this function is suffixed with a _.

Parameters:

Name Type Description Default
s str

Original string.

 required

Examples:

1
2
a = litstr("abc")
assert a.into_code() == "'abc'"
Source code in synt/tokens/lit.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
@staticmethod
def str_(s: str) -> Literal:
    """Initialize a literal string.

    Notes:
        `str` is a built-in type, so this function is suffixed with a `_`.

    Args:
        s: Original string.

    Examples:
        ```python
        a = litstr("abc")
        assert a.into_code() == "'abc'"
        ```
    """
    return Literal._repr(s)

int_ staticmethod ¤

1
int_(s: int) -> Literal

Initialize a literal integer.

Notes

int is a built-in type, so this function is suffixed with a _.

Parameters:

Name Type Description Default
s int

Original integer.

 required

Examples:

1
2
a = litint(1)
assert a.into_code() == "1"
Source code in synt/tokens/lit.py 
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
@staticmethod
def int_(s: int) -> Literal:
    """Initialize a literal integer.

    Notes:
        `int` is a built-in type, so this function is suffixed with a `_`.

    Args:
        s: Original integer.

    Examples:
        ```python
        a = litint(1)
        assert a.into_code() == "1"
        ```
    """
    return Literal._repr(s)

float_ staticmethod ¤

1
float_(s: float) -> Literal

Initialize a literal float.

Parameters:

Name Type Description Default
s float

Original float.

 required
Notes

float is a built-in type, so this function is suffixed with a _.

Examples:

1
2
a = litfloat(0.24)
assert a.into_code() == "0.24"
Source code in synt/tokens/lit.py 
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
@staticmethod
def float_(s: float) -> Literal:
    """Initialize a literal float.

    Args:
        s: Original float.

    Notes:
        `float` is a built-in type, so this function is suffixed with a `_`.

    Examples:
        ```python
        a = litfloat(0.24)
        assert a.into_code() == "0.24"
        ```
    """
    return Literal._repr(s)

into_code ¤

1
into_code() -> str
Source code in synt/tokens/lit.py 
142
143
def into_code(self) -> str:
    return self.lit