etuples

0.3.10 · active · verified Sat Apr 11

etuples is a Python library that provides S-expression emulation using tuple-like objects. It allows for the creation of functional expression trees that can be explicitly evaluated. The library is currently at version 0.3.10 and has an active development status with several releases in the past year.

Warnings

gotcha Do not confuse `etuple` objects with Python's built-in `tuple` type. `etuple` instances are specifically designed for S-expression emulation, representing an operation and its arguments as an unevaluated expression, rather than a simple immutable sequence.
Fix: Always remember that `etuple` objects require explicit evaluation (e.g., using `.eval()` or `apply(rator(et), rands(et))`) to compute their result, unlike standard Python tuples which are simple data structures.
gotcha Failing to explicitly evaluate an `etuple` object will result in operating on the `ExpressionTuple` object itself, not its computed value. This is a common mistake when users expect immediate computation akin to function calls.
Fix: Always call the `.eval()` method on an `ExpressionTuple` instance to get its computed result. For example, `my_etuple.eval()` instead of just `my_etuple`.
gotcha As `etuples` is in its 0.x version series, minor version increments (e.g., 0.3.x to 0.4.x) might introduce breaking API changes. Developers should review the changelog carefully when upgrading to a new minor version.
Fix: Consult the GitHub release notes and changelog for each new minor version before upgrading in production environments.

Install

pip install etuples Install latest version

Imports

etuple
```
from etuples import etuple
```
etuplize
```
from etuples import etuplize
```

ExpressionTuple

from etuples.core import ExpressionTuple

Quickstart

This quickstart demonstrates how to create basic S-expression-like tuples using `etuple`, how to evaluate them, and how to use `etuplize` to convert a regular callable into an expression-tuple factory.

from operator import add
from etuples import etuple, etuplize

# Create an expression tuple
et = etuple(add, 1, 2)
print(f"Expression: {et}")

# Evaluate the expression
result = et.eval()
print(f"Result of evaluation: {result}")

# etuplize can convert callables into etuples
def my_func(a, b):
    return a * b

et_func = etuplize(my_func)
et_expression = et_func(3, 4)
print(f"Et_expression: {et_expression}")
print(f"Result of et_expression: {et_expression.eval()}")

view raw JSON →