egglog 0.4.0__pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

egglog/examples/ndarrays.py

@@ -0,0 +1,159 @@
+"""
+N-Dimensional Arrays
+====================
+
+Example of building NDarray in the vein of Mathemetics of Arrays.
+"""
+# mypy: disable-error-code=empty-body
+from __future__ import annotations
+
+from egglog import *
+
+egraph = EGraph()
+
+
+@egraph.class_
+class Value(BaseExpr):
+    def __init__(self, v: i64Like) -> None:
+        ...
+
+    def __mul__(self, other: Value) -> Value:
+        ...
+
+    def __add__(self, other: Value) -> Value:
+        ...
+
+
+i, j = vars_("i j", i64)
+egraph.register(
+    rewrite(Value(i) * Value(j)).to(Value(i * j)),
+    rewrite(Value(i) + Value(j)).to(Value(i + j)),
+)
+
+
+@egraph.class_
+class Values(BaseExpr):
+    def __init__(self, v: Vec[Value]) -> None:
+        ...
+
+    def __getitem__(self, idx: Value) -> Value:
+        ...
+
+    def length(self) -> Value:
+        ...
+
+    def concat(self, other: Values) -> Values:
+        ...
+
+
+@egraph.register
+def _values(vs: Vec[Value], other: Vec[Value]):
+    yield rewrite(Values(vs)[Value(i)]).to(vs[i])
+    yield rewrite(Values(vs).length()).to(Value(vs.length()))
+    yield rewrite(Values(vs).concat(Values(other))).to(Values(vs.append(other)))
+    # yield rewrite(l.concat(r).length()).to(l.length() + r.length())
+    # yield rewrite(l.concat(r)[idx])
+
+
+@egraph.class_
+class NDArray(BaseExpr):
+    """
+    An n-dimensional array.
+    """
+
+    def __getitem__(self, idx: Values) -> Value:
+        ...
+
+    def shape(self) -> Values:
+        ...
+
+
+@egraph.function
+def arange(n: Value) -> NDArray:
+    ...
+
+
+@egraph.register
+def _ndarray_arange(n: Value, idx: Values):
+    yield rewrite(arange(n).shape()).to(Values(Vec(n)))
+    yield rewrite(arange(n)[idx]).to(idx[Value(0)])
+
+
+def assert_simplifies(left: BaseExpr, right: BaseExpr) -> None:
+    """
+    Simplify and print
+    """
+    egraph.register(left)
+    egraph.run(30)
+    res = egraph.extract(left)
+    print(f"{left} == {right} ➡  {res}")
+    egraph.check(eq(left).to(right))
+
+
+assert_simplifies(arange(Value(10)).shape(), Values(Vec(Value(10))))
+assert_simplifies(arange(Value(10))[Values(Vec(Value(0)))], Value(0))
+assert_simplifies(arange(Value(10))[Values(Vec(Value(1)))], Value(1))
+
+
+@egraph.function
+def py_value(s: StringLike) -> Value:
+    ...
+
+
+@egraph.register
+def _py_value(l: String, r: String):
+    yield rewrite(py_value(l) + py_value(r)).to(py_value(join(l, " + ", r)))
+    yield rewrite(py_value(l) * py_value(r)).to(py_value(join(l, " * ", r)))
+
+
+@egraph.function
+def py_values(s: StringLike) -> Values:
+    ...
+
+
+@egraph.register
+def _py_values(l: String, r: String):
+    yield rewrite(py_values(l)[py_value(r)]).to(py_value(join(l, "[", r, "]")))
+    yield rewrite(py_values(l).length()).to(py_value(join("len(", l, ")")))
+    yield rewrite(py_values(l).concat(py_values(r))).to(py_values(join(l, " + ", r)))
+
+
+@egraph.function
+def py_ndarray(s: StringLike) -> NDArray:
+    ...
+
+
+@egraph.register
+def _py_ndarray(l: String, r: String):
+    yield rewrite(py_ndarray(l)[py_values(r)]).to(py_value(join(l, "[", r, "]")))
+    yield rewrite(py_ndarray(l).shape()).to(py_values(join(l, ".shape")))
+    yield rewrite(arange(py_value(l))).to(py_ndarray(join("np.arange(", l, ")")))
+
+
+assert_simplifies(py_ndarray("x").shape(), py_values("x.shape"))
+assert_simplifies(arange(py_value("x"))[py_values("y")], py_value("np.arange(x)[y]"))
+# assert_simplifies(arange(py_value("x"))[py_values("y")], py_value("y[0]"))
+
+
+@egraph.function
+def cross(l: NDArray, r: NDArray) -> NDArray:
+    ...
+
+
+@egraph.register
+def _cross(l: NDArray, r: NDArray, idx: Values):
+    yield rewrite(cross(l, r).shape()).to(l.shape().concat(r.shape()))
+    yield rewrite(cross(l, r)[idx]).to(l[idx] * r[idx])
+
+
+assert_simplifies(cross(arange(Value(10)), arange(Value(11))).shape(), Values(Vec(Value(10), Value(11))))
+assert_simplifies(cross(py_ndarray("x"), py_ndarray("y")).shape(), py_values("x.shape + y.shape"))
+assert_simplifies(cross(py_ndarray("x"), py_ndarray("y"))[py_values("idx")], py_value("x[idx] * y[idx]"))
+
+
+@egraph.register
+def _cross_py(l: String, r: String):
+    yield rewrite(cross(py_ndarray(l), py_ndarray(r))).to(py_ndarray(join("np.multiply.outer(", l, ", ", r, ")")))
+
+
+assert_simplifies(cross(py_ndarray("x"), py_ndarray("y"))[py_values("idx")], py_value("np.multiply.outer(x, y)[idx]"))

