type Problem {
  error Denied(message: Text)
}

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

stopAppend(item: Int, state: List<Int>) (next: List<Int>, stop: Bool) {
  next = append(state, item)
  stop = item == 2
}

build(items: List<Int>, initial: List<Int>) (answer: List<Int>) {
  answer = reduce(appendSnapshot, items, initial)
}

keep(entry: MapEntry<Text, Int>) (answer: Bool) {
  answer = entry.value > 1
}

merge(entry: MapEntry<Text, Int>, state: Map<Text, Int>) (next: Map<Text, Int>) {
  next = put(state, entry.key, entry.value)
}

stopMerge(entry: MapEntry<Text, Int>, state: Map<Text, Int>) (next: Map<Text, Int>, stop: Bool) {
  next = put(state, entry.key, entry.value)
  stop = entry.value == 2
}

fallibleAppend(item: 0, state: List<Int>) (next: List<Int>) {
  next = append(state, item)
  fail(Problem.Denied("owned state"))
}
fallibleAppend(item: other, state: List<Int>) (next: List<Int>) {
  next = append(state, item + 1)
}

failureEntry() (answer: List<Int>) {
  answer = reduce(fallibleAppend, [1, 0, 9223372036854775807], [])
}

faultEntry() (answer: List<Int>) {
  answer = reduce(fallibleAppend, [9223372036854775807, 0], [])
}

verify() (answer: Bool) {
  initial = [10]
  answer = build([1, 2], initial) == [10, 1, 1, 2, 3] and initial == [10]
  answer = answer and build([], initial) == initial
  answer = answer and reduceUntil(stopAppend, [1, 2, 3], initial) == [10, 1, 2]
  answer = answer and initial == [10]
  original = { "a" = 1
    "b" = 2
    "c" = 3 }
  selected = filter(keep, entries(original))
  answer = answer and selected == entries({ "b" = 2
    "c" = 3 })
  answer = answer and find(keep, entries(original)) == first(selected)
  copied = entries(original)
  seed = { "seed" = 9 }
  merged = reduce(merge, entries(original), seed)
  answer = answer and merged == { "seed" = 9
    "a" = 1
    "b" = 2
    "c" = 3 }
  stopped = reduceUntil(stopMerge, entries(original), seed)
  answer = answer and stopped == { "seed" = 9
    "a" = 1
    "b" = 2 }
  answer = answer and seed == { "seed" = 9 } and entries(original) == copied
  answer = answer and verifyAppend(original)
  answer = answer and verifyForwarding()
}

appendEntry(entry: MapEntry<Text, Int>, state: List<MapEntry<Text, Int>>) (next: List<MapEntry<Text, Int>>) {
  next = append(state, entry)
}

verifyAppend(original: Map<Text, Int>) (answer: Bool) {
  initial = entries({ "seed" = 9 })
  copied = reduce(appendEntry, entries(original), initial)
  answer = copied == entries({ "seed" = 9
    "a" = 1
    "b" = 2
    "c" = 3 })
  answer = answer and initial == entries({ "seed" = 9 })
  answer = answer and reduce(appendEntry, entries({}), initial) == initial
}

passValues(values: List<Int>) (answer: List<Int>) { answer = values }

combineValues(first: List<Int>, second: List<Int>) (answer: List<Int>) {
  answer = append(first, sum(second))
}

forwardValues(values: List<Int>) (answer: List<Int>) {
  local = append(values, 7)
  alias = local
  moved = passValues(local)
  moved = append(moved, 9)
  answer = combineValues(moved, alias)
}

verifyForwarding() (answer: Bool) {
  original = [1, 2]
  forwarded = forwardValues(original)
  answer = forwarded == [1, 2, 7, 9, 10] and original == [1, 2]
  shared = [3, 4]
  combined = combineValues(shared, shared)
  answer = answer and combined == [3, 4, 7] and shared == [3, 4]
}