standard_impl.h

Go to the documentation of this file.

#ifndef REDUCT_STDLIB_IMPL_H
#define REDUCT_STDLIB_IMPL_H 1
 
#include "char.h"
#include "compile.h"
#include "core.h"
#include "defs.h"
#include "eval.h"
#include "gc.h"
#include "handle.h"
#include "item.h"
#include "native.h"
#include "parse.h"
#include "standard.h"
#include "stringify.h"
 
REDUCT_API reduct_handle_t reduct_assert(reduct_t* reduct, reduct_handle_t* cond, reduct_handle_t* msg)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    if (!REDUCT_HANDLE_IS_TRUTHY(cond))
    {
        char* str;
        reduct_size_t len;
        reduct_handle_get_string_params(reduct, msg, &str, &len);
        REDUCT_ERROR_RUNTIME(reduct, "assert failed: %s", str);
    }
 
    return *cond;
}
 
REDUCT_API reduct_handle_t reduct_throw(reduct_t* reduct, reduct_handle_t* msg)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    char* str;
    reduct_size_t len;
    reduct_handle_get_string_params(reduct, msg, &str, &len);
    REDUCT_ERROR_RUNTIME(reduct, "%s", str);
 
    return reduct_handle_nil(reduct);
}
 
REDUCT_API reduct_handle_t reduct_try(reduct_t* reduct, reduct_handle_t* callable, reduct_handle_t* catchFn)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    REDUCT_ERROR_CHECK_CALLABLE(reduct, callable, "try");
    REDUCT_ERROR_CHECK_CALLABLE(reduct, catchFn, "try");
 
    reduct_error_t* prev = reduct->error;
 
    reduct_error_t error = REDUCT_ERROR();
    if (REDUCT_ERROR_CATCH(&error))
    {
        reduct_handle_t msg = REDUCT_HANDLE_FROM_ATOM(
            reduct_atom_lookup(reduct, error.message, REDUCT_STRLEN(error.message), REDUCT_ATOM_LOOKUP_NONE));
        reduct_handle_t result = reduct_eval_call(reduct, *catchFn, 1, &msg);
        reduct->error = prev;
        return result;
    }
 
    reduct_handle_t result = reduct_eval_call(reduct, *callable, 0, REDUCT_NULL);
    reduct->error = prev;
    return result;
}
 
REDUCT_API reduct_handle_t reduct_map(reduct_t* reduct, reduct_handle_t* list, reduct_handle_t* callable)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ERROR_CHECK_LIST(reduct, list, "map");
    REDUCT_ERROR_CHECK_CALLABLE(reduct, callable, "map");
 
    reduct_item_t* listItem = REDUCT_HANDLE_TO_ITEM(list);
 
    reduct_list_t* mappedList = reduct_list_new(reduct);
    reduct_handle_t mappedHandle = REDUCT_HANDLE_FROM_LIST(mappedList);
    REDUCT_GC_RETAIN(reduct, mappedHandle);
 
    reduct_handle_t entry;
    REDUCT_LIST_FOR_EACH(&entry, &listItem->list)
    {
        reduct_handle_t result = reduct_eval_call(reduct, *callable, 1, &entry);
        reduct_list_append(reduct, mappedList, result);
    }
 
    REDUCT_GC_RELEASE(reduct, mappedHandle);
    return mappedHandle;
}
 
REDUCT_API reduct_handle_t reduct_filter(reduct_t* reduct, reduct_handle_t* list, reduct_handle_t* callable)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ERROR_CHECK_LIST(reduct, list, "filter");
    REDUCT_ERROR_CHECK_CALLABLE(reduct, callable, "filter");
 
    reduct_item_t* listItem = REDUCT_HANDLE_TO_ITEM(list);
 
    reduct_list_t* filteredList = reduct_list_new(reduct);
    reduct_handle_t filteredHandle = REDUCT_HANDLE_FROM_LIST(filteredList);
    REDUCT_GC_RETAIN(reduct, filteredHandle);
 
    reduct_handle_t entry;
    REDUCT_LIST_FOR_EACH(&entry, &listItem->list)
    {
        reduct_handle_t result = reduct_eval_call(reduct, *callable, 1, &entry);
        if (REDUCT_HANDLE_IS_TRUTHY(&result))
        {
            reduct_list_append(reduct, filteredList, entry);
        }
    }
 
    REDUCT_GC_RELEASE(reduct, filteredHandle);
    return filteredHandle;
}
 
REDUCT_API reduct_handle_t reduct_reduce(reduct_t* reduct, reduct_handle_t* list, reduct_handle_t* initial,
    reduct_handle_t* callable)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ERROR_CHECK_LIST(reduct, list, "reduce");
    REDUCT_ERROR_CHECK_CALLABLE(reduct, callable, "reduce");
 
    reduct_item_t* listItem = REDUCT_HANDLE_TO_ITEM(list);
    reduct_handle_t accumulator = (initial != REDUCT_NULL) ? *initial : REDUCT_HANDLE_NONE;
 
    reduct_handle_t entry;
    REDUCT_LIST_FOR_EACH(&entry, &listItem->list)
    {
        if (accumulator == REDUCT_HANDLE_NONE)
        {
            accumulator = entry;
            REDUCT_GC_RETAIN(reduct, accumulator);
            continue;
        }
 
        reduct_handle_t args[2] = {accumulator, entry};
        reduct_handle_t result = reduct_eval_call(reduct, *callable, 2, args);
        REDUCT_GC_RETAIN(reduct, result);
 
        REDUCT_GC_RELEASE(reduct, accumulator);
        accumulator = result;
    }
 
    if (accumulator == REDUCT_HANDLE_NONE)
    {
        return reduct_handle_nil(reduct);
    }
 
    REDUCT_GC_RELEASE(reduct, accumulator);
    return accumulator;
}
 
REDUCT_API reduct_handle_t reduct_apply(reduct_t* reduct, reduct_handle_t* list, reduct_handle_t* callable)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ERROR_CHECK_LIST(reduct, list, "apply");
    REDUCT_ERROR_CHECK_CALLABLE(reduct, callable, "apply");
 
    reduct_item_t* listItem = REDUCT_HANDLE_TO_ITEM(list);
    reduct_size_t len = listItem->length;
    if (len == 0)
    {
        return reduct_eval_call(reduct, *callable, 0, REDUCT_NULL);
    }
 
    reduct_handle_t stackBuffer[REDUCT_STACK_BUFFER_SIZE];
    reduct_handle_t* argv = (len <= REDUCT_STACK_BUFFER_SIZE)
        ? stackBuffer
        : (reduct_handle_t*)REDUCT_MALLOC(len * sizeof(reduct_handle_t));
 
    if (argv == REDUCT_NULL)
    {
        REDUCT_ERROR_INTERNAL(reduct, "out of memory");
    }
 
    reduct_handle_t entry;
    REDUCT_LIST_FOR_EACH(&entry, &listItem->list)
    {
        argv[_iter.index - 1] = entry;
    }
 
    reduct_handle_t result = reduct_eval_call(reduct, *callable, len, argv);
 
    if (argv != stackBuffer)
    {
        REDUCT_FREE(argv);
    }
 
    return result;
}
 
static inline reduct_handle_t reduct_eval_maybe_call(reduct_t* reduct, reduct_handle_t fn, reduct_handle_t* arg)
{
    if (fn == REDUCT_HANDLE_NONE)
    {
        return *arg;
    }
    else
    {
        return reduct_eval_call(reduct, fn, 1, arg);
    }
}
 
#define REDUCT_ANY_ALL_IMPL(_name, _predicate, _default) \
    REDUCT_API reduct_handle_t _name(reduct_t* reduct, reduct_handle_t* list, reduct_handle_t* callable) \
    { \
        REDUCT_ASSERT(reduct != REDUCT_NULL); \
        REDUCT_ERROR_CHECK_LIST(reduct, list, #_name); \
        reduct_item_t* listItem = REDUCT_HANDLE_TO_ITEM(list); \
        reduct_handle_t fn = (callable != REDUCT_NULL) ? *callable : REDUCT_HANDLE_NONE; \
        reduct_handle_t entry; \
        REDUCT_LIST_FOR_EACH(&entry, &listItem->list) \
        { \
            reduct_handle_t result = reduct_eval_maybe_call(reduct, fn, &entry); \
            REDUCT_GC_RETAIN(reduct, result); \
            if (_predicate) \
            { \
                REDUCT_GC_RELEASE(reduct, result); \
                return REDUCT_HANDLE_FROM_INT(!(_default)); \
            } \
            REDUCT_GC_RELEASE(reduct, result); \
        } \
        return REDUCT_HANDLE_FROM_INT(_default); \
    }
 
REDUCT_ANY_ALL_IMPL(reduct_any, REDUCT_HANDLE_IS_TRUTHY(&result), REDUCT_FALSE)
REDUCT_ANY_ALL_IMPL(reduct_all, !REDUCT_HANDLE_IS_TRUTHY(&result), REDUCT_TRUE)
 
static void reduct_sort_merge(reduct_t* reduct, reduct_handle_t callable, reduct_handle_t* a, reduct_size_t left,
    reduct_size_t right, reduct_size_t end, reduct_handle_t* b)
{
    reduct_size_t i = left;
    reduct_size_t j = right;
 
    for (reduct_size_t k = left; k < end; k++)
    {
        reduct_bool_t useLeft = REDUCT_FALSE;
        if (i < right)
        {
            if (j >= end)
            {
                useLeft = REDUCT_TRUE;
            }
            else
            {
                if (callable != REDUCT_HANDLE_NONE)
                {
                    reduct_handle_t args[2] = {a[i], a[j]};
                    reduct_handle_t res = reduct_eval_call(reduct, callable, 2, args);
                    if (REDUCT_HANDLE_IS_TRUTHY(&res))
                    {
                        useLeft = REDUCT_TRUE;
                    }
                }
                else
                {
                    if (reduct_handle_compare(reduct, &a[i], &a[j]) <= 0)
                    {
                        useLeft = REDUCT_TRUE;
                    }
                }
            }
        }
 
        if (useLeft)
        {
            b[k] = a[i];
            i++;
        }
        else
        {
            b[k] = a[j];
            j++;
        }
    }
}
 
REDUCT_API reduct_handle_t reduct_sort(reduct_t* reduct, reduct_handle_t* listHandle, reduct_handle_t* callableHandle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ASSERT(listHandle != REDUCT_NULL);
 
    REDUCT_ERROR_CHECK_LIST(reduct, listHandle, "sort");
    reduct_item_t* list = REDUCT_HANDLE_TO_ITEM(listHandle);
 
    reduct_handle_t callable = (callableHandle != REDUCT_NULL) ? *callableHandle : REDUCT_HANDLE_NONE;
    if (callable != REDUCT_HANDLE_NONE)
    {
        REDUCT_ERROR_CHECK_CALLABLE(reduct, &callable, "sort");
    }
 
    reduct_size_t len = list->length;
    if (len <= 1)
    {
        return *listHandle;
    }
 
    reduct_handle_t* a = (reduct_handle_t*)REDUCT_MALLOC(len * sizeof(reduct_handle_t));
    if (a == REDUCT_NULL)
    {
        REDUCT_ERROR_INTERNAL(reduct, "out of memory");
    }
 
    reduct_handle_t* b = (reduct_handle_t*)REDUCT_MALLOC(len * sizeof(reduct_handle_t));
    if (b == REDUCT_NULL)
    {
        REDUCT_FREE(a);
        REDUCT_ERROR_INTERNAL(reduct, "out of memory");
    }
 
    reduct_handle_t entry;
    REDUCT_LIST_FOR_EACH(&entry, &list->list)
    {
        a[_iter.index - 1] = entry;
    }
 
    reduct_handle_t* src = a;
    reduct_handle_t* dst = b;
    for (reduct_size_t width = 1; width < list->length; width *= 2)
    {
        for (reduct_size_t i = 0; i < list->length; i += 2 * width)
        {
            reduct_size_t left = i;
            reduct_size_t right = REDUCT_MIN(i + width, len);
            reduct_size_t end = REDUCT_MIN(i + 2 * width, len);
            reduct_sort_merge(reduct, callable, src, left, right, end, dst);
        }
        reduct_handle_t* temp = src;
        src = dst;
        dst = temp;
    }
 
    reduct_list_t* resultList = reduct_list_new(reduct);
    reduct_handle_t resultHandle = REDUCT_HANDLE_FROM_LIST(resultList);
    REDUCT_GC_RETAIN(reduct, resultHandle);
 
    for (reduct_size_t i = 0; i < len; i++)
    {
        reduct_list_append(reduct, resultList, src[i]);
    }
 
    REDUCT_FREE(a);
    REDUCT_FREE(b);
    REDUCT_GC_RELEASE(reduct, resultHandle);
    return resultHandle;
}
 
static inline reduct_int64_t reduct_handle_normalize_index(reduct_t* reduct, reduct_handle_t* index,
    reduct_size_t length)
{
    reduct_handle_t nHandle = reduct_get_int(reduct, index);
    reduct_int64_t n = REDUCT_HANDLE_TO_INT(&nHandle);
    if (n < 0)
    {
        n = (reduct_int64_t)length + n;
    }
    return n;
}
 
static inline void reduct_sequence_normalize_range(reduct_t* reduct, reduct_handle_t* startH, reduct_handle_t* endH,
    reduct_size_t length, reduct_size_t* outStart, reduct_size_t* outEnd)
{
    reduct_int64_t start = reduct_handle_normalize_index(reduct, startH, length);
    reduct_int64_t end;
 
    if (endH != REDUCT_NULL)
    {
        end = reduct_handle_normalize_index(reduct, endH, length);
    }
    else
    {
        end = (reduct_int64_t)length;
    }
 
    start = REDUCT_MAX(0, REDUCT_MIN(start, (reduct_int64_t)length));
    end = REDUCT_MAX(0, REDUCT_MIN(end, (reduct_int64_t)length));
 
    *outStart = (reduct_size_t)start;
    *outEnd = (reduct_size_t)end;
}
 
static inline reduct_handle_t reduct_list_find_entry(reduct_t* reduct, reduct_item_t* listItem, reduct_handle_t* key)
{
    reduct_handle_t entryH;
    REDUCT_LIST_FOR_EACH(&entryH, &listItem->list)
    {
        if (REDUCT_HANDLE_IS_LIST(&entryH))
        {
            reduct_item_t* entry = REDUCT_HANDLE_TO_ITEM(&entryH);
            if (entry->length >= 1)
            {
                reduct_handle_t entryKey = reduct_list_nth(reduct, &entry->list, 0);
                if (reduct_handle_compare(reduct, &entryKey, key) == 0)
                {
                    return entryH;
                }
            }
        }
    }
    return REDUCT_HANDLE_NONE;
}
 
static inline reduct_bool_t reduct_list_get_entry(reduct_t* reduct, reduct_handle_t* entryH, reduct_handle_t* outKey,
    reduct_handle_t* outVal)
{
    if (!REDUCT_HANDLE_IS_LIST(entryH))
    {
        return REDUCT_FALSE;
    }
    reduct_item_t* entry = REDUCT_HANDLE_TO_ITEM(entryH);
    if (entry->length < 1)
    {
        return REDUCT_FALSE;
    }
 
    if (outKey != REDUCT_NULL)
    {
        *outKey = reduct_list_nth(reduct, &entry->list, 0);
    }
 
    if (outVal != REDUCT_NULL)
    {
        *outVal = (entry->length >= 2) ? reduct_list_nth(reduct, &entry->list, 1) : reduct_handle_nil(reduct);
    }
    return REDUCT_TRUE;
}
 
REDUCT_API reduct_handle_t reduct_len(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ASSERT(argv != REDUCT_NULL || argc == 0);
 
    reduct_size_t total = 0;
    for (reduct_size_t i = 0; i < argc; i++)
    {
        total += reduct_handle_item(reduct, &argv[i])->length;
    }
    return REDUCT_HANDLE_FROM_INT(total);
}
 
REDUCT_API reduct_handle_t reduct_range(struct reduct* reduct, reduct_handle_t* start, reduct_handle_t* end,
    reduct_handle_t* step)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_handle_t startH = reduct_get_int(reduct, start);
    reduct_handle_t endH = reduct_get_int(reduct, end);
    reduct_handle_t stepH = (step != REDUCT_NULL) ? reduct_get_int(reduct, step) : REDUCT_HANDLE_FROM_INT(1);
 
    reduct_int64_t startVal = REDUCT_HANDLE_TO_INT(&startH);
    reduct_int64_t endVal = REDUCT_HANDLE_TO_INT(&endH);
    reduct_int64_t stepVal = REDUCT_HANDLE_TO_INT(&stepH);
 
    if (stepVal == 0)
    {
        REDUCT_ERROR_RUNTIME(reduct, "range step cannot be 0");
    }
 
    reduct_size_t count = 0;
    if (stepVal > 0)
    {
        if (endVal > startVal)
        {
            count = (reduct_size_t)((endVal - startVal + stepVal - 1) / stepVal);
        }
    }
    else
    {
        if (startVal > endVal)
        {
            count = (reduct_size_t)((startVal - endVal - stepVal - 1) / -stepVal);
        }
    }
 
    reduct_list_t* list = reduct_list_new(reduct);
    reduct_handle_t listHandle = REDUCT_HANDLE_FROM_LIST(list);
    REDUCT_GC_RETAIN(reduct, listHandle);
 
    reduct_int64_t current = startVal;
    for (reduct_size_t i = 0; i < count; i++)
    {
        reduct_list_append(reduct, list, REDUCT_HANDLE_FROM_INT(current));
        current += stepVal;
    }
 
    REDUCT_GC_RELEASE(reduct, listHandle);
    return listHandle;
}
 