egglog/examples/resolution.py

@@ -0,0 +1,84 @@
+"""
+Resolution theorem proving.
+===========================
+"""
+from __future__ import annotations
+
+from typing import ClassVar
+
+from egglog import *
+
+egraph = EGraph()
+
+
+@egraph.class_
+class Bool(BaseExpr):
+    FALSE: ClassVar[Bool]
+
+    def __or__(self, other: Bool) -> Bool:  # type: ignore[empty-body]
+        ...
+
+    def __invert__(self) -> Bool:  # type: ignore[empty-body]
+        ...
+
+
+# Show off two ways of creating constants, either as top level values or as classvars
+T = egraph.constant("T", Bool)
+F = Bool.FALSE
+
+p, a, b, c, as_, bs = vars_("p a b c as bs", Bool)
+egraph.register(
+    # clauses are assumed in the normal form (or a (or b (or c False)))
+    set_(~F).to(T),
+    set_(~T).to(F),
+    # "Solving" negation equations
+    rule(eq(~p).to(T)).then(union(p).with_(F)),
+    rule(eq(~p).to(F)).then(union(p).with_(T)),
+    # canonicalize associtivity. "append" for clauses terminate with false
+    rewrite((a | b) | c).to(a | (b | c)),
+    # commutativity
+    rewrite(a | (b | c)).to(b | (a | c)),
+    # absoprtion
+    rewrite(a | (a | b)).to(a | b),
+    rewrite(a | (~a | b)).to(T),
+    # Simplification
+    rewrite(F | a).to(a),
+    rewrite(a | F).to(a),
+    rewrite(T | a).to(T),
+    rewrite(a | T).to(T),
+    # unit propagation
+    # This is kind of interesting actually.
+    # Looks a bit like equation solving
+    rule(eq(T).to(p | F)).then(union(p).with_(T)),
+    # resolution
+    # This counts on commutativity to bubble everything possible up to the front of the clause.
+    rule(
+        eq(T).to(a | as_),
+        eq(T).to(~a | bs),
+    ).then(
+        set_(as_ | bs).to(T),
+    ),
+)
+
+
+# Example predicate
+@egraph.function
+def pred(x: i64Like) -> Bool:  # type: ignore[empty-body]
+    ...
+
+
+p0 = egraph.define("p0", pred(0))
+p1 = egraph.define("p1", pred(1))
+p2 = egraph.define("p2", pred(2))
+egraph.register(
+    set_(p1 | (~p2 | F)).to(T),
+    set_(p2 | (~p0 | F)).to(T),
+    set_(p0 | (~p1 | F)).to(T),
+    union(p1).with_(F),
+    set_(~p0 | (~p1 | (p2 | F))).to(T),
+)
+egraph.run(10)
+egraph.check(T != F)
+egraph.check(eq(p0).to(F))
+egraph.check(eq(p2).to(F))
+egraph

egglog/examples/schedule_demo.py

