Chunktional

Chunktional is a collection of macros that can make functional style programming in C convenient.

Abstract Data Types

Uisng the datatype(dataname, ...), datatypeatom(dataname, option), and datatypedefine(dataname, option, structure) macros, you can create Haskell style abstract data types.

Haskell Example:

datatype Maybe = None | Just x

x = None
y = Just 10

Chunktional Example:

datatype(MaybeInt, NoneInt, JustInt);
datatypeempty(MaybeInt, NoneInt);
datatypedefine(MaybeInt, JustInt, {int number;});

int main() {
    MaybeInt *x = mkdatatype(NoneInt);
    MaybeInt *y = mkdatatype(JustInt, 10);

    free(x);
    free(y);

    return 0;
}

Pattern Matching

Using the caseof(value), endcaseof, where(option, result), whereatom(option), and otherwise macros, you can create a kind of case-of statement for use with the abstract data types.

Haskell Example:

f :: Maybe Int -> Int
f m = case m of
        None -> 0
        Just x -> x

Chunktional Example:

int f(MaybeInt *m) {
    caseof(m)
        whereatom(NoneInt) return 0;
        where(JustInt, j) return j->number;
    endcaseof;
    return 0; // we unfortunately need a dummy return value to avoid a compiler warning
}

Closures

Using the closure(type, fn, context, ...) and call(fn, context, ...) macros, you can create a kind of closure over desired values for functions. This can be useful to easily create context for function calls.

Haskell Example:

f :: Int -> Int
f x = fhelper 5
    where fhelper y = x + y

Chunktional Example:

closure(int, fhelper, {int x;}, int y) {
    return closure.x + y;
}

int f(int x) {
    return call(fhelper, {x}, 5);
}