REDUCT_API reduct_handle_t reduct_concat(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ASSERT(argv != REDUCT_NULL || argc == 0);
 
    reduct_bool_t resultIsList = REDUCT_FALSE;
    reduct_size_t totalLen = 0;
 
    for (reduct_size_t i = 0; i < argc; i++)
    {
        if (REDUCT_HANDLE_IS_LIST(&argv[i]))
        {
            resultIsList = REDUCT_TRUE;
        }
        totalLen += reduct_handle_item(reduct, &argv[i])->length;
    }
 
    if (resultIsList)
    {
        reduct_list_t* newList = reduct_list_new(reduct);
        reduct_handle_t newHandle = REDUCT_HANDLE_FROM_LIST(newList);
        REDUCT_GC_RETAIN(reduct, newHandle);
 
        for (reduct_size_t i = 0; i < argc; i++)
        {
            if (REDUCT_HANDLE_IS_LIST(&argv[i]))
            {
                reduct_list_append_list(reduct, newList, &REDUCT_HANDLE_TO_ITEM(&argv[i])->list);
            }
            else
            {
                reduct_list_append(reduct, newList, argv[i]);
            }
        }
 
        REDUCT_GC_RELEASE(reduct, newHandle);
        return newHandle;
    }
 
    REDUCT_SCRATCH_BUFFER(buffer, totalLen);
 
    reduct_size_t currentPos = 0;
    for (reduct_size_t i = 0; i < argc; i++)
    {
        char* str;
        reduct_size_t len;
        reduct_handle_get_string_params(reduct, &argv[i], &str, &len);
        REDUCT_MEMCPY(buffer + currentPos, str, len);
        currentPos += len;
    }
 
    reduct_handle_t result =
        REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, totalLen, REDUCT_ATOM_LOOKUP_NONE));
    REDUCT_SCRATCH_BUFFER_FREE(buffer);
    return result;
}
 
static inline reduct_handle_t reduct_sequence_edge(reduct_t* reduct, reduct_handle_t* handle, reduct_bool_t first)
{
    reduct_item_t* item = reduct_handle_item(reduct, handle);
 
    if (item->length == 0)
    {
        return reduct_handle_nil(reduct);
    }
 
    reduct_size_t index = first ? 0 : item->length - 1;
 
    if (item->type == REDUCT_ITEM_TYPE_LIST)
    {
        return reduct_list_nth(reduct, &item->list, index);
    }
    else
    {
        return REDUCT_HANDLE_FROM_ATOM(
            reduct_atom_lookup(reduct, item->atom.string + index, 1, REDUCT_ATOM_LOOKUP_NONE));
    }
}
 
REDUCT_API reduct_handle_t reduct_first(reduct_t* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ERROR_CHECK_SEQUENCE(reduct, handle, "first");
    return reduct_sequence_edge(reduct, handle, REDUCT_TRUE);
}
 
REDUCT_API reduct_handle_t reduct_last(reduct_t* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ERROR_CHECK_SEQUENCE(reduct, handle, "last");
    return reduct_sequence_edge(reduct, handle, REDUCT_FALSE);
}
 
static inline reduct_handle_t reduct_sequence_trim(reduct_t* reduct, reduct_handle_t* handle, reduct_bool_t rest)
{
    reduct_item_t* item = reduct_handle_item(reduct, handle);
 
    if (item->length <= 1)
    {
        return reduct_handle_nil(reduct);
    }
 
    reduct_size_t start = rest ? 1 : 0;
    reduct_size_t end = rest ? item->length : item->length - 1;
 
    if (item->type == REDUCT_ITEM_TYPE_LIST)
    {
        return REDUCT_HANDLE_FROM_LIST(reduct_list_slice(reduct, &item->list, start, end));
    }
    else
    {
        return REDUCT_HANDLE_FROM_ATOM(
            reduct_atom_lookup(reduct, item->atom.string + start, end - start, REDUCT_ATOM_LOOKUP_NONE));
    }
}
 
REDUCT_API reduct_handle_t reduct_rest(reduct_t* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ERROR_CHECK_SEQUENCE(reduct, handle, "rest");
    return reduct_sequence_trim(reduct, handle, REDUCT_TRUE);
}
 
REDUCT_API reduct_handle_t reduct_init(reduct_t* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ERROR_CHECK_SEQUENCE(reduct, handle, "init");
    return reduct_sequence_trim(reduct, handle, REDUCT_FALSE);
}
 
REDUCT_API reduct_handle_t reduct_nth(reduct_t* reduct, reduct_handle_t* handle, reduct_handle_t* index,
    reduct_handle_t* defaultVal)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ERROR_CHECK_SEQUENCE(reduct, handle, "nth");
 
    reduct_item_t* item = reduct_handle_item(reduct, handle);
 
    reduct_int64_t n = reduct_handle_normalize_index(reduct, index, item->length);
 
    if (n < 0 || n >= (reduct_int64_t)item->length)
    {
        return (defaultVal != REDUCT_NULL) ? *defaultVal : reduct_handle_nil(reduct);
    }
 
    if (item->type == REDUCT_ITEM_TYPE_LIST)
    {
        return reduct_list_nth(reduct, &item->list, (reduct_size_t)n);
    }
    else
    {
        return REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, item->atom.string + n, 1, REDUCT_ATOM_LOOKUP_NONE));
    }
}
 
static inline char reduct_handle_get_char(reduct_t* reduct, reduct_handle_t* handle, char defaultChar)
{
    char* str;
    reduct_size_t len;
    reduct_handle_get_string_params(reduct, handle, &str, &len);
    return (len > 0) ? str[0] : defaultChar;
}
 
REDUCT_API reduct_handle_t reduct_assoc(reduct_t* reduct, reduct_handle_t* handle, reduct_handle_t* index,
    reduct_handle_t* value, reduct_handle_t* fillVal)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_item_t* item = reduct_handle_item(reduct, handle);
 
    reduct_int64_t n = reduct_handle_normalize_index(reduct, index, item->length);
    if (n < 0)
    {
        n = 0;
    }
 
    reduct_size_t targetIndex = (reduct_size_t)n;
 
    if (targetIndex >= item->length && fillVal == REDUCT_NULL)
    {
        REDUCT_ERROR_RUNTIME(reduct, "assoc index %zu out of bounds", targetIndex);
    }
 
    switch (item->type)
    {
    case REDUCT_ITEM_TYPE_LIST:
    {
        if (targetIndex < item->length)
        {
            reduct_list_t* newList = reduct_list_assoc(reduct, &item->list, targetIndex, *value);
            return REDUCT_HANDLE_FROM_LIST(newList);
        }
 
        reduct_list_t* newList = reduct_list_new(reduct);
        reduct_handle_t newListH = REDUCT_HANDLE_FROM_LIST(newList);
        REDUCT_GC_RETAIN(reduct, newListH);
        reduct_list_append_list(reduct, newList, &item->list);
        for (reduct_size_t i = item->length; i < targetIndex; i++)
        {
            reduct_list_append(reduct, newList, *fillVal);
        }
        reduct_list_append(reduct, newList, *value);
        REDUCT_GC_RELEASE(reduct, newListH);
        return newListH;
    }
    case REDUCT_ITEM_TYPE_ATOM:
    {
        char charToPut = reduct_handle_get_char(reduct, value, '\0');
        char padChar = (fillVal != REDUCT_NULL) ? reduct_handle_get_char(reduct, fillVal, ' ') : ' ';
 
        reduct_size_t newLen = REDUCT_MAX(item->length, targetIndex + 1);
 
        REDUCT_SCRATCH_BUFFER(buffer, newLen);
 
        reduct_size_t prefixLen = REDUCT_MIN(item->length, targetIndex);
        REDUCT_MEMCPY(buffer, item->atom.string, prefixLen);
        for (reduct_size_t i = item->length; i < targetIndex; i++)
        {
            buffer[i] = padChar;
        }
        buffer[targetIndex] = charToPut;
        if (targetIndex + 1 < item->length)
        {
            reduct_size_t suffixLen = item->length - (targetIndex + 1);
            REDUCT_MEMCPY(buffer + targetIndex + 1, item->atom.string + targetIndex + 1, suffixLen);
        }
 
        reduct_handle_t result =
            REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, newLen, REDUCT_ATOM_LOOKUP_NONE));
        REDUCT_SCRATCH_BUFFER_FREE(buffer);
        return result;
    }
    default:
        REDUCT_ERROR_RUNTIME(reduct, "assoc expected list or atom, got %s", reduct_item_type_str(item->type));
    }
}
 
REDUCT_API reduct_handle_t reduct_dissoc(struct reduct* reduct, reduct_handle_t* handle, reduct_handle_t* index)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_item_t* item = reduct_handle_item(reduct, handle);
 
    reduct_int64_t n = reduct_handle_normalize_index(reduct, index, item->length);
 
    if (n < 0 || n >= (reduct_int64_t)item->length)
    {
        return *handle;
    }
 
    reduct_size_t targetIndex = (reduct_size_t)n;
    reduct_size_t newLen = item->length - 1;
 
    switch (item->type)
    {
    case REDUCT_ITEM_TYPE_LIST:
    {
        reduct_list_t* newList = reduct_list_dissoc(reduct, &item->list, targetIndex);
        return REDUCT_HANDLE_FROM_LIST(newList);
    }
    case REDUCT_ITEM_TYPE_ATOM:
    {
        REDUCT_SCRATCH_BUFFER(buffer, newLen);
 
        REDUCT_MEMCPY(buffer, item->atom.string, targetIndex);
        REDUCT_MEMCPY(buffer + targetIndex, item->atom.string + targetIndex + 1, item->length - targetIndex - 1);
 
        reduct_handle_t result =
            REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, newLen, REDUCT_ATOM_LOOKUP_NONE));
        REDUCT_SCRATCH_BUFFER_FREE(buffer);
        return result;
    }
    default:
        REDUCT_ERROR_RUNTIME(reduct, "dissoc expected list or atom, got %s", reduct_item_type_str(item->type));
    }
}
 
REDUCT_API reduct_handle_t reduct_update(reduct_t* reduct, reduct_handle_t* handle, reduct_handle_t* index,
    reduct_handle_t* callable, reduct_handle_t* fillVal)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_item_t* item = reduct_handle_item(reduct, handle);
 
    reduct_int64_t targetIndex = reduct_handle_normalize_index(reduct, index, item->length);
    if (targetIndex < 0)
    {
        targetIndex = 0;
    }
 
    if ((reduct_size_t)targetIndex >= item->length && fillVal == REDUCT_NULL)
    {
        REDUCT_ERROR_RUNTIME(reduct, "update index %lld out of bounds", (long long)targetIndex);
    }
 
    reduct_handle_t currentVal = reduct_nth(reduct, handle, index, fillVal);
    reduct_handle_t newVal = reduct_eval_call(reduct, *callable, 1, &currentVal);
 
    return reduct_assoc(reduct, handle, index, &newVal, fillVal);
}
 
