// List processing

let list1 = [1, 2, 3, 4];
let list2 = ["foo", "bar", "foo", "bar"];

let mapper = func (item) => item + 1;
let filtrator = func (item) =>  select (item, NULL) => {
        foo = item,
};

let boolfiltrator = func (item) => item < 5;

let identity_list_reducer = func (acc, item) =>  acc + [item];

assert {
    ok = reduce(identity_list_reducer, [], list1) == list1,
    desc = "reduce(identity_list_reducer, [], list1) == list1",
};

let nested_list = {
    list = list1,
};

assert {
    ok = reduce(identity_list_reducer, [], (nested_list.list)) == list1,
    desc = "reduce(identity_list_reducer, [], (nested_list.list)) == list1",
};

let list_reducer = func (acc, item) =>  acc + item;

assert {
    ok = reduce(list_reducer, 0, list1) == 0 + 1 + 2 + 3 + 4,
    desc = "reduce(list_reducer, 0, list1) == 0 + 1 + 2 + 3 + 4",
};

assert {
    ok = map(mapper, list1) == [2, 3, 4, 5],
    desc = "map(mapper, list1) == [2, 3, 4, 5]",
};
assert {
    ok = (map(mapper, [1, 2, 3, 4])) == [2, 3, 4, 5],
    desc = "(map(mapper, [1, 2, 3, 4])) == [2, 3, 4, 5]",
};
assert {
    ok = map(mapper, [1, 2, 3, 4]) == [2, 3, 4, 5],
    desc = "map(mapper, [1, 2, 3, 4]) == [2, 3, 4, 5]",
};

let s_mapper = func (arg) => arg + ",";

assert {
    ok = map(s_mapper, "foo") == "f,o,o,",
    desc = "we can map over each character",
};

assert {
    ok = filter(filtrator, list2) == ["foo", "foo"],
    desc = "filter(filtrator, list2) == [\"foo\", \"foo\"]",
};

assert {
    ok = (filter(filtrator, ["foo", "bar", "foo", "bar"])) == ["foo", "foo"],
    desc = "(filter(filtrator, [\"foo\", \"bar\", \"foo\", \"bar\"])) == [\"foo\", \"foo\"]",
};
assert {
    ok = filter(filtrator, ["foo", "bar", "foo", "bar"]) == ["foo", "foo"],
    desc = "filter(filtrator, [\"foo\", \"bar\", \"foo\", \"bar\"]) == [\"foo\", \"foo\"]",
};
assert {
    ok = filter(boolfiltrator, [1, 2, 3, 4, 5, 6, 7]) == [1, 2, 3, 4],
    desc = "filter(boolfiltrator, [1, 2, 3, 4, 5, 6, 7]) == [1, 2, 3, 4]",
};

// Tuple processing
let test_tpl = {
    foo = "bar",
    quux = "baz",
};

let identity_tpl_mapper = func (name, val) => [name, val];

assert {
    ok = map(identity_tpl_mapper, test_tpl) == test_tpl,
    desc = "map(identity_tpl_mapper, test_tpl) == test_tpl",
};

let tpl_mapper = func (name, val) => select (name, [name, val]) => {
    "foo" = ["foo", "barbar"],
    quux = ["cute", "pygmy"],
};

assert {
    ok = map(tpl_mapper, test_tpl) == {foo = "barbar", cute = "pygmy"},
    desc = "map(tpl_mapper, test_tpl) == {foo = \"barbar\", cute = \"pygmy\"}",
};

let identity_tpl_filter = func (name, val) =>  true;

// strip out foo field
let tpl_filter = func (name, val) => name != "foo";

assert {
    ok = filter(identity_tpl_filter, test_tpl) == test_tpl,
    desc = "filter(identity_tpl_filter, test_tpl) == test_tpl",
};

assert {
    ok = filter(tpl_filter, test_tpl) == { quux = "baz" },
    desc = "filter(tpl_filter, test_tpl) == { quux = \"baz\" }",
};

let o_str_filter = func (s) => s != "o";

assert {
    ok = filter(o_str_filter, "foobar") == "fbar",
    desc = "We can strip out characters",
};

let tpl_reducer = func (acc, name, val) => acc{
        keys = self.keys + [name],
        vals = self.vals + [val],
};

assert {
    ok = reduce(tpl_reducer, {keys = [], vals = []}, test_tpl) == {keys = ["foo", "quux"], vals = ["bar", "baz"]},
    desc = "reduce(tpl_reducer, {keys = [], vals = []}, test_tpl) == {keys = [\"foo\", \"quux\"], vals = [\"bar\", \"baz\"]}",
};

let str_identity_reducer = func (acc, s) => acc + s;

assert {
    ok = reduce(str_identity_reducer, "", "foo") == "foo",
    desc = "identity reducer copies string",
};

let char_iter = func (acc, s) => acc + [s];

assert {
    ok = reduce(char_iter, [], "foo") == ["f", "o", "o"],
    desc = "we can split a string into grapheme clusters",
};

assert {
    ok = reduce((char_iter), [], "foo") == ["f", "o", "o"],
    desc = "We can use arbitrary expressions to refer to the macro.",
};

let tpl_with_list = {
    list = [1, 2, 3],
};

assert {
    ok = reduce(func(acc, s) => acc + [s + 1], [], tpl_with_list.list) == [2, 3, 4],
    desc = "We can use full expressions for any of the arguments to reduce",
};

assert {
    ok = map(func(item) => item + 1, tpl_with_list.list) == [2, 3, 4],
    desc = "We can use full expressions for any of the arguments to map",
};

assert {
    ok = filter(func(item) => item != 1, tpl_with_list.list) == [2, 3],
    desc = "We can use full expressions for any of the arguments to map",
};