Function leancallable_call

LeanPy/native/python_bridge.c:933–1018

static PyObject *leancallable_repr(PyObject *self_) {
    LeanCallableObject *self = (LeanCallableObject *)self_;
    char buf[128];
    snprintf(buf, sizeof(buf),
             "<LeanCallable%s @ %p>",
             self->has_kw ? "Kw" : "",
             (void *)self->closure);
    return p_PyUnicode_DecodeUTF8(buf, (Py_ssize_t)strlen(buf), NULL);
}

static PyObject *leancallable_call(PyObject *self_, PyObject *args, PyObject *kwds) {
    LeanCallableObject *self = (LeanCallableObject *)self_;
    if (!self->closure) {
        if (p_PyErr_SetString && p_PyExc_RuntimeError) {
            p_PyErr_SetString(p_PyExc_RuntimeError,
                              "LeanCallable: closure has been freed");
        }
        return NULL;
    }

    Py_ssize_t n = p_PyTuple_Size(args);
    if (n < 0) return NULL;

    /* Build `Array Py` from positional args. */
    lean_object *arr = lean_alloc_array((size_t)n, (size_t)n);
    for (Py_ssize_t i = 0; i < n; i++) {
        PyObject *po = p_PyTuple_GetItem(args, i); /* borrowed */
        p_Py_IncRef(po);                           /* +1 for wrapper */
        lean_object *wrapped = wrap_pyobject(po);
        lean_array_set_core(arr, (size_t)i, wrapped);
    }

    /* Bump closure ref so the Lean apply consumer doesn't free our
     * captured reference. */
    lean_inc(self->closure);
    lean_object *result = NULL;

    if (self->has_kw) {
        Py_ssize_t kn = (kwds && p_PyDict_Size) ? p_PyDict_Size(kwds) : 0;
        if (kn < 0) kn = 0;
        lean_object *kwarr = lean_alloc_array((size_t)kn, (size_t)kn);
        if (kn > 0) {
            Py_ssize_t pos = 0;
            PyObject *k = NULL, *v = NULL;
            size_t idx = 0;
            while (p_PyDict_Next(kwds, &pos, &k, &v)) {
                const char *cs = p_PyUnicode_AsUTF8(k);
                if (!cs) cs = "";
                lean_object *key_str = lean_mk_string(cs);
                p_Py_IncRef(v);
                lean_object *val_py = wrap_pyobject(v);
                lean_object *pair = lean_alloc_ctor(0, 2, 0);
                lean_ctor_set(pair, 0, key_str);
                lean_ctor_set(pair, 1, val_py);
                lean_array_set_core(kwarr, idx++, pair);
            }
        }
        result = lean_apply_3(self->closure, arr, kwarr, lean_box(0));
    } else {
        result = lean_apply_2(self->closure, arr, lean_box(0));