REDUCT_API reduct_handle_t reduct_index_of(reduct_t* reduct, reduct_handle_t* handle, reduct_handle_t* target)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_item_t* item = reduct_handle_item(reduct, handle);
 
    switch (item->type)
    {
    case REDUCT_ITEM_TYPE_LIST:
    {
        reduct_handle_t current;
        REDUCT_LIST_FOR_EACH(&current, &item->list)
        {
            if (reduct_handle_compare(reduct, &current, target) == 0)
            {
                return REDUCT_HANDLE_FROM_INT(_iter.index - 1);
            }
        }
    }
    break;
    case REDUCT_ITEM_TYPE_ATOM:
    {
        char* targetStr;
        reduct_size_t targetLen;
        reduct_handle_get_string_params(reduct, target, &targetStr, &targetLen);
 
        if (targetLen == 0)
        {
            return REDUCT_HANDLE_FROM_INT(0);
        }
 
        if (targetLen <= item->length)
        {
            for (reduct_size_t i = 0; i <= item->length - targetLen; i++)
            {
                if (REDUCT_MEMCMP(item->atom.string + i, targetStr, targetLen) == 0)
                {
                    return REDUCT_HANDLE_FROM_INT(i);
                }
            }
        }
        break;
    }
    default:
        REDUCT_ERROR_RUNTIME(reduct, "index-of expected list or atom, got %s", reduct_item_type_str(item->type));
    }
 
    return reduct_handle_nil(reduct);
}
 
REDUCT_API reduct_handle_t reduct_reverse(reduct_t* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_item_t* item = reduct_handle_item(reduct, handle);
 
    if (item->length <= 1)
    {
        return *handle;
    }
 
    switch (item->type)
    {
    case REDUCT_ITEM_TYPE_LIST:
    {
        reduct_list_t* newList = reduct_list_new(reduct);
        reduct_handle_t newHandle = REDUCT_HANDLE_FROM_LIST(newList);
        REDUCT_GC_RETAIN(reduct, newHandle);
 
        reduct_size_t i = item->length;
        while (i > 0)
        {
            reduct_list_append(reduct, newList, reduct_list_nth(reduct, &item->list, --i));
        }
 
        REDUCT_GC_RELEASE(reduct, newHandle);
        return newHandle;
    }
    case REDUCT_ITEM_TYPE_ATOM:
    {
        REDUCT_SCRATCH_BUFFER(buffer, item->length);
 
        for (reduct_size_t i = 0; i < item->length; i++)
        {
            buffer[i] = item->atom.string[item->length - 1 - i];
        }
 
        reduct_handle_t result =
            REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, item->length, REDUCT_ATOM_LOOKUP_NONE));
        REDUCT_SCRATCH_BUFFER_FREE(buffer);
        return result;
    }
    default:
        REDUCT_ERROR_RUNTIME(reduct, "reverse expected list or atom, got %s", reduct_item_type_str(item->type));
    }
}
 
REDUCT_API reduct_handle_t reduct_slice(reduct_t* reduct, reduct_handle_t* handle, reduct_handle_t* startH,
    reduct_handle_t* endH)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ASSERT(handle != REDUCT_NULL);
    REDUCT_ASSERT(startH != REDUCT_NULL);
 
    reduct_item_t* item = reduct_handle_item(reduct, handle);
    reduct_size_t start, end;
    reduct_sequence_normalize_range(reduct, startH, endH, item->length, &start, &end);
 
    if (start >= end)
    {
        return reduct_handle_nil(reduct);
    }
 
    switch (item->type)
    {
    case REDUCT_ITEM_TYPE_LIST:
    {
        return REDUCT_HANDLE_FROM_LIST(reduct_list_slice(reduct, &item->list, start, end));
    }
    case REDUCT_ITEM_TYPE_ATOM:
    {
        return REDUCT_HANDLE_FROM_ATOM(
            reduct_atom_lookup(reduct, item->atom.string + start, end - start, REDUCT_ATOM_LOOKUP_NONE));
    }
    default:
        REDUCT_ERROR_RUNTIME(reduct, "slice expected list or atom, got %s", reduct_item_type_str(item->type));
    }
}
 
REDUCT_API reduct_handle_t reduct_flatten(struct reduct* reduct, reduct_handle_t* handle, reduct_handle_t* depthH)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    if (!REDUCT_HANDLE_IS_LIST(handle))
    {
        return *handle;
    }
 
    reduct_int64_t depth = -1;
    if (depthH != REDUCT_NULL)
    {
        reduct_handle_t d = reduct_get_int(reduct, depthH);
        depth = REDUCT_HANDLE_TO_INT(&d);
    }
 
    if (depth == 0)
    {
        return *handle;
    }
 
    reduct_item_t* item = REDUCT_HANDLE_TO_ITEM(handle);
    reduct_list_t* newList = reduct_list_new(reduct);
    reduct_handle_t newHandle = REDUCT_HANDLE_FROM_LIST(newList);
    REDUCT_GC_RETAIN(reduct, newHandle);
 
    reduct_handle_t current;
    REDUCT_LIST_FOR_EACH(&current, &item->list)
    {
        if (REDUCT_HANDLE_IS_LIST(&current))
        {
            reduct_handle_t nextDepthH = REDUCT_HANDLE_FROM_INT(depth - 1);
            reduct_handle_t flattened = reduct_flatten(reduct, &current, &nextDepthH);
            REDUCT_GC_RETAIN(reduct, flattened);
 
            if (REDUCT_HANDLE_IS_LIST(&flattened))
            {
                reduct_list_append_list(reduct, newList, &REDUCT_HANDLE_TO_ITEM(&flattened)->list);
            }
            else if (flattened != reduct_handle_nil(reduct))
            {
                reduct_list_append(reduct, newList, flattened);
            }
            REDUCT_GC_RELEASE(reduct, flattened);
        }
        else
        {
            reduct_list_append(reduct, newList, current);
        }
    }
 
    REDUCT_GC_RELEASE(reduct, newHandle);
    return newHandle;
}
 
REDUCT_API reduct_handle_t reduct_contains(struct reduct* reduct, reduct_handle_t* handle, reduct_handle_t* target)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    reduct_handle_t index = reduct_index_of(reduct, handle, target);
    return REDUCT_HANDLE_FROM_BOOL(index != reduct_handle_nil(reduct));
}
 
REDUCT_API reduct_handle_t reduct_replace(struct reduct* reduct, reduct_handle_t* handle, reduct_handle_t* oldVal,
    reduct_handle_t* newVal)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    reduct_item_t* item = reduct_handle_item(reduct, handle);
 
    switch (item->type)
    {
    case REDUCT_ITEM_TYPE_LIST:
    {
        reduct_list_t* newList = reduct_list_new(reduct);
        reduct_handle_t newHandle = REDUCT_HANDLE_FROM_LIST(newList);
        REDUCT_GC_RETAIN(reduct, newHandle);
 
        reduct_handle_t entry;
        REDUCT_LIST_FOR_EACH(&entry, &item->list)
        {
            if (reduct_handle_compare(reduct, &entry, oldVal) == 0)
            {
                reduct_list_append(reduct, newList, *newVal);
            }
            else
            {
                reduct_list_append(reduct, newList, entry);
            }
        }
 
        REDUCT_GC_RELEASE(reduct, newHandle);
        return newHandle;
    }
    case REDUCT_ITEM_TYPE_ATOM:
    {
        char* oldStr;
        reduct_size_t oldLen;
        reduct_handle_get_string_params(reduct, oldVal, &oldStr, &oldLen);
 
        char* newStr;
        reduct_size_t newLen;
        reduct_handle_get_string_params(reduct, newVal, &newStr, &newLen);
 
        if (oldLen == 0)
        {
            return *handle;
        }
 
        reduct_size_t count = 0;
        for (reduct_size_t i = 0; i <= item->length - oldLen; i++)
        {
            if (REDUCT_MEMCMP(item->atom.string + i, oldStr, oldLen) == 0)
            {
                count++;
                i += oldLen - 1;
            }
        }
 
        if (count == 0)
        {
            return *handle;
        }
 
        reduct_size_t resultLen = item->length + (count * (newLen - oldLen));
        char* buffer = (char*)REDUCT_MALLOC(resultLen);
        if (buffer == REDUCT_NULL)
        {
            REDUCT_ERROR_INTERNAL(reduct, "out of memory");
        }
 
        reduct_size_t currentPos = 0;
        for (reduct_size_t i = 0; i < item->length;)
        {
            if (i <= item->length - oldLen && REDUCT_MEMCMP(item->atom.string + i, oldStr, oldLen) == 0)
            {
                REDUCT_MEMCPY(buffer + currentPos, newStr, newLen);
                currentPos += newLen;
                i += oldLen;
            }
            else
            {
                buffer[currentPos++] = item->atom.string[i++];
            }
        }
 
        reduct_handle_t result =
            REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, resultLen, REDUCT_ATOM_LOOKUP_NONE));
        REDUCT_FREE(buffer);
        return result;
    }
    default:
        REDUCT_ERROR_RUNTIME(reduct, "replace expected list or atom, got %s", reduct_item_type_str(item->type));
    }
}
 
REDUCT_API reduct_handle_t reduct_unique(struct reduct* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    if (!REDUCT_HANDLE_IS_LIST(handle))
    {
        return *handle;
    }
 
    reduct_item_t* item = REDUCT_HANDLE_TO_ITEM(handle);
    reduct_list_t* newList = reduct_list_new(reduct);
    reduct_handle_t resultHandle = REDUCT_HANDLE_FROM_LIST(newList);
    REDUCT_GC_RETAIN(reduct, resultHandle);
 
    reduct_handle_t current;
    REDUCT_LIST_FOR_EACH(&current, &item->list)
    {
        reduct_bool_t found = REDUCT_FALSE;
        reduct_handle_t existing;
        REDUCT_LIST_FOR_EACH(&existing, newList)
        {
            if (reduct_handle_compare(reduct, &current, &existing) == 0)
            {
                found = REDUCT_TRUE;
                break;
            }
        }
 
        if (!found)
        {
            reduct_list_append(reduct, newList, current);
        }
    }
 
    REDUCT_GC_RELEASE(reduct, resultHandle);
    return resultHandle;
}
 
REDUCT_API reduct_handle_t reduct_chunk(struct reduct* reduct, reduct_handle_t* handle, reduct_handle_t* sizeH)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    if (!REDUCT_HANDLE_IS_LIST(handle))
    {
        return *handle;
    }
 
    reduct_handle_t nHandle = reduct_get_int(reduct, sizeH);
    reduct_int64_t n = REDUCT_HANDLE_TO_INT(&nHandle);
 
    if (n <= 0)
    {
        REDUCT_ERROR_RUNTIME(reduct, "chunk size must be greater than 0");
    }
 
    reduct_item_t* item = REDUCT_HANDLE_TO_ITEM(handle);
    reduct_list_t* resultList = reduct_list_new(reduct);
    reduct_handle_t resultHandle = REDUCT_HANDLE_FROM_LIST(resultList);
    REDUCT_GC_RETAIN(reduct, resultHandle);
 
    reduct_size_t chunkSize = (reduct_size_t)n;
    for (reduct_size_t i = 0; i < item->length; i += chunkSize)
    {
        reduct_size_t end = REDUCT_MIN(i + chunkSize, item->length);
        reduct_list_t* chunk = reduct_list_slice(reduct, &item->list, i, end);
        reduct_list_append(reduct, resultList, REDUCT_HANDLE_FROM_LIST(chunk));
    }
 
    REDUCT_GC_RELEASE(reduct, resultHandle);
    return resultHandle;
}
 
REDUCT_API reduct_handle_t reduct_find(struct reduct* reduct, reduct_handle_t* handle, reduct_handle_t* callable)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    if (!REDUCT_HANDLE_IS_LIST(handle))
    {
        return reduct_handle_nil(reduct);
    }
 
    reduct_item_t* item = REDUCT_HANDLE_TO_ITEM(handle);
    reduct_handle_t current;
    REDUCT_LIST_FOR_EACH(&current, &item->list)
    {
        reduct_handle_t result = reduct_eval_call(reduct, *callable, 1, &current);
        if (REDUCT_HANDLE_IS_TRUTHY(&result))
        {
            return current;
        }
    }
 
    return reduct_handle_nil(reduct);
}
 
REDUCT_API reduct_handle_t reduct_get_in(reduct_t* reduct, reduct_handle_t* list, reduct_handle_t* path,
    reduct_handle_t* defaultVal)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_handle_t current = *list;
    reduct_handle_t pathH = *path;
 
    if (!REDUCT_HANDLE_IS_LIST(&pathH))
    {
        reduct_item_t* item = reduct_handle_item(reduct, &current);
        if (item->type != REDUCT_ITEM_TYPE_LIST)
        {
            return (defaultVal != REDUCT_NULL) ? *defaultVal : reduct_handle_nil(reduct);
        }
 
        reduct_handle_t entryH = reduct_list_find_entry(reduct, item, &pathH);
        if (entryH != REDUCT_HANDLE_NONE)
        {
            reduct_item_t* entry = REDUCT_HANDLE_TO_ITEM(&entryH);
            return (entry->length >= 2) ? reduct_list_nth(reduct, &entry->list, 1) : reduct_handle_nil(reduct);
        }
        return (defaultVal != REDUCT_NULL) ? *defaultVal : reduct_handle_nil(reduct);
    }
    reduct_item_t* pathItem = REDUCT_HANDLE_TO_ITEM(&pathH);
    reduct_handle_t key;
    REDUCT_LIST_FOR_EACH(&key, &pathItem->list)
    {
        current = reduct_get_in(reduct, &current, &key, REDUCT_NULL);
        if (current == reduct_handle_nil(reduct))
        {
            return (defaultVal != REDUCT_NULL) ? *defaultVal : reduct_handle_nil(reduct);
        }
    }
 
    return current;
}
 
