type Local { streams: List<Stream<Int>>
 target: Channel<Int> }

submit(target: Channel<Int>) () {
 local = Local { streams = []
 target = target }
 send(local.target, 1)
}

verify() (answer: Bool) {
 target = channel(Int, 2)
 pending = run(submit(target))
 wait(pending)
 first = receive(target)
 changed = run(reassigned(target))
 wait(changed)
 second = receive(target)
 third = receive(target)
 text_task = run(borrowedText())
 text_ok = wait(text_task)
 projected_task = run(projectedText())
 projected_ok = wait(projected_task)
 nested_task = run(nestedText())
 nested_ok = wait(nested_task)
 length_task = run(lengthSend(target))
 wait(length_task)
 length_value = receive(target)
 first_task = run(firstSend(target))
 wait(first_task)
 first_value = receive(target)
 map_task = run(mapSend(target))
 wait(map_task)
 map_value = receive(target)
 reduce_task = run(reduceSend(target))
 wait(reduce_task)
 reduce_value = receive(target)
 answer = first == 1 and second == 1 and third == 2 and text_ok and projected_ok and nested_ok and length_value == 0 and first_value == 1 and map_value == 1 and reduce_value == 0
}

type TextLocal { streams: List<Stream<Int>>
 text: Text }

type Nested { streams: List<Stream<Int>>
 inner: TextLocal }

reassigned(target: Channel<Int>) () { local = Local { streams = []
 target = target }
 send(local.target, 1)
 local = Local { streams = []
 target = target }
 send(local.target, 2) }

textReady(text: Text) (answer: Bool) { dever.task.sleep(0)
 answer = text == "ready" }

borrowedText() (answer: Bool) { local = TextLocal { streams = []
 text = "ready" }
 answer = textReady(local.text) }

projectedText() (answer: Bool) {
 local = TextLocal { streams = []
 text = "ready" }
 text = local.text
 answer = textReady(text)
}

nestedText() (answer: Bool) { local = Nested { streams = []
 inner = TextLocal { streams = []
 text = "ready" } }
 answer = textReady(local.inner.text) }

empty() (values: List<Stream<Int>>) pure { values = [] }

lengthSend(target: Channel<Int>) () { values = empty()
 send(target, length(values)) }

found(value: null) (answer: Int) pure { answer = 0 }
found(value: Local) (answer: Int) pure { answer = 1 }

firstSend(target: Channel<Int>) () { values = [Local { streams = []
 target = target }]
 send(target, found(first(values))) }

mapSend(target: Channel<Int>) () { values = { 1 = Local { streams = []
 target = target } }
 send(target, found(get(values, 1))) }

count(value: Stream<Int>, state: Int) (next: Int) { close(value)
 next = state + 1 }

reduceSend(target: Channel<Int>) () { values = empty()
 send(target, reduce(count, values, 0)) }