std.fkc

cong map = fk(arr, f) {
    cong iter = fk(arr, accumulated) {
        if (len(arr) == 0) {
            -> accumulated;
        } else {
            -> iter(rest(arr), push(accumulated, f(front(arr))));
        }
    }

    if (!isInteger(arr)) {
        -> newError("Error: `map` expects an array made of integers.");
    } else {
        -> iter(arr, []);
    }
}

cong reduce = fk(arr, initial, f) {
    cong iter = fk(arr, result) {
        if (len(arr) == 0) {
            -> result;
        } else {
            -> iter(rest(arr), f(result, front(arr)));
        }
    }

    if (!isInteger(arr)) {
        -> newError("Error: `reduce` expects an array made of integers.");
    } else {
        -> iter(arr, initial);
    }
}

cong sum = fk(arr) {
    if (!isInteger(arr)) {
        -> newError("Error: `sum` expects an array made of integers.");
    } else {
        -> reduce(arr, 0, fk(initial, el) { -> initial + el; });
    }
}

cong max = fk(arr) {
    if(!isInteger(arr)) {
        -> newError("Error: `max` expects an array made of integers.");
    } else {
        -> reduce(arr, 0, fk(initial, el) { -> if (el > initial) { el; } else { initial; } });
    }
}

cong min = fk(arr) {
    if(!isInteger(arr)) {
        -> newError("Error: `min` expects an array made of integers.");
    } else {
        -> reduce(arr, 0, fk(initial, el) { -> if (el < initial) { el; } else { initial; } });
    }
}

cong merge = fk(left, right, target) {
    cong merged = [];
    if (target == 0) {
        cong mergeHelper = fk(acc, l, r) {
            if (len(l) == 0) {
                -> push(acc, r);
            }
            if (len(r) == 0) {
                -> push(acc, l);
            }
            if (front(l) > front(r)) {
                -> mergeHelper(push(acc, front(l)), rest(l), r);
            } else{
                -> mergeHelper(push(acc, front(r)), l, rest(r));
            }
        }

        -> mergeHelper(merged, left, right);
    } else {
        cong mergeHelper = fk(acc, l, r) {
            if (len(l) == 0) {
                -> push(acc, r);
            }
            if (len(r) == 0) {
                -> push(acc, l);
            }
            if (front(l) < front(r)) {
                -> mergeHelper(push(acc, front(l)), rest(l), r);
            } else{
                -> mergeHelper(push(acc, front(r)), l, rest(r));
            }
        }

        -> mergeHelper(merged, left, right);
    }
}

cong sort = fk(arr, target) {
    if(!isInteger(target)) {
        -> newError("Error: `sort` expects a target of 0(desc) or 1(asc).");
    }
    if(target * (target - 1) != 0) {
        -> newError("Error: `sort` expects a target of 0(desc) or 1(asc).");
    }
    if (!isInteger(arr)) {
        -> newError("Error: `sort` expects an array made of integers.");
    } else {
        if (len(arr) < 2) {
            -> arr;
        } else {
            cong middle = len(arr) / 2;
            cong left = sort(subArray(arr, 0, middle), target);
            cong right = sort(subArray(arr, middle, len(arr)), target);
            -> merge(left, right, target);
        }
    }
}

cong reverse = fk(arr) {
    if (!isInteger(arr)) {
        -> newError("Error: `reverse` expects an array made of integers.");
    } else {
        cong iter = fk(arr, il, ir) {
            if (il < ir) {
               swap(arr, il, ir);
               iter(arr, il + 1, ir - 1);
            } else {
                -> arr;
            }
        }
        cong rIdx = len(arr) - 1;
        -> iter(arr, 0, rIdx);
    }
}

cong swap = fk(arr, il, ir) {
    if (!isInteger(arr)) {
        -> newError("Error: `swap` expects an array made of integers.");
    } else {
        cong length = len(arr);
        if (il * (length - il) < 0) {
            -> newError("Error: `swap` expects a valid index.");
        }
        if (ir * (length - ir) < 0) {
            -> newError("Error: `swap` expects a valid index.");
        }

        cong tmp = arr[il];
        set arr[il] = arr[ir];
        set arr[ir] = tmp;
    }
}