REDUCT_API reduct_handle_t reduct_assoc_in(reduct_t* reduct, reduct_handle_t* list, reduct_handle_t* path,
    reduct_handle_t* val)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    if (!REDUCT_HANDLE_IS_LIST(path))
    {
        reduct_item_t* listItem = reduct_handle_item(reduct, list);
        reduct_list_t* newList = reduct_list_new(reduct);
        reduct_handle_t targetEntry = reduct_list_find_entry(reduct, listItem, path);
 
        reduct_handle_t entryH;
        REDUCT_LIST_FOR_EACH(&entryH, &listItem->list)
        {
            if (entryH == targetEntry)
            {
                reduct_list_t* newEntry = reduct_list_new(reduct);
                reduct_list_append(reduct, newEntry, *path);
                reduct_list_append(reduct, newEntry, *val);
                reduct_list_append(reduct, newList, REDUCT_HANDLE_FROM_LIST(newEntry));
                continue;
            }
            reduct_list_append(reduct, newList, entryH);
        }
 
        if (targetEntry == REDUCT_HANDLE_NONE)
        {
            reduct_list_t* newEntry = reduct_list_new(reduct);
            reduct_list_append(reduct, newEntry, *path);
            reduct_list_append(reduct, newEntry, *val);
            reduct_list_append(reduct, newList, REDUCT_HANDLE_FROM_LIST(newEntry));
        }
 
        return REDUCT_HANDLE_FROM_LIST(newList);
    }
 
    reduct_item_t* pathItem = REDUCT_HANDLE_TO_ITEM(path);
    if (pathItem->length == 0)
    {
        return *val;
    }
 
    reduct_handle_t firstKey = reduct_list_nth(reduct, &pathItem->list, 0);
    reduct_handle_t restPath;
 
    if (pathItem->length == 1)
    {
        restPath = firstKey;
        return reduct_assoc_in(reduct, list, &restPath, val);
    }
    else
    {
        restPath = REDUCT_HANDLE_FROM_LIST(reduct_list_slice(reduct, &pathItem->list, 1, pathItem->length));
        REDUCT_GC_RETAIN(reduct, restPath);
 
        reduct_handle_t subList = reduct_get_in(reduct, list, &firstKey, REDUCT_NULL);
        if (!REDUCT_HANDLE_IS_LIST(&subList))
        {
            subList = REDUCT_HANDLE_FROM_LIST(reduct_list_new(reduct));
        }
 
        reduct_handle_t updatedSubList = reduct_assoc_in(reduct, &subList, &restPath, val);
        reduct_handle_t result = reduct_assoc_in(reduct, list, &firstKey, &updatedSubList);
 
        REDUCT_GC_RELEASE(reduct, restPath);
        return result;
    }
}
 
REDUCT_API reduct_handle_t reduct_dissoc_in(reduct_t* reduct, reduct_handle_t* list, reduct_handle_t* path)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    if (!REDUCT_HANDLE_IS_LIST(path))
    {
        reduct_item_t* listItem = reduct_handle_item(reduct, list);
        reduct_list_t* newList = reduct_list_new(reduct);
        reduct_handle_t targetEntry = reduct_list_find_entry(reduct, listItem, path);
 
        reduct_handle_t entryH;
        REDUCT_LIST_FOR_EACH(&entryH, &listItem->list)
        {
            if (entryH == targetEntry)
            {
                continue;
            }
            reduct_list_append(reduct, newList, entryH);
        }
 
        return REDUCT_HANDLE_FROM_LIST(newList);
    }
    reduct_item_t* pathItem = REDUCT_HANDLE_TO_ITEM(path);
    if (pathItem->length == 0)
    {
        return *list;
    }
 
    reduct_handle_t firstKey = reduct_list_nth(reduct, &pathItem->list, 0);
    if (pathItem->length == 1)
    {
        return reduct_dissoc_in(reduct, list, &firstKey);
    }
    else
    {
        reduct_handle_t restPath =
            REDUCT_HANDLE_FROM_LIST(reduct_list_slice(reduct, &pathItem->list, 1, pathItem->length));
        REDUCT_GC_RETAIN(reduct, restPath);
 
        reduct_handle_t subList = reduct_get_in(reduct, list, &firstKey, REDUCT_NULL);
        if (REDUCT_HANDLE_IS_LIST(&subList))
        {
            reduct_handle_t updatedSubList = reduct_dissoc_in(reduct, &subList, &restPath);
            reduct_handle_t result = reduct_assoc_in(reduct, list, &firstKey, &updatedSubList);
            REDUCT_GC_RELEASE(reduct, restPath);
            return result;
        }
 
        REDUCT_GC_RELEASE(reduct, restPath);
        return *list;
    }
}
 
REDUCT_API reduct_handle_t reduct_update_in(reduct_t* reduct, reduct_handle_t* list, reduct_handle_t* path,
    reduct_handle_t* callable)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_handle_t currentVal = reduct_get_in(reduct, list, path, REDUCT_NULL);
    reduct_handle_t newVal = reduct_eval_call(reduct, *callable, 1, &currentVal);
 
    return reduct_assoc_in(reduct, list, path, &newVal);
}
 
static inline reduct_handle_t reduct_list_project(reduct_t* reduct, reduct_handle_t* listHandle, reduct_size_t index,
    const char* name)
{
    REDUCT_ERROR_CHECK_LIST(reduct, listHandle, name);
    reduct_item_t* item = REDUCT_HANDLE_TO_ITEM(listHandle);
    reduct_list_t* resultList = reduct_list_new(reduct);
    reduct_handle_t resultHandle = REDUCT_HANDLE_FROM_LIST(resultList);
    REDUCT_GC_RETAIN(reduct, resultHandle);
 
    reduct_handle_t childHandle;
    REDUCT_LIST_FOR_EACH(&childHandle, &item->list)
    {
        if (REDUCT_HANDLE_IS_LIST(&childHandle))
        {
            reduct_item_t* childItem = REDUCT_HANDLE_TO_ITEM(&childHandle);
            if (childItem->length > index)
            {
                reduct_list_append(reduct, resultList, reduct_list_nth(reduct, &childItem->list, index));
            }
        }
    }
 
    REDUCT_GC_RELEASE(reduct, resultHandle);
    return resultHandle;
}
 
REDUCT_API reduct_handle_t reduct_keys(reduct_t* reduct, reduct_handle_t* listHandle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    return reduct_list_project(reduct, listHandle, 0, "keys");
}
 
REDUCT_API reduct_handle_t reduct_values(reduct_t* reduct, reduct_handle_t* listHandle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    return reduct_list_project(reduct, listHandle, 1, "values");
}
 
REDUCT_API reduct_handle_t reduct_merge(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ASSERT(argv != REDUCT_NULL || argc == 0);
 
    reduct_list_t* resultList = reduct_list_new(reduct);
    reduct_handle_t result = REDUCT_HANDLE_FROM_LIST(resultList);
    REDUCT_GC_RETAIN(reduct, result);
 
    for (reduct_size_t i = 0; i < argc; i++)
    {
        if (!REDUCT_HANDLE_IS_LIST(&argv[i]))
        {
            continue;
        }
 
        reduct_item_t* currentItem = REDUCT_HANDLE_TO_ITEM(&argv[i]);
        reduct_handle_t entryH;
        REDUCT_LIST_FOR_EACH(&entryH, &currentItem->list)
        {
            reduct_handle_t key, val;
            if (reduct_list_get_entry(reduct, &entryH, &key, &val))
            {
                reduct_handle_t next = reduct_assoc_in(reduct, &result, &key, &val);
                REDUCT_GC_RETAIN(reduct, next);
                REDUCT_GC_RELEASE(reduct, result);
                result = next;
            }
        }
    }
 
    REDUCT_GC_RELEASE(reduct, result);
    return result;
}
 
REDUCT_API reduct_handle_t reduct_explode(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ASSERT(argv != REDUCT_NULL || argc == 0);
 
    reduct_list_t* list = reduct_list_new(reduct);
    reduct_handle_t listHandle = REDUCT_HANDLE_FROM_LIST(list);
    REDUCT_GC_RETAIN(reduct, listHandle);
 
    for (reduct_size_t i = 0; i < argc; i++)
    {
        char* str;
        reduct_size_t len;
        reduct_handle_get_string_params(reduct, &argv[i], &str, &len);
        for (reduct_size_t j = 0; j < len; j++)
        {
            reduct_list_append(reduct, list, REDUCT_HANDLE_FROM_INT((reduct_int64_t)(unsigned char)str[j]));
        }
    }
 
    REDUCT_GC_RELEASE(reduct, listHandle);
    return listHandle;
}
 
REDUCT_API reduct_handle_t reduct_implode(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ASSERT(argv != REDUCT_NULL || argc == 0);
 
    reduct_size_t totalLen = 0;
    for (reduct_size_t i = 0; i < argc; i++)
    {
        if (!REDUCT_HANDLE_IS_LIST(&argv[i]))
        {
            continue;
        }
        totalLen += REDUCT_HANDLE_TO_ITEM(&argv[i])->length;
    }
 
    REDUCT_SCRATCH_BUFFER(buffer, totalLen);
 
    reduct_size_t currentPos = 0;
    for (reduct_size_t i = 0; i < argc; i++)
    {
        if (!REDUCT_HANDLE_IS_LIST(&argv[i]))
        {
            continue;
        }
        reduct_item_t* list = REDUCT_HANDLE_TO_ITEM(&argv[i]);
        reduct_handle_t valH;
        REDUCT_LIST_FOR_EACH(&valH, &list->list)
        {
            reduct_handle_t charH = reduct_get_int(reduct, &valH);
            buffer[currentPos++] = (char)REDUCT_HANDLE_TO_INT(&charH);
        }
    }
 
    reduct_handle_t result =
        REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, totalLen, REDUCT_ATOM_LOOKUP_NONE));
    REDUCT_SCRATCH_BUFFER_FREE(buffer);
    return result;
}
 
REDUCT_API reduct_handle_t reduct_repeat(reduct_t* reduct, reduct_handle_t* handle, reduct_handle_t* count)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_handle_t nHandle = reduct_get_int(reduct, count);
    reduct_int64_t n = REDUCT_HANDLE_TO_INT(&nHandle);
 
    if (n < 0)
    {
        REDUCT_ERROR_RUNTIME(reduct, "repeat count cannot be negative, got %lld", n);
    }
 
    reduct_list_t* newList = reduct_list_new(reduct);
    reduct_handle_t newHandle = REDUCT_HANDLE_FROM_LIST(newList);
    REDUCT_GC_RETAIN(reduct, newHandle);
 
    for (reduct_size_t i = 0; i < (reduct_size_t)n; i++)
    {
        reduct_list_append(reduct, newList, *handle);
    }
 
    REDUCT_GC_RELEASE(reduct, newHandle);
    return newHandle;
}
 
static inline reduct_handle_t reduct_sequence_check_edge(reduct_t* reduct, reduct_handle_t* handle,
    reduct_handle_t* target, reduct_bool_t start, const char* name)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    REDUCT_ERROR_CHECK_SEQUENCE(reduct, handle, name);
    reduct_item_t* item = REDUCT_HANDLE_TO_ITEM(handle);
 
    if (item->type == REDUCT_ITEM_TYPE_LIST)
    {
        if (item->length == 0)
        {
            return REDUCT_HANDLE_FALSE();
        }
        reduct_size_t index = start ? 0 : item->length - 1;
        reduct_handle_t edge = reduct_list_nth(reduct, &item->list, index);
        return (reduct_handle_compare(reduct, &edge, target) == 0) ? REDUCT_HANDLE_TRUE() : REDUCT_HANDLE_FALSE();
    }
    else
    {
        char *srcStr, *tgtStr;
        reduct_size_t srcLen, tgtLen;
        reduct_handle_get_string_params(reduct, handle, &srcStr, &srcLen);
        reduct_handle_get_string_params(reduct, target, &tgtStr, &tgtLen);
 
        if (tgtLen > srcLen)
        {
            return REDUCT_HANDLE_FALSE();
        }
        const char* offset = start ? srcStr : srcStr + srcLen - tgtLen;
        return (REDUCT_MEMCMP(offset, tgtStr, tgtLen) == 0) ? REDUCT_HANDLE_TRUE() : REDUCT_HANDLE_FALSE();
    }
    return REDUCT_HANDLE_FALSE();
}
 
REDUCT_API reduct_handle_t reduct_starts_with(reduct_t* reduct, reduct_handle_t* handle, reduct_handle_t* prefix)
{
    return reduct_sequence_check_edge(reduct, handle, prefix, REDUCT_TRUE, "starts-with?");
}
 
REDUCT_API reduct_handle_t reduct_ends_with(reduct_t* reduct, reduct_handle_t* handle, reduct_handle_t* suffix)
{
    return reduct_sequence_check_edge(reduct, handle, suffix, REDUCT_FALSE, "ends-with?");
}
 
REDUCT_API reduct_handle_t reduct_join(reduct_t* reduct, reduct_handle_t* listHandle, reduct_handle_t* sepHandle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    if (!REDUCT_HANDLE_IS_LIST(listHandle))
    {
        REDUCT_ERROR_RUNTIME(reduct, "join expects a list as the first argument, got %s",
            reduct_item_type_str(REDUCT_HANDLE_GET_TYPE(listHandle)));
    }
 
    reduct_item_t* list = REDUCT_HANDLE_TO_ITEM(listHandle);
    if (list->length == 0)
    {
        return REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, "", 0, REDUCT_ATOM_LOOKUP_NONE));
    }
 
    char* sepStr;
    reduct_size_t sepLen;
    reduct_handle_get_string_params(reduct, sepHandle, &sepStr, &sepLen);
 
    reduct_size_t totalLen = 0;
    reduct_handle_t entry;
    REDUCT_LIST_FOR_EACH(&entry, &list->list)
    {
        totalLen += reduct_handle_item(reduct, &entry)->length;
    }
 
    if (list->length > 1)
    {
        totalLen += sepLen * (list->length - 1);
    }
 
    REDUCT_SCRATCH_BUFFER(buffer, totalLen);
 
    reduct_size_t currentPos = 0;
    REDUCT_LIST_FOR_EACH(&entry, &list->list)
    {
        char* str;
        reduct_size_t len;
        reduct_handle_get_string_params(reduct, &entry, &str, &len);
        REDUCT_MEMCPY(buffer + currentPos, str, len);
        currentPos += len;
 
        if (_iter.index < list->length)
        {
            REDUCT_MEMCPY(buffer + currentPos, sepStr, sepLen);
            currentPos += sepLen;
        }
    }
 
    reduct_handle_t result =
        REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, totalLen, REDUCT_ATOM_LOOKUP_NONE));
    REDUCT_SCRATCH_BUFFER_FREE(buffer);
    return result;
}
 
