remove extra lines

Author: saulshanabrook

docs/reference/python-integration.md

@@ -639,7 +639,3 @@ r = ruleset(
 )
 egraph.saturate(r)
 ```
-
-```
-
-```

python/egglog/deconstruct.py

@@ -171,74 +171,3 @@ def _deconstruct_call_decl(
     )
 
     return RuntimeFunction(decls_thunk, Thunk.value(call.callable), egg_bound), arg_exprs
-
-
-##
-# Alternative way of deconstructing expressions. Don't use this for now because type checking is harder for it.
-# is_expr_fn won't validate that the return types are the same b/c of type broadening and the above way is more succinct.
-##
-# def deconstruct(x: T) -> tuple[Callable[..., T], Unpack[tuple[object, ...]]]:
-#     """
-#     Deconstructs a value into a callable and its arguments.
-
-#     For all egglog expressions:
-
-#     >>> fn, *args = deconstruct(expr)
-#     >>> assert fn(*args) == expr
-
-#     If the `expr` is a constant value (like from `const` or a classvar), then it will be wrapped in `DeconstructedConstant`
-#     and return as the function with no arguments.
-#     """
-#     if not isinstance(x, RuntimeExpr):
-#         raise TypeError(f"Expected Expression, got {type(x).__name__}")
-
-#     match expr := x.__egg_typed_expr__.expr:
-#         case UnboundVarDecl(name, egg_name):
-#             tp = RuntimeClass(x.__egg_decls_thunk__, x.__egg_typed_expr__.tp.to_var())
-#             return var, name, tp, egg_name
-#         case LetRefDecl(name):
-#             msg = "let expressions are not supported in deconstruct. Please open an issue if you need this feature."
-#             raise NotImplementedError(msg)
-#         case LitDecl(bool(b)):
-#             return Bool, b
-#         case LitDecl(int(i)):
-#             return i64, i
-#         case LitDecl(float(f)):
-#             return f64, f
-#         case LitDecl(None):
-#             return (Unit,)
-#         case PyObjectDecl(obj):
-#             return PyObject, obj
-#         case PartialCallDecl(call):
-#             return UnstableFn, *_deconstruct_call_decl(x.__egg_decls_thunk__, call)
-#         case CallDecl(callable):
-#             if isinstance(callable, (ConstantRef, ClassVariableRef)):
-#                 return (DeconstructedConstant(x),)
-#             return _deconstruct_call_decl(x.__egg_decls_thunk__, expr)
-#         case _:
-#             assert_never(expr)
-
-
-# @dataclass
-# class DeconstructedConstant(Generic[T]):
-#     """
-#     Wrapper around constant expressions retuen by `deconstruct`.
-#     """
-
-#     expr: T
-
-#     def __call__(self) -> T:
-#         """
-#         Returns the constant expression.
-#         """
-#         return self.expr
-
-
-# def is_expr_fn(
-#     deconstructed: tuple[Callable[..., T], Unpack[tuple[Any, ...]]],
-#     fn: Callable[[Unpack[TS]], T],
-# ) -> TypeIs[tuple[Callable[[Unpack[TS]], T], Unpack[TS]]]:
-#     """
-#     Compares a deconstructed fn and args to a function, so that the args are now properly type cast.
-#     """
-#     return deconstructed[0] == fn