@@ -0,0 +1,33 @@
+"""
+Schedule demo
+=============
+"""
+from __future__ import annotations
+
+from egglog import *
+
+egraph = EGraph()
+
+left = egraph.relation("left", i64)
+right = egraph.relation("right", i64)
+
+egraph.register(left(i64(0)), right(i64(0)))
+
+x, y = vars_("x y", i64)
+
+step_left = egraph.ruleset("step-left")
+egraph.register(rule(left(x), right(x), ruleset=step_left).then(left(x + 1)))
+
+step_right = egraph.ruleset("step-right")
+egraph.register(rule(left(x), right(y), eq(x).to(y + 1), ruleset=step_right).then(right(x)))
+
+egraph.run(
+    seq(
+        run(step_right).saturate(),
+        run(step_left).saturate(),
+    )
+    * 10
+)
+egraph.check(left(i64(10)), right(i64(9)))
+egraph.check_fail(left(i64(11)), right(i64(10)))
+egraph

egglog/ipython_magic.py

@@ -0,0 +1,40 @@
+from .bindings import EGraph
+
+EGRAPH_VAR = "_MAGIC_EGRAPH"
+
+try:
+    get_ipython()  # type: ignore[name-defined]
+    in_ipython = True
+except NameError:
+    in_ipython = False
+
+if in_ipython:
+    import graphviz
+    from IPython.core.magic import needs_local_scope, register_cell_magic
+
+    @needs_local_scope
+    @register_cell_magic
+    def egglog(line, cell, local_ns):
+        """
+        Run an egglog program
+
+        Usage:
+
+            %%egglog [output] [continue] [graph]
+            (egglog program)
+
+        If `output` is specified, the output of the program will be printed.
+        If `continue` is specified, the program will be run in the same EGraph as the previous cell.
+        If `graph` is specified, the EGraph will be displayed as a graph.
+        """
+        if EGRAPH_VAR in local_ns and "continue" in line:
+            e = local_ns[EGRAPH_VAR]
+        else:
+            e = EGraph()
+            local_ns[EGRAPH_VAR] = e
+        cmds = e.parse_program(cell)
+        res = e.run_program(*cmds)
+        if "output" in line:
+            print("\n".join(res))
+        if "graph" in line:
+            return graphviz.Source(e.to_graphviz_string())

egglog/monkeypatch.py

@@ -0,0 +1,33 @@
+import sys
+import typing
+
+__all__ = ["monkeypatch_forward_ref"]
+
+
+def monkeypatch_forward_ref():
+    """
+    Monkeypatch to backport https://github.com/python/cpython/pull/21553.
+    Removed recursive gaurd for simplicity
+    Can be removed once Pytho 3.8 is no longer supported
+    """
+    if sys.version_info >= (3, 9):
+        return
+    typing.ForwardRef._evaluate = _evaluate_monkeypatch  # type: ignore
+
+
+def _evaluate_monkeypatch(self, globalns, localns):
+    if not self.__forward_evaluated__ or localns is not globalns:
+        if globalns is None and localns is None:
+            globalns = localns = {}
+        elif globalns is None:
+            globalns = localns
+        elif localns is None:
+            localns = globalns
+        type_ = typing._type_check(  # type: ignore
+            eval(self.__forward_code__, globalns, localns),
+            "Forward references must evaluate to types.",
+            is_argument=self.__forward_is_argument__,
+        )
+        self.__forward_value__ = typing._eval_type(type_, globalns, localns)  # type: ignore
+        self.__forward_evaluated__ = True
+    return self.__forward_value__

egglog/runtime.py

