// List processing

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

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

let boolfiltrator = macro(item) => {
    result = item < 5,
};

let identity_list_reducer = macro(acc, item) => {
    result = acc + [item],
};

assert {
    ok = reduce identity_list_reducer.result [], list1 == list1,
    desc = "reduce identity_list_reducer.result [], list1 == list1",
};

let nested_list = {
    list = list1,
};

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

let list_reducer = macro(acc, item) => {
    result = acc + item,
};

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

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

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

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

let identity_tpl_mapper = macro(name, val) => {
    result = [name, val],
};

assert {
    ok = map identity_tpl_mapper.result test_tpl == test_tpl,
    desc = "map identity_tpl_mapper.result test_tpl == test_tpl",
};

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

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

let identity_tpl_filter = macro(name, val) => {
    result = true,
};

// strip out foo field
let tpl_filter = macro(name, val) => {
    result = name != "foo",
};

assert {
    ok = filter identity_tpl_filter.result test_tpl == test_tpl,
    desc = "filter identity_tpl_filter.result test_tpl == test_tpl",
};

assert {
    ok = filter tpl_filter.result test_tpl == { quux = "baz" },
    desc = "filter tpl_filter.result test_tpl == { quux = \"baz\" }",
};

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

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