REDUCT_API reduct_handle_t reduct_split(reduct_t* reduct, reduct_handle_t* srcHandle, reduct_handle_t* sepHandle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    char *srcStr, *sepStr;
    reduct_size_t srcLen, sepLen;
 
    reduct_handle_get_string_params(reduct, srcHandle, &srcStr, &srcLen);
    reduct_handle_get_string_params(reduct, sepHandle, &sepStr, &sepLen);
 
    reduct_list_t* resultList = reduct_list_new(reduct);
    reduct_handle_t resultHandle = REDUCT_HANDLE_FROM_LIST(resultList);
    REDUCT_GC_RETAIN(reduct, resultHandle);
 
    if (sepLen == 0)
    {
        for (reduct_size_t i = 0; i < srcLen; i++)
        {
            reduct_list_append(reduct, resultList,
                REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, srcStr + i, 1, REDUCT_ATOM_LOOKUP_NONE)));
        }
    }
    else
    {
        reduct_size_t lastPos = 0;
        for (reduct_size_t i = 0; i <= srcLen - sepLen; i++)
        {
            if (REDUCT_MEMCMP(srcStr + i, sepStr, sepLen) == 0)
            {
                reduct_list_append(reduct, resultList,
                    REDUCT_HANDLE_FROM_ATOM(
                        reduct_atom_lookup(reduct, srcStr + lastPos, i - lastPos, REDUCT_ATOM_LOOKUP_NONE)));
                i += sepLen - 1;
                lastPos = i + 1;
            }
        }
 
        reduct_list_append(reduct, resultList,
            REDUCT_HANDLE_FROM_ATOM(
                reduct_atom_lookup(reduct, srcStr + lastPos, srcLen - lastPos, REDUCT_ATOM_LOOKUP_NONE)));
    }
 
    REDUCT_GC_RELEASE(reduct, resultHandle);
    return resultHandle;
}
 
static inline reduct_handle_t reduct_string_transform(reduct_t* reduct, reduct_handle_t* srcHandle, reduct_bool_t upper)
{
    char* srcStr;
    reduct_size_t srcLen;
    reduct_handle_get_string_params(reduct, srcHandle, &srcStr, &srcLen);
 
    if (srcLen == 0)
    {
        return *srcHandle;
    }
 
    REDUCT_SCRATCH_BUFFER(buffer, srcLen);
    for (reduct_size_t i = 0; i < srcLen; i++)
    {
        buffer[i] = upper ? REDUCT_CHAR_TO_UPPER(srcStr[i]) : REDUCT_CHAR_TO_LOWER(srcStr[i]);
    }
 
    reduct_handle_t result =
        REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, srcLen, REDUCT_ATOM_LOOKUP_NONE));
    REDUCT_SCRATCH_BUFFER_FREE(buffer);
    return result;
}
 
REDUCT_API reduct_handle_t reduct_upper(reduct_t* reduct, reduct_handle_t* srcHandle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    return reduct_string_transform(reduct, srcHandle, REDUCT_TRUE);
}
 
REDUCT_API reduct_handle_t reduct_lower(reduct_t* reduct, reduct_handle_t* srcHandle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    return reduct_string_transform(reduct, srcHandle, REDUCT_FALSE);
}
 
REDUCT_API reduct_handle_t reduct_trim(reduct_t* reduct, reduct_handle_t* srcHandle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    char* srcStr;
    reduct_size_t srcLen;
    reduct_handle_get_string_params(reduct, srcHandle, &srcStr, &srcLen);
 
    if (srcLen == 0)
    {
        return *srcHandle;
    }
 
    reduct_size_t start = 0;
    while (start < srcLen && REDUCT_CHAR_IS_WHITESPACE(srcStr[start]))
    {
        start++;
    }
 
    if (start == srcLen)
    {
        return REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, "", 0, REDUCT_ATOM_LOOKUP_NONE));
    }
 
    reduct_size_t end = srcLen - 1;
    while (end > start && REDUCT_CHAR_IS_WHITESPACE(srcStr[end]))
    {
        end--;
    }
 
    return REDUCT_HANDLE_FROM_ATOM(
        reduct_atom_lookup(reduct, srcStr + start, end - start + 1, REDUCT_ATOM_LOOKUP_NONE));
}
 
#define REDUCT_INTROSPECTION_LOOP(_predicate) \
    do \
    { \
        REDUCT_ASSERT(reduct != REDUCT_NULL); \
        REDUCT_ASSERT(argv != REDUCT_NULL || argc == 0); \
        for (reduct_size_t i = 0; i < argc; i++) \
        { \
            if (!(_predicate)) \
            { \
                return REDUCT_HANDLE_FALSE(); \
            } \
        } \
        return REDUCT_HANDLE_TRUE(); \
    } while (0)
 
#define REDUCT_INTROSPECTION_IMPL(_name, _predicate_macro) \
    REDUCT_API reduct_handle_t _name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        REDUCT_UNUSED(reduct); \
        REDUCT_INTROSPECTION_LOOP(_predicate_macro(&argv[i])); \
    }
 
REDUCT_INTROSPECTION_IMPL(reduct_is_atom, REDUCT_HANDLE_IS_ATOM)
REDUCT_INTROSPECTION_IMPL(reduct_is_int, REDUCT_HANDLE_IS_INT_SHAPED)
REDUCT_INTROSPECTION_IMPL(reduct_is_float, REDUCT_HANDLE_IS_FLOAT_SHAPED)
REDUCT_INTROSPECTION_IMPL(reduct_is_number, REDUCT_HANDLE_IS_NUMBER_SHAPED)
REDUCT_INTROSPECTION_IMPL(reduct_is_lambda, REDUCT_HANDLE_IS_LAMBDA)
REDUCT_INTROSPECTION_IMPL(reduct_is_native, REDUCT_HANDLE_IS_NATIVE)
REDUCT_INTROSPECTION_IMPL(reduct_is_callable, REDUCT_HANDLE_IS_CALLABLE)
REDUCT_INTROSPECTION_IMPL(reduct_is_list, REDUCT_HANDLE_IS_LIST)
 
#define REDUCT_PREDICATE_IS_STRING(_h) (REDUCT_HANDLE_IS_ATOM(_h) && !REDUCT_HANDLE_IS_NUMBER_SHAPED(_h))
REDUCT_INTROSPECTION_IMPL(reduct_is_string, REDUCT_PREDICATE_IS_STRING)
 
#define REDUCT_PREDICATE_IS_EMPTY(_h) (reduct_handle_item(reduct, _h)->length == 0)
REDUCT_INTROSPECTION_IMPL(reduct_is_empty, REDUCT_PREDICATE_IS_EMPTY)
 
#define REDUCT_PREDICATE_IS_NIL(_h) (*(_h) == reduct_handle_nil(reduct))
REDUCT_INTROSPECTION_IMPL(reduct_is_nil, REDUCT_PREDICATE_IS_NIL)
 
#define REDUCT_GET_NUMERIC_IMPL(_name, _res, _type, _other, _targetUnion, _otherUnion) \
    REDUCT_API reduct_handle_t reduct_get_##_name(reduct_t* reduct, reduct_handle_t* handle) \
    { \
        REDUCT_ASSERT(reduct != REDUCT_NULL); \
        if (REDUCT_HANDLE_IS_##_type(handle)) \
        { \
            return *handle; \
        } \
        if (REDUCT_HANDLE_IS_##_other(handle)) \
        { \
            return REDUCT_HANDLE_FROM_##_res((reduct_##_name##_t)REDUCT_HANDLE_TO_##_other(handle)); \
        } \
        reduct_item_t* item = reduct_handle_item(reduct, handle); \
        if (item->flags & REDUCT_ITEM_FLAG_##_type##_SHAPED) \
        { \
            return REDUCT_HANDLE_FROM_##_res(item->atom._targetUnion); \
        } \
        if (item->flags & REDUCT_ITEM_FLAG_##_other##_SHAPED) \
        { \
            return REDUCT_HANDLE_FROM_##_res((reduct_##_name##_t)item->atom._otherUnion); \
        } \
        REDUCT_ERROR_RUNTIME(reduct, "expected " #_name ", got %s", reduct_item_type_str(item->type)); \
    }
 
REDUCT_GET_NUMERIC_IMPL(int, INT, INT, FLOAT, integerValue, floatValue)
REDUCT_GET_NUMERIC_IMPL(float, FLOAT, FLOAT, INT, floatValue, integerValue)
 
REDUCT_API reduct_handle_t reduct_get_string(reduct_t* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    if (REDUCT_HANDLE_IS_ATOM(handle))
    {
        reduct_item_t* item = reduct_handle_item(reduct, handle);
        return REDUCT_HANDLE_FROM_ATOM(
            reduct_atom_lookup(reduct, item->atom.string, item->length, REDUCT_ATOM_LOOKUP_QUOTED));
    }
 
    char stackBuffer[REDUCT_STACK_BUFFER_SIZE];
    reduct_size_t len = reduct_stringify(reduct, handle, stackBuffer, REDUCT_STACK_BUFFER_SIZE);
    if (len < REDUCT_STACK_BUFFER_SIZE)
    {
        return REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, stackBuffer, len, REDUCT_ATOM_LOOKUP_QUOTED));
    }
 
    REDUCT_SCRATCH_BUFFER(buffer, len);
    reduct_stringify(reduct, handle, buffer, len + 1);
    reduct_handle_t result =
        REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, len, REDUCT_ATOM_LOOKUP_QUOTED));
    REDUCT_SCRATCH_BUFFER_FREE(buffer);
    return result;
}
 
static void reduct_path_copy(reduct_t* reduct, char* dest, const char* src, reduct_size_t len, reduct_size_t max)
{
    if (len >= max)
    {
        REDUCT_ERROR_RUNTIME(reduct, "path too long");
    }
    REDUCT_MEMCPY(dest, src, len);
    dest[len] = '\0';
}
 
static void reduct_resolve_path(reduct_t* reduct, const char* path, reduct_size_t pathLen, char* outPath,
    reduct_size_t maxLen)
{
    reduct_bool_t isAbsolute = REDUCT_FALSE;
    if (pathLen > 0 && (path[0] == '/' || path[0] == '\\'))
    {
        isAbsolute = REDUCT_TRUE;
    }
    if (pathLen > 1 && ((path[0] >= 'a' && path[0] <= 'z') || (path[0] >= 'A' && path[0] <= 'Z')) && path[1] == ':')
    {
        isAbsolute = REDUCT_TRUE;
    }
 
    if (isAbsolute || reduct->evalState == REDUCT_NULL || reduct->evalState->frameCount == 0)
    {
        reduct_path_copy(reduct, outPath, path, pathLen, maxLen);
        return;
    }
 
    reduct_input_t* input = REDUCT_NULL;
    for (reduct_size_t i = reduct->evalState->frameCount; i > 0; i--)
    {
        reduct_eval_frame_t* frame = &reduct->evalState->frames[i - 1];
        reduct_item_t* funcItem = REDUCT_CONTAINER_OF(frame->closure->function, reduct_item_t, function);
        if (funcItem->input != REDUCT_NULL && funcItem->input->path[0] != '\0')
        {
            input = funcItem->input;
            break;
        }
    }
 
    if (input == REDUCT_NULL)
    {
        reduct_path_copy(reduct, outPath, path, pathLen, maxLen);
        return;
    }
 
    const char* lastSlash = NULL;
    const char* p = input->path;
    while (*p != '\0')
    {
        if (*p == '/' || *p == '\\')
        {
            lastSlash = p;
        }
        p++;
    }
 
    if (lastSlash == REDUCT_NULL)
    {
        reduct_path_copy(reduct, outPath, path, pathLen, maxLen);
        return;
    }
 
    reduct_size_t dirLen = (reduct_size_t)(lastSlash - input->path) + 1;
    if (dirLen + pathLen >= maxLen)
    {
        REDUCT_ERROR_RUNTIME(reduct, "path too long");
    }
 
    REDUCT_MEMCPY(outPath, input->path, dirLen);
    REDUCT_MEMCPY(outPath + dirLen, path, pathLen);
    outPath[dirLen + pathLen] = '\0';
}
 
REDUCT_API reduct_handle_t reduct_run(struct reduct* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    char* str;
    reduct_size_t len;
    reduct_handle_get_string_params(reduct, handle, &str, &len);
 
    reduct_handle_t ast = reduct_parse(reduct, str, len, "<run>");
    reduct_function_t* function = reduct_compile(reduct, &ast);
    return reduct_eval(reduct, function);
}
 
static void reduct_get_resolved_path(reduct_t* reduct, reduct_handle_t* pathHandle, char* outBuf)
{
    char* pathStr;
    reduct_size_t pathLen;
    reduct_handle_get_string_params(reduct, pathHandle, &pathStr, &pathLen);
    reduct_resolve_path(reduct, pathStr, pathLen, outBuf, REDUCT_PATH_MAX);
}
 
REDUCT_API reduct_handle_t reduct_load(struct reduct* reduct, reduct_handle_t* path)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    char pathBuf[REDUCT_PATH_MAX];
    reduct_get_resolved_path(reduct, path, pathBuf);
 
    reduct_handle_t ast = reduct_parse_file(reduct, pathBuf);
    reduct_function_t* function = reduct_compile(reduct, &ast);
    return reduct_eval(reduct, function);
}
 
