synt.expr.closure

lambda_ module-attribute

lambda_ = ClosureBuilder

Alias ClosureBuilder.

Closure

Bases: Expression, IntoCode

Python's closure expression, aka lambda.

Notes

In Python, a lambda expression can have a single expression as its body. Synt won't try to create a separate function containing multiple statements, you must do it yourself.

References

expr.ExprPrecedence.Lambda.

Source code in synt/expr/closure.py

class Closure(expr.Expression, code.IntoCode):
    r"""Python's closure expression, aka `lambda`.

    Notes:
        In Python, a lambda expression can have a single expression as its body.
        Synt won't try to create a separate function containing multiple statements,
        you must do it yourself.

    References:
        [expr.ExprPrecedence.Lambda][synt.expr.expr.ExprPrecedence.Lambda].
    """

    args: list[Identifier]
    """Argument list."""
    body: expr.Expression
    """expr.Expression body."""

    precedence = expr.ExprPrecedence.Lambda
    expr_type = expr.ExprType.Closure

    def __init__(self, args: list[Identifier], body: expr.IntoExpression):
        """Initialize a closure expression.

        Args:
            args: Argument list.
            body: expr.Expression body.
        """
        self.args = args
        self.body = body.into_expression()
        if self.body.precedence > self.precedence:
            self.body = self.body.wrapped()

    def into_code(self) -> str:
        return f"lambda {', '.join(arg.into_code() for arg in self.args)}: {self.body.into_code()}"

precedence class-attribute instance-attribute

precedence = Lambda

expr_type class-attribute instance-attribute

expr_type = Closure

args instance-attribute

args: list[Identifier] = args

Argument list.

body instance-attribute

body: Expression = into_expression()

expr.Expression body.

__init__

__init__(args: list[Identifier], body: IntoExpression)

Initialize a closure expression.

Parameters:

Name	Type	Description	Default
args	list[Identifier]	Argument list.	required
body	IntoExpression	expr.Expression body.	required

Source code in synt/expr/closure.py

def __init__(self, args: list[Identifier], body: expr.IntoExpression):
    """Initialize a closure expression.

    Args:
        args: Argument list.
        body: expr.Expression body.
    """
    self.args = args
    self.body = body.into_expression()
    if self.body.precedence > self.precedence:
        self.body = self.body.wrapped()

into_code

into_code() -> str

Source code in synt/expr/closure.py

def into_code(self) -> str:
    return f"lambda {', '.join(arg.into_code() for arg in self.args)}: {self.body.into_code()}"

ClosureBuilder

Builder for Closure.

Examples:

closure = (
    lambda_(id_("x"), id_("y")) # initial a closure builder
    .join(id_("z")) # append new argument, optional
    .return_(id_("x").expr() + id_("y") + id_("z")) # set the expression to be returned and build the closure
)
assert closure.into_code() == "lambda x, y, z: x + y + z"

Source code in synt/expr/closure.py

class ClosureBuilder:
    r"""Builder for [`Closure`][synt.expr.closure.Closure].

    Examples:
        ```python
        closure = (
            lambda_(id_("x"), id_("y")) # initial a closure builder
            .join(id_("z")) # append new argument, optional
            .return_(id_("x").expr() + id_("y") + id_("z")) # set the expression to be returned and build the closure
        )
        assert closure.into_code() == "lambda x, y, z: x + y + z"
        ```
    """

    __args: list[Identifier]

    def __init__(self, *args: Identifier):
        """Initialize a closure.

        Args:
            *args: Initial closure argument list.
        """
        self.__args = list(args)

    def join(self, *args: Identifier) -> Self:
        """Append new arguments to the closure.

        Args:
            *args: New closure arguments.
        """
        self.__args.extend(args)
        return self

    def ret(self, e: expr.IntoExpression) -> Closure:
        """Set the expression to be returned by the closure.

        Args:
            e: expr.Expression to be returned.
        """
        return Closure(self.__args, e)

    def return_(self, e: expr.IntoExpression) -> Closure:
        """Alias [`ret`][synt.expr.closure.ClosureBuilder.ret]."""
        return self.ret(e)

__init__

__init__(*args: Identifier)

Initialize a closure.

Parameters:

Name	Type	Description	Default
*args	Identifier	Initial closure argument list.	()

Source code in synt/expr/closure.py

def __init__(self, *args: Identifier):
    """Initialize a closure.

    Args:
        *args: Initial closure argument list.
    """
    self.__args = list(args)

join

join(*args: Identifier) -> Self

Append new arguments to the closure.

Parameters:

Name	Type	Description	Default
*args	Identifier	New closure arguments.	()

Source code in synt/expr/closure.py

def join(self, *args: Identifier) -> Self:
    """Append new arguments to the closure.

    Args:
        *args: New closure arguments.
    """
    self.__args.extend(args)
    return self

ret

ret(e: IntoExpression) -> Closure

Set the expression to be returned by the closure.

Parameters:

Name	Type	Description	Default
e	IntoExpression	expr.Expression to be returned.	required

Source code in synt/expr/closure.py

def ret(self, e: expr.IntoExpression) -> Closure:
    """Set the expression to be returned by the closure.

    Args:
        e: expr.Expression to be returned.
    """
    return Closure(self.__args, e)

return_

return_(e: IntoExpression) -> Closure

Alias ret.

Source code in synt/expr/closure.py

def return_(self, e: expr.IntoExpression) -> Closure:
    """Alias [`ret`][synt.expr.closure.ClosureBuilder.ret]."""
    return self.ret(e)