114 lines
3.3 KiB
Plaintext
114 lines
3.3 KiB
Plaintext
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]
|
|
}
|