REDUCT_API reduct_handle_t reduct_read_file(struct reduct* reduct, reduct_handle_t* path)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    char pathBuf[REDUCT_PATH_MAX];
    reduct_get_resolved_path(reduct, path, pathBuf);
 
    reduct_file_t file = REDUCT_FOPEN(pathBuf, "rb");
    if (file == REDUCT_NULL)
    {
        REDUCT_ERROR_RUNTIME(reduct, "could not open file '%s'", pathBuf);
    }
 
    fseek(file, 0, SEEK_END);
    long size = ftell(file);
    fseek(file, 0, SEEK_SET);
 
    char* buffer = (char*)REDUCT_MALLOC(size);
    if (buffer == REDUCT_NULL)
    {
        REDUCT_FCLOSE(file);
        REDUCT_ERROR_INTERNAL(reduct, "out of memory");
    }
 
    if (REDUCT_FREAD(buffer, 1, size, file) != (reduct_size_t)size)
    {
        REDUCT_FREE(buffer);
        REDUCT_FCLOSE(file);
        REDUCT_ERROR_RUNTIME(reduct, "could not read file '%s'", pathBuf);
    }
 
    REDUCT_FCLOSE(file);
    reduct_handle_t result =
        REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, size, REDUCT_ATOM_LOOKUP_QUOTED));
    REDUCT_FREE(buffer);
    return result;
}
 
REDUCT_API reduct_handle_t reduct_write_file(struct reduct* reduct, reduct_handle_t* path, reduct_handle_t* content)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    char pathBuf[REDUCT_PATH_MAX];
    reduct_get_resolved_path(reduct, path, pathBuf);
 
    char* contentStr;
    reduct_size_t contentLen;
    reduct_handle_get_string_params(reduct, content, &contentStr, &contentLen);
 
    reduct_file_t file = REDUCT_FOPEN(pathBuf, "wb");
    if (file == REDUCT_NULL)
    {
        REDUCT_ERROR_RUNTIME(reduct, "could not open file '%s' for writing", pathBuf);
    }
 
    if (REDUCT_FWRITE(contentStr, 1, contentLen, file) != contentLen)
    {
        REDUCT_FCLOSE(file);
        REDUCT_ERROR_RUNTIME(reduct, "could not write to file '%s'", pathBuf);
    }
 
    REDUCT_FCLOSE(file);
    return *content;
}
 
REDUCT_API reduct_handle_t reduct_read_char(struct reduct* reduct)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    int c = REDUCT_FGETC(REDUCT_STDIN);
    if (c == EOF)
    {
        return reduct_handle_nil(reduct);
    }
 
    char ch = (char)c;
    return REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, &ch, 1, REDUCT_ATOM_LOOKUP_NONE));
}
 
REDUCT_API reduct_handle_t reduct_read_line(struct reduct* reduct)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    char stackBuffer[REDUCT_STACK_BUFFER_SIZE];
    reduct_size_t capacity = REDUCT_STACK_BUFFER_SIZE;
    char* buffer = stackBuffer;
    reduct_size_t length = 0;
 
    while (REDUCT_TRUE)
    {
        int c = REDUCT_FGETC(REDUCT_STDIN);
        if (c == EOF || c == '\n')
        {
            if (c == EOF && length == 0)
            {
                if (buffer != stackBuffer)
                {
                    REDUCT_FREE(buffer);
                }
                return reduct_handle_nil(reduct);
            }
            break;
        }
 
        if (length + 1 >= capacity)
        {
            reduct_size_t newCapacity = capacity * 2;
            char* newBuffer = (char*)REDUCT_MALLOC(newCapacity);
            if (newBuffer == REDUCT_NULL)
            {
                if (buffer != stackBuffer)
                {
                    REDUCT_FREE(buffer);
                }
                REDUCT_ERROR_INTERNAL(reduct, "out of memory");
            }
            REDUCT_MEMCPY(newBuffer, buffer, length);
            if (buffer != stackBuffer)
            {
                REDUCT_FREE(buffer);
            }
            buffer = newBuffer;
            capacity = newCapacity;
        }
        buffer[length++] = (char)c;
    }
 
    reduct_handle_t result =
        REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, length, REDUCT_ATOM_LOOKUP_QUOTED));
    if (buffer != stackBuffer)
    {
        REDUCT_FREE(buffer);
    }
    return result;
}
 
REDUCT_API reduct_handle_t reduct_print(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    for (reduct_size_t i = 0; i < argc; i++)
    {
        char* str;
        reduct_size_t len;
        reduct_handle_get_string_params(reduct, &argv[i], &str, &len);
        REDUCT_FWRITE(str, 1, len, REDUCT_STDOUT);
        if (i < argc - 1)
        {
            REDUCT_FWRITE(" ", 1, 1, REDUCT_STDOUT);
        }
    }
    return reduct_handle_nil(reduct);
}
 
REDUCT_API reduct_handle_t reduct_println(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_handle_t handle = reduct_print(reduct, argc, argv);
    REDUCT_FWRITE("\n", 1, 1, REDUCT_STDOUT);
    return handle;
}
 
REDUCT_API reduct_handle_t reduct_ord(struct reduct* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    REDUCT_ASSERT(handle != REDUCT_NULL);
 
    char* str;
    reduct_size_t len;
    reduct_handle_get_string_params(reduct, handle, &str, &len);
 
    if (len == 0)
    {
        REDUCT_ERROR_RUNTIME(reduct, "ord expects a non-empty atom");
    }
 
    return REDUCT_HANDLE_FROM_INT((reduct_int64_t)(reduct_uint8_t)str[0]);
}
 
REDUCT_API reduct_handle_t reduct_chr(struct reduct* reduct, reduct_handle_t* handle)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_handle_t iVal = reduct_get_int(reduct, handle);
    reduct_int64_t val = REDUCT_HANDLE_TO_INT(&iVal);
 
    if (val < 0 || val > 255)
    {
        REDUCT_ERROR_RUNTIME(reduct, "chr expects an integer in range 0-255, got %lld", (long long)val);
    }
 
    char c = (char)(reduct_uint8_t)val;
    return REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, &c, 1, REDUCT_ATOM_LOOKUP_NONE));
}
 
REDUCT_API reduct_handle_t reduct_format(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    if (argc == 0)
    {
        return REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, "", 0, REDUCT_ATOM_LOOKUP_NONE));
    }
 
    char* fmtStr;
    reduct_size_t fmtLen;
    reduct_handle_get_string_params(reduct, &argv[0], &fmtStr, &fmtLen);
 
    reduct_size_t totalLen = 0;
    reduct_size_t argIndex = 1;
 
    for (reduct_size_t i = 0; i < fmtLen; i++)
    {
        if (fmtStr[i] == '{')
        {
            if (i + 1 < fmtLen && fmtStr[i + 1] == '{')
            {
                totalLen++;
                i++;
                continue;
            }
 
            reduct_size_t j = i + 1;
            reduct_int64_t explicitIndex = -1;
            if (j < fmtLen && fmtStr[j] >= '0' && fmtStr[j] <= '9')
            {
                explicitIndex = 0;
                while (j < fmtLen && fmtStr[j] >= '0' && fmtStr[j] <= '9')
                {
                    explicitIndex = explicitIndex * 10 + (fmtStr[j] - '0');
                    j++;
                }
            }
 
            if (j < fmtLen && fmtStr[j] == '}')
            {
                reduct_size_t idx = (explicitIndex != -1) ? (reduct_size_t)explicitIndex + 1 : argIndex++;
                if (idx >= argc)
                {
                    REDUCT_ERROR_RUNTIME(reduct, "format index out of range");
                }
                totalLen += reduct_stringify(reduct, &argv[idx], REDUCT_NULL, 0);
                i = j;
                continue;
            }
 
            REDUCT_ERROR_RUNTIME(reduct, "invalid format string");
        }
        else if (fmtStr[i] == '}')
        {
            if (i + 1 < fmtLen && fmtStr[i + 1] == '}')
            {
                totalLen++;
                i++;
                continue;
            }
 
            REDUCT_ERROR_RUNTIME(reduct, "single '}' encountered in format string");
        }
        totalLen++;
    }
 
    REDUCT_SCRATCH_BUFFER(buffer, totalLen);
 
    reduct_size_t currentPos = 0;
    argIndex = 1;
 
    for (reduct_size_t i = 0; i < fmtLen; i++)
    {
        if (fmtStr[i] == '{')
        {
            if (i + 1 < fmtLen && fmtStr[i + 1] == '{')
            {
                buffer[currentPos++] = '{';
                i++;
                continue;
            }
 
            reduct_size_t j = i + 1;
            reduct_int64_t explicitIndex = -1;
            if (j < fmtLen && fmtStr[j] >= '0' && fmtStr[j] <= '9')
            {
                explicitIndex = 0;
                while (j < fmtLen && fmtStr[j] >= '0' && fmtStr[j] <= '9')
                {
                    explicitIndex = explicitIndex * 10 + (fmtStr[j] - '0');
                    j++;
                }
            }
 
            if (j < fmtLen && fmtStr[j] == '}')
            {
                reduct_size_t idx = (explicitIndex != -1) ? (reduct_size_t)explicitIndex + 1 : argIndex++;
                currentPos += reduct_stringify(reduct, &argv[idx], buffer + currentPos, totalLen - currentPos + 1);
                i = j;
                continue;
            }
        }
        else if (fmtStr[i] == '}')
        {
            if (i + 1 < fmtLen && fmtStr[i + 1] == '}')
            {
                buffer[currentPos++] = '}';
                i++;
                continue;
            }
        }
        buffer[currentPos++] = fmtStr[i];
    }
 
    reduct_handle_t result =
        REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, buffer, totalLen, REDUCT_ATOM_LOOKUP_NONE));
    REDUCT_SCRATCH_BUFFER_FREE(buffer);
    return result;
}
 
REDUCT_API reduct_handle_t reduct_now(reduct_t* reduct)
{
    REDUCT_UNUSED(reduct);
 
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    return REDUCT_HANDLE_FROM_FLOAT((reduct_float_t)REDUCT_TIME());
}
 
REDUCT_API reduct_handle_t reduct_uptime(reduct_t* reduct)
{
    REDUCT_UNUSED(reduct);
 
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    return REDUCT_HANDLE_FROM_FLOAT((reduct_float_t)REDUCT_CLOCK());
}
 
REDUCT_API reduct_handle_t reduct_env(struct reduct* reduct)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    extern char** environ;
    reduct_size_t count = 0;
    while (environ[count] != REDUCT_NULL)
    {
        count++;
    }
 
    reduct_list_t* list = reduct_list_new(reduct);
    for (reduct_size_t i = 0; i < count; i++)
    {
        char* env = environ[i];
        char* eq = strchr(env, '=');
        if (eq != REDUCT_NULL)
        {
            reduct_list_t* pair = reduct_list_new(reduct);
            reduct_list_append(reduct, pair,
                REDUCT_HANDLE_FROM_ATOM(
                    reduct_atom_lookup(reduct, env, (reduct_size_t)(eq - env), REDUCT_ATOM_LOOKUP_NONE)));
            reduct_list_append(reduct, pair,
                REDUCT_HANDLE_FROM_ATOM(
                    reduct_atom_lookup(reduct, eq + 1, REDUCT_STRLEN(eq + 1), REDUCT_ATOM_LOOKUP_QUOTED)));
 
            reduct_list_append(reduct, list, REDUCT_HANDLE_FROM_LIST(pair));
        }
    }
 
    return REDUCT_HANDLE_FROM_LIST(list);
}
 
REDUCT_API reduct_handle_t reduct_args(struct reduct* reduct)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    if (reduct->argc == 0)
    {
        return reduct_handle_nil(reduct);
    }
 
    reduct_list_t* list = reduct_list_new(reduct);
    for (int i = 0; i < reduct->argc; i++)
    {
        reduct_list_append(reduct, list,
            REDUCT_HANDLE_FROM_ATOM(reduct_atom_lookup(reduct, reduct->argv[i], REDUCT_STRLEN(reduct->argv[i]),
                REDUCT_ATOM_LOOKUP_QUOTED)));
    }
 
    return REDUCT_HANDLE_FROM_LIST(list);
}
 
#define REDUCT_MATH_MIN_MAX_IMPL(_name, _op) \
    REDUCT_API reduct_handle_t _name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        REDUCT_ASSERT(reduct != REDUCT_NULL); \
        if (argc == 0) \
        { \
            return reduct_handle_nil(reduct); \
        } \
        reduct_handle_t current = argv[0]; \
        for (reduct_size_t i = 1; i < argc; i++) \
        { \
            reduct_promotion_t prom; \
            reduct_handle_promote(reduct, &current, &argv[i], &prom); \
            if (prom.type == REDUCT_PROMOTION_TYPE_INT) \
            { \
                current = REDUCT_HANDLE_FROM_INT(prom.a.intVal _op prom.b.intVal ? prom.a.intVal : prom.b.intVal); \
            } \
            else \
            { \
                current = \
                    REDUCT_HANDLE_FROM_FLOAT(prom.a.floatVal _op prom.b.floatVal ? prom.a.floatVal : prom.b.floatVal); \
            } \
        } \
        return current; \
    }
 
REDUCT_MATH_MIN_MAX_IMPL(reduct_min, <)
REDUCT_MATH_MIN_MAX_IMPL(reduct_max, >)
 