@@ -0,0 +1,304 @@
+"""
+This module holds a number of types which are only used at runtime to emulate Python objects.
+
+Users will not import anything from this module, and statically they won't know these are the types they are using.
+
+But at runtime they will be exposed.
+
+Note that all their internal fields are prefixed with __egg_ to avoid name collisions with user code, but will end in __
+so they are not mangled by Python and can be accessed by the user.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Collection, Iterable, Optional, Union
+
+import black
+from typing_extensions import assert_never
+
+from . import config  # noqa: F401
+from .declarations import *
+from .declarations import BINARY_METHODS, UNARY_METHODS
+from .type_constraint_solver import *
+
+__all__ = [
+    "LIT_CLASS_NAMES",
+    "RuntimeClass",
+    "RuntimeParamaterizedClass",
+    "RuntimeClassMethod",
+    "RuntimeExpr",
+    "RuntimeFunction",
+    "ArgType",
+]
+
+
+BLACK_MODE = black.Mode(line_length=120)  # type: ignore
+
+UNIT_CLASS_NAME = "Unit"
+UNARY_LIT_CLASS_NAMES = {"i64", "f64", "String"}
+LIT_CLASS_NAMES = UNARY_LIT_CLASS_NAMES | {UNIT_CLASS_NAME}
+
+
+@dataclass
+class RuntimeClass:
+    __egg_decls__: ModuleDeclarations
+    __egg_name__: str
+
+    def __call__(self, *args: ArgType) -> RuntimeExpr:
+        """
+        Create an instance of this kind by calling the __init__ classmethod
+        """
+        # If this is a literal type, initializing it with a literal should return a literal
+        if self.__egg_name__ in UNARY_LIT_CLASS_NAMES:
+            assert len(args) == 1
+            assert isinstance(args[0], (int, float, str))
+            return RuntimeExpr(self.__egg_decls__, TypedExprDecl(JustTypeRef(self.__egg_name__), LitDecl(args[0])))
+        if self.__egg_name__ == UNIT_CLASS_NAME:
+            assert len(args) == 0
+            return RuntimeExpr(self.__egg_decls__, TypedExprDecl(JustTypeRef(self.__egg_name__), LitDecl(None)))
+
+        return RuntimeClassMethod(self.__egg_decls__, self.__egg_name__, "__init__")(*args)
+
+    def __dir__(self) -> list[str]:
+        cls_decl = self.__egg_decls__.get_class_decl(self.__egg_name__)
+        possible_methods = list(cls_decl.class_methods) + list(cls_decl.class_variables)
+        if "__init__" in possible_methods:
+            possible_methods.remove("__init__")
+            possible_methods.append("__call__")
+        return possible_methods
+
+    def __getitem__(self, args: tuple[RuntimeTypeArgType, ...] | RuntimeTypeArgType) -> RuntimeParamaterizedClass:
+        if not isinstance(args, tuple):
+            args = (args,)
+        tp = JustTypeRef(self.__egg_name__, tuple(class_to_ref(arg) for arg in args))
+        return RuntimeParamaterizedClass(self.__egg_decls__, tp)
+
+    def __getattr__(self, name: str) -> RuntimeClassMethod | RuntimeExpr:
+        cls_decl = self.__egg_decls__.get_class_decl(self.__egg_name__)
+        # if this is a class variable, return an expr for it, otherwise, assume it's a method
+        if name in cls_decl.class_variables:
+            return_tp = cls_decl.class_variables[name]
+            return RuntimeExpr(
+                self.__egg_decls__, TypedExprDecl(return_tp, CallDecl(ClassVariableRef(self.__egg_name__, name)))
+            )
+        return RuntimeClassMethod(self.__egg_decls__, self.__egg_name__, name)
+
+    def __str__(self) -> str:
+        return self.__egg_name__
+
+    # Make hashable so can go in Union
+    def __hash__(self) -> int:
+        return hash((id(self.__egg_decls__), self.__egg_name__))
+
+
+@dataclass
+class RuntimeParamaterizedClass:
+    __egg_decls__: ModuleDeclarations
+    # Note that this will never be a typevar because we don't use RuntimeParamaterizedClass for maps on their own methods
+    # which is the only time we define function which take typevars
+    __egg_tp__: JustTypeRef
+
+    def __post_init__(self):
+        desired_args = self.__egg_decls__.get_class_decl(self.__egg_tp__.name).n_type_vars
+        if len(self.__egg_tp__.args) != desired_args:
+            raise ValueError(f"Expected {desired_args} type args, got {len(self.__egg_tp__.args)}")
+
+    def __call__(self, *args: ArgType) -> RuntimeExpr:
+        return RuntimeClassMethod(self.__egg_decls__, class_to_ref(self), "__init__")(*args)
+
+    def __getattr__(self, name: str) -> RuntimeClassMethod:
+        return RuntimeClassMethod(self.__egg_decls__, class_to_ref(self), name)
+
+    def __str__(self) -> str:
+        return self.__egg_tp__.pretty()
+
+
+# Type args can either be typevars or classes
+RuntimeTypeArgType = Union[RuntimeClass, RuntimeParamaterizedClass]
+
+
+def class_to_ref(cls: RuntimeTypeArgType) -> JustTypeRef:
+    if isinstance(cls, RuntimeClass):
+        return JustTypeRef(cls.__egg_name__)
+    if isinstance(cls, RuntimeParamaterizedClass):
+        return cls.__egg_tp__
+    assert_never(cls)
+
+
+@dataclass
+class RuntimeFunction:
+    __egg_decls__: ModuleDeclarations
+    __egg_name__: str
+    __egg_fn_ref__: FunctionRef = field(init=False)
+    __egg_fn_decl__: FunctionDecl = field(init=False)
+
+    def __post_init__(self):
+        self.__egg_fn_ref__ = FunctionRef(self.__egg_name__)
+        self.__egg_fn_decl__ = self.__egg_decls__.get_function_decl(self.__egg_fn_ref__)
+
+    def __call__(self, *args: ArgType) -> RuntimeExpr:
+        return _call(self.__egg_decls__, self.__egg_fn_ref__, self.__egg_fn_decl__, args)
+
+    def __str__(self) -> str:
+        return self.__egg_name__
+
+
+def _call(
+    decls: ModuleDeclarations,
+    callable_ref: CallableRef,
+    # Not included if this is the != method
+    fn_decl: Optional[FunctionDecl],
+    args: Collection[ArgType],
+    bound_params: Optional[tuple[JustTypeRef, ...]] = None,
+) -> RuntimeExpr:
+    upcasted_args = [_resolve_literal(decls, arg) for arg in args]
+
+    arg_types = [arg.__egg_typed_expr__.tp for arg in upcasted_args]
+
+    if bound_params is not None:
+        tcs = TypeConstraintSolver.from_type_parameters(bound_params)
+    else:
+        tcs = TypeConstraintSolver()
+
+    if fn_decl is not None:
+        return_tp = tcs.infer_return_type(fn_decl.arg_types, fn_decl.return_type, fn_decl.var_arg_type, arg_types)
+    else:
+        return_tp = JustTypeRef("Unit")
+
+    arg_decls = tuple(arg.__egg_typed_expr__ for arg in upcasted_args)
+    expr_decl = CallDecl(callable_ref, arg_decls, bound_params)
+    return RuntimeExpr(decls, TypedExprDecl(return_tp, expr_decl))
+
+
+@dataclass
+class RuntimeClassMethod:
+    __egg_decls__: ModuleDeclarations
+    # Either a string if it isn't bound or a tp if it s
+    __egg_tp__: JustTypeRef | str
+    __egg_method_name__: str
+    __egg_callable_ref__: ClassMethodRef = field(init=False)
+    __egg_fn_decl__: FunctionDecl = field(init=False)
+
+    def __post_init__(self):
+        self.__egg_callable_ref__ = ClassMethodRef(self.class_name, self.__egg_method_name__)
+        try:
+            self.__egg_fn_decl__ = self.__egg_decls__.get_function_decl(self.__egg_callable_ref__)
+        except KeyError:
+            raise AttributeError(f"Class {self.class_name} does not have method {self.__egg_method_name__}")
+
+    def __call__(self, *args: ArgType) -> RuntimeExpr:
+        bound_params = self.__egg_tp__.args if isinstance(self.__egg_tp__, JustTypeRef) else None
+        return _call(self.__egg_decls__, self.__egg_callable_ref__, self.__egg_fn_decl__, args, bound_params)
+
+    def __str__(self) -> str:
+        return f"{self.class_name}.{self.__egg_method_name__}"
+
+    @property
+    def class_name(self) -> str:
+        if isinstance(self.__egg_tp__, str):
+            return self.__egg_tp__
+        return self.__egg_tp__.name
+
+
+@dataclass
+class RuntimeMethod:
+    __egg_decls__: ModuleDeclarations
+    __egg_typed_expr__: TypedExprDecl
+    __egg_method_name__: str
+    __egg_callable_ref__: MethodRef = field(init=False)
+    __egg_fn_decl__: Optional[FunctionDecl] = field(init=False)
+
+    def __post_init__(self):
+        self.__egg_callable_ref__ = MethodRef(self.class_name, self.__egg_method_name__)
+        # Special case for __ne__ which does not have a normal function defintion since
+        # it relies of type parameters
+        if self.__egg_method_name__ == "__ne__":
+            self.__egg_fn_decl__ = None
+        else:
+            try:
+                self.__egg_fn_decl__ = self.__egg_decls__.get_function_decl(self.__egg_callable_ref__)
+            except KeyError:
+                raise AttributeError(f"Class {self.class_name} does not have method {self.__egg_method_name__}")
+
+    def __call__(self, *args: ArgType) -> RuntimeExpr:
+        first_arg = RuntimeExpr(self.__egg_decls__, self.__egg_typed_expr__)
+        args = (first_arg, *args)
+        return _call(self.__egg_decls__, self.__egg_callable_ref__, self.__egg_fn_decl__, args)
+
+    @property
+    def class_name(self) -> str:
+        return self.__egg_typed_expr__.tp.name
+
+
+@dataclass
+class RuntimeExpr:
+    __egg_decls__: ModuleDeclarations
+    __egg_typed_expr__: TypedExprDecl
+
+    def __getattr__(self, name: str) -> RuntimeMethod:
+        return RuntimeMethod(self.__egg_decls__, self.__egg_typed_expr__, name)
+
+    def __repr__(self) -> str:
+        """
+        The repr of the expr is the pretty printed version of the expr.
+        """
+        return str(self)
+
+    def __str__(self) -> str:
+        pretty_expr = self.__egg_typed_expr__.expr.pretty(parens=False)
+        if config.SHOW_TYPES:
+            s = f"_: {self.__egg_typed_expr__.tp.pretty()} = {pretty_expr}"
+            return black.format_str(s, mode=black.FileMode()).strip()
+        else:
+            return black.format_str(pretty_expr, mode=black.FileMode(line_length=180)).strip()
+
+    def __dir__(self) -> Iterable[str]:
+        return list(self.__egg_decls__.get_class_decl(self.__egg_typed_expr__.tp.name).methods)
+
+    # Have __eq__ take no NoReturn (aka Never https://docs.python.org/3/library/typing.html#typing.Never) because
+    # we don't wany any type that MyPy thinks is an expr to be used with __eq__.
+    # That's because we want to reserve __eq__ for domain specific equality checks, overloading this method.
+    # To check if two exprs are equal, use the expr_eq method.
+    def __eq__(self, other: NoReturn) -> Expr:  # type: ignore
+        raise NotImplementedError(
+            "Do not use == on RuntimeExpr. Compare the __egg_typed_expr__ attribute instead for structural equality."
+        )
+
+
+# Define each of the special methods, since we have already declared them for pretty printing
+for name in list(BINARY_METHODS) + list(UNARY_METHODS) + ["__getitem__", "__call__"]:
+
+    def _special_method(self: RuntimeExpr, *args: ArgType, __name: str = name) -> RuntimeExpr:
+        return RuntimeMethod(self.__egg_decls__, self.__egg_typed_expr__, __name)(*args)
+
+    setattr(RuntimeExpr, name, _special_method)
+
+
+# Args can either be expressions or literals which are automatically promoted
+ArgType = Union[RuntimeExpr, int, str, float]
+
+
+def _resolve_literal(decls: ModuleDeclarations, arg: ArgType) -> RuntimeExpr:
+    if isinstance(arg, int):
+        return RuntimeExpr(decls, TypedExprDecl(JustTypeRef("i64"), LitDecl(arg)))
+    elif isinstance(arg, float):
+        return RuntimeExpr(decls, TypedExprDecl(JustTypeRef("f64"), LitDecl(arg)))
+    elif isinstance(arg, str):
+        return RuntimeExpr(decls, TypedExprDecl(JustTypeRef("String"), LitDecl(arg)))
+    return arg
+
+
+def _resolve_callable(callable: object) -> CallableRef:
+    """
+    Resolves a runtime callable into a ref
+    """
+    if isinstance(callable, RuntimeFunction):
+        return FunctionRef(callable.__egg_name__)
+    if isinstance(callable, RuntimeClassMethod):
+        return ClassMethodRef(callable.class_name, callable.__egg_method_name__)
+    if isinstance(callable, RuntimeMethod):
+        return MethodRef(callable.__egg_typed_expr__.tp.name, callable.__egg_method_name__)
+    if isinstance(callable, RuntimeClass):
+        return ClassMethodRef(callable.__egg_name__, "__init__")
+    raise NotImplementedError(f"Cannot turn {callable} into a callable ref")