type BufferState { values: List<Int>
count: Int }

bufferStep(value: Int, state: BufferState) (next: BufferState) {
  values = append(state.values, value)
  next = BufferState { values = values
count = state.count + 1 }
}

bufferLengthStep(value: Int, state: BufferState) (next: BufferState) {
  count = length(state.values) + 1
  values = append(state.values, value)
  next = BufferState { values = values
count = count }
}

bufferBuild(values: Bytes) (answer: BufferState) {
  answer = reduce(bufferStep, values, BufferState { values = []
count = 0 })
}

bufferInspect(values: Bytes) (answer: BufferState) {
  answer = reduce(bufferLengthStep, values, BufferState { values = []
count = 0 })
}

type ScalarRow { first: Int
second: Int
third: Int }

scalarTotal(row: ScalarRow) (answer: Int) {
  answer = row.first + row.second + row.third
}

readScalarRows(values: List<ScalarRow>) (answer: Int) {
  answer = sum(scalarTotal, values)
}

type Key {
  First
  Second
}

type Row {
  name: Text
  count: Int
}

type Problem {
  error Denied(message: Text)
}

number(value: Int) (answer: Int) {
  answer = value
}
number(value: null) (answer: Int) {
  answer = 0
}

readKey(key: Int, values: Map<Int, Int>) (answer: Int) {
  answer = number(get(values, key))
}

lookup(values: Map<Int, Int>, keys: List<Int>) (answer: Int) {
  answer = sum(readKey, keys, values)
}

readTextKey(key: Text, values: Map<Text, Int>) (answer: Int) {
  answer = number(get(values, key))
}

lookupText(values: Map<Text, Int>, keys: List<Text>) (answer: Int) {
  answer = sum(readTextKey, keys, values)
}

entryValue(entry: MapEntry<Int, Int>) (answer: Int) {
  answer = entry.value
}

scan(values: Map<Int, Int>) (answer: Int) {
  answer = sum(entryValue, entries(values))
}

insert(item: Int, state: Map<Int, Int>) (next: Map<Int, Int>) {
  next = put(state, item, item)
}

buildMap(values: List<Int>) (answer: Map<Int, Int>) {
  answer = reduce(insert, values, {})
}

buildEntries(values: List<Int>) (answer: List<MapEntry<Int, Int>>) {
  answer = entries(buildMap(values))
}

add(item: Int, state: List<Int>) (next: List<Int>) {
  next = append(state, item)
}

buildList(values: List<Int>) (answer: List<Int>) {
  answer = reduce(add, values, [])
}

rewrite(entry: MapEntry<Text, Row>) (answer: MapEntry<Text, Row>) {
  answer = entry
  answer.key = "new"
  answer.value.name = "changed"
}

rowValue(entry: MapEntry<Text, Row>) (answer: Row) {
  answer = entry.value
}

duplicate(first_key: Text, second_key: Text) (answer: Map<Text, Int>) {
  answer = { first_key = 1
    second_key = 2 }
}

duplicateEntry() (answer: Map<Text, Int>) {
  answer = duplicate("same", "same")
}

denyText() (answer: Text) {
  fail(Problem.Denied("first"))
}

faultText(value: Int) (answer: Text) {
  checked = value + 1
  answer = "key"
}

failureEntry() (answer: Map<Text, Text>) {
  answer = { denyText() = faultText(9223372036854775807) }
}

faultEntry() (answer: Map<Text, Text>) {
  answer = { faultText(9223372036854775807) = denyText() }
}

lookupFailure() (answer: Text?) {
  answer = get({ "item" = denyText() }, faultText(9223372036854775807))
}

lookupFault() (answer: Text?) {
  answer = get({ "item" = faultText(9223372036854775807) }, denyText())
}

optional(values: Map<Text, Int?>) (answer: Int?) {
  answer = get(values, "present")
}

verify() (answer: Bool) {
  original = { "a" = 1
    "b" = 2 }
  changed = put(original, "a", 3)
  extended = put(changed, "c", 4)
  removed = remove(extended, "a")
  reinserted = put(removed, "a", 5)
  answer = original == { "a" = 1
    "b" = 2 } and changed == { "a" = 3
    "b" = 2 }
  answer = answer and original != { "b" = 2
    "a" = 1 } and reinserted == { "b" = 2
    "c" = 4
    "a" = 5 }
  answer = answer and get(original, "none") == null and get(original, "a") == 1
  answer = answer and optional({ "present" = null }) == null and optional({ "present" = 7 }) == 7
  answer = answer and length(remove(original, "missing")) == 2
  rows = { "old" = Row { name = "雪"
    count = 4 } }
  rewritten = each(rewrite, entries(rows))
  answer = answer and each(rowValue, rewritten) == [Row { name = "changed"
    count = 4 }]
  answer = answer and get(rows, "old") == Row { name = "雪"
    count = 4 }
  choices = { Key.First = 7
    Key.Second = 9 }
  booleans = { true = "yes"
    false = "no" }
  answer = answer and get(choices, Key.Second) == 9 and get(booleans, false) == "no"
  list = [1, 2]
  appended = append(list, 3)
  answer = answer and list == [1, 2] and appended == [1, 2, 3] and first(list) == 1
  answer = answer and buildList([3, 1, 4]) == [3, 1, 4] and length(buildList([])) == 0
  built = buildMap([3, 1, 4, 1])
  answer = answer and built == { 3 = 3
    1 = 1
    4 = 4 } and lookup(built, [4, 1, 99]) == 5 and scan(built) == 8
  answer = answer and length(buildMap([])) == 0
  answer = answer and buildEntries([3, 1, 4, 1]) == entries(built)
}

staticLookupFailure() (answer: Text?) {
  answer = get({ "selected" = "kept"
    "other" = denyText() }, "selected")
}

staticMissingFailure() (answer: Text?) {
  answer = get({ "other" = denyText() }, "missing")
}

traceMapValue(value: Text) (answer: Text) {
  dever.io.println(value)
  answer = value
}

traceLiteralLookup() (answer: Bool) {
  value = get({ "a" = traceMapValue("first")
    "b" = traceMapValue("second")
    "c" = traceMapValue("third") }, "a")
  listed = first([traceMapValue("fourth"), traceMapValue("fifth")])
  answer = value == "first" and listed == "fourth"
}