REDUCT_API reduct_handle_t reduct_clamp(reduct_t* reduct, reduct_handle_t* val, reduct_handle_t* minVal,
    reduct_handle_t* maxVal)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_handle_t current = *val;
    reduct_promotion_t prom;
 
    reduct_handle_promote(reduct, &current, minVal, &prom);
    if (prom.type == REDUCT_PROMOTION_TYPE_INT)
    {
        current = REDUCT_HANDLE_FROM_INT(prom.a.intVal < prom.b.intVal ? prom.b.intVal : prom.a.intVal);
    }
    else
    {
        current = REDUCT_HANDLE_FROM_FLOAT(prom.a.floatVal < prom.b.floatVal ? prom.b.floatVal : prom.a.floatVal);
    }
 
    reduct_handle_promote(reduct, &current, maxVal, &prom);
    if (prom.type == REDUCT_PROMOTION_TYPE_INT)
    {
        current = REDUCT_HANDLE_FROM_INT(prom.a.intVal > prom.b.intVal ? prom.b.intVal : prom.a.intVal);
    }
    else
    {
        current = REDUCT_HANDLE_FROM_FLOAT(prom.a.floatVal > prom.b.floatVal ? prom.b.floatVal : prom.a.floatVal);
    }
 
    return current;
}
 
#define REDUCT_MATH_UNARY_IMPL(_name, _int_func, _float_func) \
    REDUCT_API reduct_handle_t _name(reduct_t* reduct, reduct_handle_t* val) \
    { \
        REDUCT_ASSERT(reduct != REDUCT_NULL); \
        if (REDUCT_HANDLE_IS_INT_SHAPED(val)) \
        { \
            reduct_handle_t iVal = reduct_get_int(reduct, val); \
            reduct_int64_t i = REDUCT_HANDLE_TO_INT(&iVal); \
            return REDUCT_HANDLE_FROM_INT((reduct_int64_t)_int_func(i)); \
        } \
        reduct_handle_t floatVal = reduct_get_float(reduct, val); \
        reduct_float_t f = REDUCT_HANDLE_TO_FLOAT(&floatVal); \
        return REDUCT_HANDLE_FROM_FLOAT((reduct_float_t)_float_func(f)); \
    }
 
#define REDUCT_INT_ABS(_x) ((_x) < 0 ? -(_x) : (_x))
REDUCT_MATH_UNARY_IMPL(reduct_abs, REDUCT_INT_ABS, REDUCT_FABS)
REDUCT_MATH_UNARY_IMPL(reduct_exp, REDUCT_EXP, REDUCT_EXP)
REDUCT_MATH_UNARY_IMPL(reduct_sqrt, REDUCT_SQRT, REDUCT_SQRT)
 
#define REDUCT_MATH_UNARY_TO_INT_IMPL(_name, _float_func) \
    REDUCT_API reduct_handle_t _name(struct reduct* reduct, reduct_handle_t* val) \
    { \
        REDUCT_ASSERT(reduct != REDUCT_NULL); \
        if (REDUCT_HANDLE_IS_INT_SHAPED(val)) \
        { \
            return reduct_get_int(reduct, val); \
        } \
        reduct_handle_t floatVal = reduct_get_float(reduct, val); \
        reduct_float_t f = REDUCT_HANDLE_TO_FLOAT(&floatVal); \
        return REDUCT_HANDLE_FROM_INT((reduct_int64_t)_float_func(f)); \
    }
 
REDUCT_MATH_UNARY_TO_INT_IMPL(reduct_floor, REDUCT_FLOOR)
REDUCT_MATH_UNARY_TO_INT_IMPL(reduct_ceil, REDUCT_CEIL)
REDUCT_MATH_UNARY_TO_INT_IMPL(reduct_round, REDUCT_ROUND)
 
REDUCT_API reduct_handle_t reduct_pow(reduct_t* reduct, reduct_handle_t* base, reduct_handle_t* exp)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_promotion_t prom;
    reduct_handle_promote(reduct, base, exp, &prom);
 
    if (prom.type == REDUCT_PROMOTION_TYPE_INT)
    {
        return REDUCT_HANDLE_FROM_INT(
            (reduct_int64_t)REDUCT_POW((reduct_float_t)prom.a.intVal, (reduct_float_t)prom.b.intVal));
    }
    return REDUCT_HANDLE_FROM_FLOAT((reduct_float_t)REDUCT_POW(prom.a.floatVal, prom.b.floatVal));
}
 
REDUCT_API reduct_handle_t reduct_log(struct reduct* reduct, reduct_handle_t* val, reduct_handle_t* base)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    if (base == REDUCT_NULL)
    {
        if (REDUCT_HANDLE_IS_INT_SHAPED(val))
        {
            reduct_handle_t iVal = reduct_get_int(reduct, val);
            reduct_int64_t i = REDUCT_HANDLE_TO_INT(&iVal);
            return REDUCT_HANDLE_FROM_INT((reduct_int64_t)REDUCT_LOG(i));
        }
 
        reduct_handle_t floatVal = reduct_get_float(reduct, val);
        reduct_float_t f = REDUCT_HANDLE_TO_FLOAT(&floatVal);
        return REDUCT_HANDLE_FROM_FLOAT((reduct_float_t)REDUCT_LOG(f));
    }
 
    reduct_promotion_t prom;
    reduct_handle_promote(reduct, val, base, &prom);
 
    if (prom.type == REDUCT_PROMOTION_TYPE_INT)
    {
        reduct_float_t res = REDUCT_LOG((reduct_float_t)prom.a.intVal) / REDUCT_LOG((reduct_float_t)prom.b.intVal);
        return REDUCT_HANDLE_FROM_INT((reduct_int64_t)res);
    }
    reduct_float_t res = REDUCT_LOG(prom.a.floatVal) / REDUCT_LOG(prom.b.floatVal);
    return REDUCT_HANDLE_FROM_FLOAT((reduct_float_t)res);
}
 
#define REDUCT_MATH_UNARY_FLOAT_IMPL(_name, _func) \
    REDUCT_API reduct_handle_t _name(struct reduct* reduct, reduct_handle_t* val) \
    { \
        REDUCT_ASSERT(reduct != REDUCT_NULL); \
        reduct_handle_t fv = reduct_get_float(reduct, val); \
        return REDUCT_HANDLE_FROM_FLOAT((reduct_float_t)_func(REDUCT_HANDLE_TO_FLOAT(&fv))); \
    }
 
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_sin, REDUCT_SIN)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_cos, REDUCT_COS)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_tan, REDUCT_TAN)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_asin, REDUCT_ASIN)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_acos, REDUCT_ACOS)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_atan, REDUCT_ATAN)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_sinh, REDUCT_SINH)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_cosh, REDUCT_COSH)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_tanh, REDUCT_TANH)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_asinh, REDUCT_ASINH)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_acosh, REDUCT_ACOSH)
REDUCT_MATH_UNARY_FLOAT_IMPL(reduct_atanh, REDUCT_ATANH)
 
REDUCT_API reduct_handle_t reduct_atan2(struct reduct* reduct, reduct_handle_t* y, reduct_handle_t* x)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    reduct_handle_t yFloatVal = reduct_get_float(reduct, y);
    reduct_handle_t xFloatVal = reduct_get_float(reduct, x);
    reduct_float_t yf = REDUCT_HANDLE_TO_FLOAT(&yFloatVal);
    reduct_float_t xf = REDUCT_HANDLE_TO_FLOAT(&xFloatVal);
    return REDUCT_HANDLE_FROM_FLOAT((reduct_float_t)REDUCT_ATAN2(yf, xf));
}
 
REDUCT_API reduct_handle_t reduct_rand(struct reduct* reduct, reduct_handle_t* minVal, reduct_handle_t* maxVal)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    reduct_promotion_t prom;
    reduct_handle_promote(reduct, minVal, maxVal, &prom);
 
    reduct_float_t r = (reduct_float_t)REDUCT_RAND() / (reduct_float_t)REDUCT_RAND_MAX;
 
    if (prom.type == REDUCT_PROMOTION_TYPE_INT)
    {
        reduct_int64_t res = prom.a.intVal + (reduct_int64_t)(r * (prom.b.intVal - prom.a.intVal));
        return REDUCT_HANDLE_FROM_INT(res);
    }
    reduct_float_t res = prom.a.floatVal + (r * (prom.b.floatVal - prom.a.floatVal));
    return REDUCT_HANDLE_FROM_FLOAT(res);
}
 
REDUCT_API reduct_handle_t reduct_seed(struct reduct* reduct, reduct_handle_t* val)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
    reduct_handle_t iVal = reduct_get_int(reduct, val);
    reduct_int64_t i = REDUCT_HANDLE_TO_INT(&iVal);
    REDUCT_SRAND((unsigned int)i);
    return reduct_handle_nil(reduct);
}
 
#define REDUCT_STDLIB_WRAPPER_0(_name, _impl) \
    static reduct_handle_t reduct_stdlib_##_name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        reduct_error_check_arity(reduct, argc, 0, #_name); \
        (void)argv; \
        return _impl(reduct); \
    }
 
#define REDUCT_STDLIB_WRAPPER_1(_name, _impl) \
    static reduct_handle_t reduct_stdlib_##_name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        reduct_error_check_arity(reduct, argc, 1, #_name); \
        return _impl(reduct, &argv[0]); \
    }
 
#define REDUCT_STDLIB_WRAPPER_2(_name, _impl) \
    static reduct_handle_t reduct_stdlib_##_name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        reduct_error_check_arity(reduct, argc, 2, #_name); \
        return _impl(reduct, &argv[0], &argv[1]); \
    }
 
#define REDUCT_STDLIB_WRAPPER_3(_name, _impl) \
    static reduct_handle_t reduct_stdlib_##_name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        reduct_error_check_arity(reduct, argc, 3, #_name); \
        return _impl(reduct, &argv[0], &argv[1], &argv[2]); \
    }
 
#define REDUCT_STDLIB_WRAPPER_R12(_name, _impl) \
    static reduct_handle_t reduct_stdlib_##_name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        reduct_error_check_arity_range(reduct, argc, 1, 2, #_name); \
        return _impl(reduct, &argv[0], argc == 2 ? &argv[1] : REDUCT_NULL); \
    }
 
#define REDUCT_STDLIB_WRAPPER_R23(_name, _impl) \
    static reduct_handle_t reduct_stdlib_##_name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        reduct_error_check_arity_range(reduct, argc, 2, 3, #_name); \
        return _impl(reduct, &argv[0], &argv[1], argc == 3 ? &argv[2] : REDUCT_NULL); \
    }
 
#define REDUCT_STDLIB_WRAPPER_R34(_name, _impl) \
    static reduct_handle_t reduct_stdlib_##_name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        reduct_error_check_arity_range(reduct, argc, 3, 4, #_name); \
        return _impl(reduct, &argv[0], &argv[1], &argv[2], argc == 4 ? &argv[3] : REDUCT_NULL); \
    }
 
#define REDUCT_STDLIB_WRAPPER_ARG2(_name, _impl) \
    static reduct_handle_t reduct_stdlib_##_name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        reduct_error_check_arity(reduct, argc, 2, #_name); \
        return _impl(reduct, &argv[0], &argv[1]); \
    }
 
