Chaining functions that can throw

[november-kilo]

I was messing around with chaining functions that can throw and ended up with a rough, one-take Try implementation.
Thought I'd share, even if I don't yet know if it's useful or for what.

Result.h

#ifndef RESULT_LIB_H

#define RESULT_LIB_H

#define RESULT_LIB "/lib/Result"
#define Result object RESULT_LIB

#define RESULT_SUCCESS(v) (new Result(1, v, nil))
#define RESULT_FAILURE(e) (new Result(0, nil, e))

#endif

Result.c

/* Immutable Result type. */

#include <Result.h>

inherit format "/lib/util/format";

private int ok;
private mixed value;
private string err;

static void create(int ok, mixed value, string err) {
    ::ok = ok;
    ::value = value;
    ::err = err;
}

int ok() {
    return ok;
}

private void result_error(string str) {
    error("Result " + str + " is undefined.");
}

mixed value() {
    if (!ok) {
        result_error("value");
    }
    return value;
}

string err() {
    if (ok) {
        result_error("err");
    }
    return err;
}

string fold() {
    return ok
        ? format::str_format("Value: {:value}", ([ "value": value ]))
        : "Error: " + err;
}

Try.h

#ifndef TRY_LIB_H

#define TRY_LIB_H

#include <Result.h>

#define TRY_LIB "/lib/Try"
#define Try object TRY_LIB

#define TRY_SUCCESS(v) (new Try(RESULT_SUCCESS(v)))
#define TRY_FAILURE(e) (new Try(RESULT_FAILURE(e)))

#endif

Try.c

/* Compose functions that can throw, short-circuit on error. */

#include <Try.h>

private Result result;

static void create(Result result) {
    ::result = result;
}

Result result() {
    return result;
}

string fold() {
    return result->fold();
}

/*
 * Chains a call to obj->func(previousValue, args...)
 * and returns a new Try unless we've already failed.
 * Catches any error raised by the call into a failed Result.
 */
Try map(object obj, string func, mixed args...) {
    Result r;

    if (!result->ok()) {
        return this_object();
    }

    if (!function_object(func, obj)) {
        return TRY_FAILURE("Not a function: " + func);
    }

    try {
        r = RESULT_SUCCESS(call_other(obj, func, (({ result->value() }) + args)...));
    } catch (err) {
        r = RESULT_FAILURE(err);
    }

    return new Try(r);
}

try_object.c

/* Pure functions to Try. */

private int x;

int initial_value() { return x; }

int add(int prevValue, varargs int y) {
    return prevValue + y;
}

int subtract(int prevValue, varargs int y) {
    return prevValue - y;
}

int multiply(int prevValue, varargs int y) {
    return prevValue * y;
}

int divide(int prevValue, varargs int y) {
    if (y == 0) {
        error("Division by zero");
    }

    return prevValue / y;
}

static create(int x) {
    ::x = x;
}

Usage example

#include <Try.h>

string try_object_path;
object try_object;
string answer;

try_object_path = "/usr/nik/obj/try_object";
compile_object(try_object_path);
try_object = clone_object(try_object_path, 42);

answer = TRY_SUCCESS(try_object->initial_value()) /* presumptuous */
            ->map(try_object, "add", 1)
            ->map(try_object, "divide", 0)
            ->map(try_object, "subtract", 1)
            ->fold();