#define REDUCT_STDLIB_WRAPPER_V1(_name, _impl) \
    static reduct_handle_t reduct_stdlib_##_name(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv) \
    { \
        reduct_error_check_min_arity(reduct, argc, 1, #_name); \
        return _impl(reduct, argc, argv); \
    }
 
REDUCT_STDLIB_WRAPPER_2(assert, reduct_assert)
REDUCT_STDLIB_WRAPPER_1(throw, reduct_throw)
REDUCT_STDLIB_WRAPPER_2(try, reduct_try)
REDUCT_STDLIB_WRAPPER_2(map, reduct_map)
REDUCT_STDLIB_WRAPPER_2(filter, reduct_filter)
REDUCT_STDLIB_WRAPPER_2(apply, reduct_apply)
REDUCT_STDLIB_WRAPPER_V1(len, reduct_len)
REDUCT_STDLIB_WRAPPER_V1(is_atom, reduct_is_atom)
REDUCT_STDLIB_WRAPPER_V1(is_int, reduct_is_int)
REDUCT_STDLIB_WRAPPER_V1(is_float, reduct_is_float)
REDUCT_STDLIB_WRAPPER_V1(is_number, reduct_is_number)
REDUCT_STDLIB_WRAPPER_V1(is_string, reduct_is_string)
REDUCT_STDLIB_WRAPPER_V1(is_lambda, reduct_is_lambda)
REDUCT_STDLIB_WRAPPER_V1(is_native, reduct_is_native)
REDUCT_STDLIB_WRAPPER_V1(is_callable, reduct_is_callable)
REDUCT_STDLIB_WRAPPER_V1(is_list, reduct_is_list)
REDUCT_STDLIB_WRAPPER_V1(is_empty, reduct_is_empty)
REDUCT_STDLIB_WRAPPER_V1(is_nil, reduct_is_nil)
 
static reduct_handle_t reduct_stdlib_reduce(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    reduct_error_check_arity_range(reduct, argc, 2, 3, "reduce");
    return reduct_reduce(reduct, &argv[0], argc == 3 ? &argv[1] : REDUCT_NULL, argc == 3 ? &argv[2] : &argv[1]);
}
 
REDUCT_STDLIB_WRAPPER_R12(any, reduct_any)
REDUCT_STDLIB_WRAPPER_R12(all, reduct_all)
REDUCT_STDLIB_WRAPPER_R12(sort, reduct_sort)
REDUCT_STDLIB_WRAPPER_R12(flatten, reduct_flatten)
REDUCT_STDLIB_WRAPPER_R12(log, reduct_log)
 
static reduct_handle_t reduct_stdlib_range(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    reduct_error_check_arity_range(reduct, argc, 1, 3, "range");
    reduct_handle_t* start = (argc >= 2) ? &argv[0] : REDUCT_NULL;
    reduct_handle_t* end = (argc == 1) ? &argv[0] : (argc >= 2 ? &argv[1] : REDUCT_NULL);
    reduct_handle_t* step = (argc == 3) ? &argv[2] : REDUCT_NULL;
 
    if (argc == 1)
    {
        reduct_handle_t zero = REDUCT_HANDLE_FROM_INT(0);
        return reduct_range(reduct, &zero, end, REDUCT_NULL);
    }
 
    return reduct_range(reduct, start, end, step);
}
 
static reduct_handle_t reduct_stdlib_concat(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    return reduct_concat(reduct, argc, argv);
}
 
REDUCT_STDLIB_WRAPPER_1(first, reduct_first)
REDUCT_STDLIB_WRAPPER_1(last, reduct_last)
REDUCT_STDLIB_WRAPPER_1(rest, reduct_rest)
REDUCT_STDLIB_WRAPPER_1(init, reduct_init)
REDUCT_STDLIB_WRAPPER_1(reverse, reduct_reverse)
REDUCT_STDLIB_WRAPPER_1(unique, reduct_unique)
REDUCT_STDLIB_WRAPPER_1(keys, reduct_keys)
REDUCT_STDLIB_WRAPPER_1(values, reduct_values)
REDUCT_STDLIB_WRAPPER_R23(nth, reduct_nth)
REDUCT_STDLIB_WRAPPER_R23(slice, reduct_slice)
REDUCT_STDLIB_WRAPPER_R23(get_in, reduct_get_in)
REDUCT_STDLIB_WRAPPER_R34(assoc, reduct_assoc)
REDUCT_STDLIB_WRAPPER_ARG2(dissoc, reduct_dissoc)
REDUCT_STDLIB_WRAPPER_R34(update, reduct_update)
REDUCT_STDLIB_WRAPPER_ARG2(index_of, reduct_index_of)
REDUCT_STDLIB_WRAPPER_ARG2(contains, reduct_contains)
REDUCT_STDLIB_WRAPPER_3(replace, reduct_replace)
REDUCT_STDLIB_WRAPPER_ARG2(chunk, reduct_chunk)
REDUCT_STDLIB_WRAPPER_ARG2(find, reduct_find)
REDUCT_STDLIB_WRAPPER_3(assoc_in, reduct_assoc_in)
REDUCT_STDLIB_WRAPPER_ARG2(dissoc_in, reduct_dissoc_in)
REDUCT_STDLIB_WRAPPER_3(update_in, reduct_update_in)
REDUCT_STDLIB_WRAPPER_V1(merge, reduct_merge)
REDUCT_STDLIB_WRAPPER_V1(explode, reduct_explode)
REDUCT_STDLIB_WRAPPER_V1(implode, reduct_implode)
 
static reduct_handle_t reduct_stdlib_repeat(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    reduct_error_check_arity(reduct, argc, 2, "repeat");
    return reduct_repeat(reduct, &argv[0], &argv[1]);
}
 
REDUCT_STDLIB_WRAPPER_ARG2(starts_with, reduct_starts_with)
REDUCT_STDLIB_WRAPPER_ARG2(ends_with, reduct_ends_with)
REDUCT_STDLIB_WRAPPER_ARG2(join, reduct_join)
REDUCT_STDLIB_WRAPPER_ARG2(split, reduct_split)
 
REDUCT_STDLIB_WRAPPER_1(upper, reduct_upper)
REDUCT_STDLIB_WRAPPER_1(lower, reduct_lower)
REDUCT_STDLIB_WRAPPER_1(trim, reduct_trim)
REDUCT_STDLIB_WRAPPER_1(int, reduct_get_int)
REDUCT_STDLIB_WRAPPER_1(float, reduct_get_float)
REDUCT_STDLIB_WRAPPER_1(string, reduct_get_string)
 
static reduct_handle_t reduct_stdlib_eval_impl(reduct_t* reduct, reduct_handle_t* arg)
{
    return reduct_eval(reduct, reduct_compile(reduct, arg));
}
REDUCT_STDLIB_WRAPPER_1(eval, reduct_stdlib_eval_impl)
 
static reduct_handle_t reduct_stdlib_parse_impl(reduct_t* reduct, reduct_handle_t* arg)
{
    char* str;
    reduct_size_t len;
    reduct_handle_get_string_params(reduct, arg, &str, &len);
    return reduct_parse(reduct, str, len, "<parse>");
}
REDUCT_STDLIB_WRAPPER_1(parse, reduct_stdlib_parse_impl)
 
REDUCT_STDLIB_WRAPPER_1(run, reduct_run)
REDUCT_STDLIB_WRAPPER_1(load, reduct_load)
REDUCT_STDLIB_WRAPPER_1(read_file, reduct_read_file)
REDUCT_STDLIB_WRAPPER_2(write_file, reduct_write_file)
REDUCT_STDLIB_WRAPPER_0(read_char, reduct_read_char)
REDUCT_STDLIB_WRAPPER_0(read_line, reduct_read_line)
 
static reduct_handle_t reduct_stdlib_print(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    return reduct_print(reduct, argc, argv);
}
 
static reduct_handle_t reduct_stdlib_println(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    return reduct_println(reduct, argc, argv);
}
 
REDUCT_STDLIB_WRAPPER_1(ord, reduct_ord)
REDUCT_STDLIB_WRAPPER_1(chr, reduct_chr)
 
static reduct_handle_t reduct_stdlib_format(reduct_t* reduct, reduct_size_t argc, reduct_handle_t* argv)
{
    return reduct_format(reduct, argc, argv);
}
 
REDUCT_STDLIB_WRAPPER_0(now, reduct_now)
REDUCT_STDLIB_WRAPPER_0(uptime, reduct_uptime)
REDUCT_STDLIB_WRAPPER_0(env, reduct_env)
REDUCT_STDLIB_WRAPPER_0(args, reduct_args)
REDUCT_STDLIB_WRAPPER_V1(min, reduct_min)
REDUCT_STDLIB_WRAPPER_V1(max, reduct_max)
REDUCT_STDLIB_WRAPPER_3(clamp, reduct_clamp)
 
REDUCT_STDLIB_WRAPPER_1(abs, reduct_abs)
REDUCT_STDLIB_WRAPPER_1(floor, reduct_floor)
REDUCT_STDLIB_WRAPPER_1(ceil, reduct_ceil)
REDUCT_STDLIB_WRAPPER_1(round, reduct_round)
REDUCT_STDLIB_WRAPPER_1(exp, reduct_exp)
REDUCT_STDLIB_WRAPPER_1(sqrt, reduct_sqrt)
REDUCT_STDLIB_WRAPPER_1(sin, reduct_sin)
REDUCT_STDLIB_WRAPPER_2(pow, reduct_pow)
 
REDUCT_STDLIB_WRAPPER_1(cos, reduct_cos)
REDUCT_STDLIB_WRAPPER_1(tan, reduct_tan)
REDUCT_STDLIB_WRAPPER_1(asin, reduct_asin)
REDUCT_STDLIB_WRAPPER_1(acos, reduct_acos)
REDUCT_STDLIB_WRAPPER_1(atan, reduct_atan)
REDUCT_STDLIB_WRAPPER_1(sinh, reduct_sinh)
REDUCT_STDLIB_WRAPPER_1(cosh, reduct_cosh)
REDUCT_STDLIB_WRAPPER_1(tanh, reduct_tanh)
REDUCT_STDLIB_WRAPPER_1(asinh, reduct_asinh)
REDUCT_STDLIB_WRAPPER_1(acosh, reduct_acosh)
REDUCT_STDLIB_WRAPPER_1(atanh, reduct_atanh)
REDUCT_STDLIB_WRAPPER_2(atan2, reduct_atan2)
REDUCT_STDLIB_WRAPPER_2(rand, reduct_rand)
REDUCT_STDLIB_WRAPPER_1(seed, reduct_seed)
 
REDUCT_API void reduct_stdlib_register(reduct_t* reduct, reduct_stdlib_sets_t sets)
{
    REDUCT_ASSERT(reduct != REDUCT_NULL);
 
    if (sets & REDUCT_STDLIB_ERROR)
    {
        reduct_native_t natives[] = {
            {"assert!", reduct_stdlib_assert},
            {"throw!", reduct_stdlib_throw},
            {"try", reduct_stdlib_try},
        };
        reduct_native_register(reduct, natives, sizeof(natives) / sizeof(reduct_native_t));
    }
    if (sets & REDUCT_STDLIB_HIGHER_ORDER)
    {
        reduct_native_t natives[] = {
            {"map", reduct_stdlib_map},
            {"filter", reduct_stdlib_filter},
            {"reduce", reduct_stdlib_reduce},
            {"apply", reduct_stdlib_apply},
            {"any?", reduct_stdlib_any},
            {"all?", reduct_stdlib_all},
            {"sort", reduct_stdlib_sort},
        };
        reduct_native_register(reduct, natives, sizeof(natives) / sizeof(reduct_native_t));
    }
    if (sets & REDUCT_STDLIB_SEQUENCES)
    {
        reduct_native_t natives[] = {
            {"len", reduct_stdlib_len},
            {"range", reduct_stdlib_range},
            {"concat", reduct_stdlib_concat},
            {"first", reduct_stdlib_first},
            {"last", reduct_stdlib_last},
            {"rest", reduct_stdlib_rest},
            {"init", reduct_stdlib_init},
            {"nth", reduct_stdlib_nth},
            {"assoc", reduct_stdlib_assoc},
            {"dissoc", reduct_stdlib_dissoc},
            {"update", reduct_stdlib_update},
            {"index-of", reduct_stdlib_index_of},
            {"reverse", reduct_stdlib_reverse},
            {"slice", reduct_stdlib_slice},
            {"flatten", reduct_stdlib_flatten},
            {"contains?", reduct_stdlib_contains},
            {"replace", reduct_stdlib_replace},
            {"unique", reduct_stdlib_unique},
            {"chunk", reduct_stdlib_chunk},
            {"find", reduct_stdlib_find},
            {"get-in", reduct_stdlib_get_in},
            {"assoc-in", reduct_stdlib_assoc_in},
            {"dissoc-in", reduct_stdlib_dissoc_in},
            {"update-in", reduct_stdlib_update_in},
            {"keys", reduct_stdlib_keys},
            {"values", reduct_stdlib_values},
            {"merge", reduct_stdlib_merge},
            {"explode", reduct_stdlib_explode},
            {"implode", reduct_stdlib_implode},
            {"repeat", reduct_stdlib_repeat},
        };
        reduct_native_register(reduct, natives, sizeof(natives) / sizeof(reduct_native_t));
    }
    if (sets & REDUCT_STDLIB_STRING)
    {
        reduct_native_t natives[] = {
            {"starts-with?", reduct_stdlib_starts_with},
            {"ends-with?", reduct_stdlib_ends_with},
            {"contains?", reduct_stdlib_contains},
            {"replace", reduct_stdlib_replace},
            {"join", reduct_stdlib_join},
            {"split", reduct_stdlib_split},
            {"upper", reduct_stdlib_upper},
            {"lower", reduct_stdlib_lower},
            {"trim", reduct_stdlib_trim},
        };
        reduct_native_register(reduct, natives, sizeof(natives) / sizeof(reduct_native_t));
    }
    if (sets & REDUCT_STDLIB_INTROSPECTION)
    {
        reduct_native_t natives[] = {
            {"atom?", reduct_stdlib_is_atom},
            {"int?", reduct_stdlib_is_int},
            {"float?", reduct_stdlib_is_float},
            {"number?", reduct_stdlib_is_number},
            {"string?", reduct_stdlib_is_string},
            {"lambda?", reduct_stdlib_is_lambda},
            {"native?", reduct_stdlib_is_native},
            {"callable?", reduct_stdlib_is_callable},
            {"list?", reduct_stdlib_is_list},
            {"empty?", reduct_stdlib_is_empty},
            {"nil?", reduct_stdlib_is_nil},
        };
        reduct_native_register(reduct, natives, sizeof(natives) / sizeof(reduct_native_t));
    }
    if (sets & REDUCT_STDLIB_TYPE_CASTING)
    {
        reduct_native_t natives[] = {
            {"int", reduct_stdlib_int},
            {"float", reduct_stdlib_float},
            {"string", reduct_stdlib_string},
        };
        reduct_native_register(reduct, natives, sizeof(natives) / sizeof(reduct_native_t));
    }
    if (sets & REDUCT_STDLIB_SYSTEM)
    {
        reduct_native_t natives[] = {
            {"eval", reduct_stdlib_eval},
            {"parse", reduct_stdlib_parse},
            {"run", reduct_stdlib_run},
            {"load!", reduct_stdlib_load},
            {"read-file!", reduct_stdlib_read_file},
            {"write-file!", reduct_stdlib_write_file},
            {"read-char!", reduct_stdlib_read_char},
            {"read-line!", reduct_stdlib_read_line},
            {"print!", reduct_stdlib_print},
            {"println!", reduct_stdlib_println},
            {"ord", reduct_stdlib_ord},
            {"chr", reduct_stdlib_chr},
            {"format", reduct_stdlib_format},
            {"now!", reduct_stdlib_now},
            {"uptime!", reduct_stdlib_uptime},
            {"env!", reduct_stdlib_env},
            {"args!", reduct_stdlib_args},
        };
        reduct_native_register(reduct, natives, sizeof(natives) / sizeof(reduct_native_t));
    }
    if (sets & REDUCT_STDLIB_MATH)
    {
        reduct_native_t natives[] = {
            {"min", reduct_stdlib_min},
            {"max", reduct_stdlib_max},
            {"clamp", reduct_stdlib_clamp},
            {"abs", reduct_stdlib_abs},
            {"floor", reduct_stdlib_floor},
            {"ceil", reduct_stdlib_ceil},
            {"round", reduct_stdlib_round},
            {"pow", reduct_stdlib_pow},
            {"exp", reduct_stdlib_exp},
            {"log", reduct_stdlib_log},
            {"sqrt", reduct_stdlib_sqrt},
            {"sin", reduct_stdlib_sin},
            {"cos", reduct_stdlib_cos},
            {"tan", reduct_stdlib_tan},
            {"asin", reduct_stdlib_asin},
            {"acos", reduct_stdlib_acos},
            {"atan", reduct_stdlib_atan},
            {"atan2", reduct_stdlib_atan2},
            {"sinh", reduct_stdlib_sinh},
            {"cosh", reduct_stdlib_cosh},
            {"tanh", reduct_stdlib_tanh},
            {"asinh", reduct_stdlib_asinh},
            {"acosh", reduct_stdlib_acosh},
            {"atanh", reduct_stdlib_atanh},
            {"rand", reduct_stdlib_rand},
            {"seed!", reduct_stdlib_seed},
        };
        reduct_native_register(reduct, natives, sizeof(natives) / sizeof(reduct_native_t));
    }
}
 
#endif