core/test/rust/fixtures/collection.dever

type Row {
  name: Text
  count: Int
}

type Result {
  Ready(value: Int)
  error Failed(value: Int)
}

checked(value: Int < 0) (answer: Int) {
  fail(Result.Failed(value))
}
checked(value: other) (answer: Int) {
  answer = value
}

double(value: Int) (answer: Int) {
  answer = value * 2
}

positive(value: Int) (answer: Bool) {
  answer = value > 0
}

above(value: Int, threshold: Int) (answer: Bool) {
  answer = value > threshold
}

add(value: Int, state: Int) (next: Int) {
  next = state + value
}

stop(value: Int, state: Int) (next: Int, stop: Bool) {
  next = state + value
  stop = next >= 3
}

ignore(value: Int) () {

}

append(value: Text, suffix: Text) (answer: Text) {
  answer = value + suffix
}

change(value: Row) (answer: Row) {
  answer = value
  answer.name = value.name + "新"
  answer.count = value.count + 1
}

keepRow(value: Row, threshold: Int) (answer: Bool) {
  answer = value.count > threshold
}

extend(value: Text, state: Text) (next: Text) {
  next = state + value
}

mapInts(values: List<Int>) (answer: List<Int>) {
  answer = each(double, values)
}

filterInts(values: List<Int>) (answer: List<Int>) {
  answer = filter(positive, values)
}

findInt(values: List<Int>, threshold: Int) (answer: Int?) {
  answer = find(above, values, threshold)
}

projectSum(values: List<Int>) (answer: Int) {
  answer = sum(double, values)
}

foldSum(values: List<Int>) (answer: Int) {
  answer = reduce(add, values, 0)
}

stopSum(values: List<Int>) (answer: Int) {
  answer = reduceUntil(stop, values, 0)
}

mapRows(values: List<Row>) (answer: List<Row>) {
  answer = each(change, values)
}

projectFloat(value: Float) (answer: Float) {
  answer = value * 2.0
}

projectDecimal(value: Decimal) (answer: Decimal) {
  answer = value * 2
}

floatSum(values: List<Float>) (answer: Float) {
  answer = sum(projectFloat, values)
}

decimalSum(values: List<Decimal>) (answer: Decimal) {
  answer = sum(projectDecimal, values)
}

captureList(values: List<Int>) (answer: Result) {
  answer = result(checkedSum(values))
}

checkedSum(values: List<Int>) (answer: Int) {
  answer = sum(checked, values)
}

insertNext(item: Int, state: Map<Int, Int>) (next: Map<Int, Int>) {
  snapshot = state
  key = length(snapshot)
  key = key + 1
  next = put(state, key, item + length(snapshot))
}

verify() (answer: Bool) recover("compare captured test failures with their expected values") {
  values = [1, -2, 3]
  original = Row { name = "雪"
  count = 2 }
  rows = [original]
  changed = mapRows(rows)
  selected = filter(keepRow, rows, 1)
  found = find(keepRow, rows, 1)
  texts = each(append, ["雪", "山"], "新")
  each(ignore, values)
  empty = each(double, [])
  answer = mapInts(values) == [2, -4, 6]
  answer = answer and filterInts(values) == [1, 3] and findInt(values, 1) == 3 and findInt(values, 3) == null
  answer = answer and projectSum(values) == 4 and foldSum(values) == 2 and stopSum([1, 2, 9223372036854775807]) == 3
  answer = answer and length(empty) == 0 and sum(double, []) == 0 and reduce(add, [], 9) == 9 and reduceUntil(stop, [], 9) == 9
  answer = answer and reduce(checkedAdd, [], 7) == 7 and reduce(checkedAdd, [1, 2, 3], 7) == 13
  answer = answer and texts == ["雪新", "山新"] and reduce(extend, ["雪", "山"], "前") == "前雪山"
  answer = answer and changed == [Row { name = "雪新"
  count = 3 }] and selected == rows and found == original and original.name == "雪" and original.count == 2
  answer = answer and floatSum([1.5, 2.5]) == floatEight() and decimalSum([1.5, 2.5]) == 8
  answer = answer and floatSum([]) == floatZero() and decimalSum([]) == 0
  answer = answer and captureList([1, -2, 3]) == Result.Failed(-2) and captureList([1, 2, 3]) == Result.Ready(6)
  partial = changePartial(original)
  dependent = changeDependent(original)
  answer = answer and partial.name == "雪局" and partial.count == 2 and dependent.name == "雪顺" and dependent.count == 2 and original.name == "雪"
  table = {0 = 7}
  inserted = reduce(insertNext, [2, 3], table)
  answer = answer and inserted == {0 = 7, 2 = 3, 3 = 5} and table == {0 = 7}
  answer = answer and reduce(insertNext, [], table) == table
}

failureEntry() (answer: Int) {
  answer = checkedSum([1, -2, 3])
}

overflowEntry() (answer: Int) {
  answer = sum(addContext, [9223372036854775807, 1], 0)
}

addContext(value: Int, context: Int) (answer: Int) {
  answer = value + context
}

handlerFaultEntry() (answer: Int) {
  answer = projectSum([9223372036854775807])
}

extraEntry() (answer: Int) {
  answer = sum(addContext, [], checked(-9))
}

floatEight() (answer: Float) {
  answer = 8.0
}

floatZero() (answer: Float) {
  answer = 0.0
}

changePartial(value: Row) (answer: Row) {
  answer = value
  answer.name = value.name + "局"
}

changeDependent(value: Row) (answer: Row) {
  answer = value
  answer.name = value.name + "顺"
  answer.count = length(answer.name)
}

failedRow(value: Row) (answer: Row) {
  amount = checked(value.count)
  answer = Row { name = value.name
  count = amount }
}

changeFailed(value: Row) (answer: Row) {
  answer = failedRow(value)
  answer.name = "替"
  answer.count = 0
}

initializeEntry() (answer: Row) {
  answer = changeFailed(Row { name = "原"
  count = -1 })
}

checkedAdd(value: Int, state: Int) (next: Int) {
  next = state + checked(value)
}

reductionFailureEntry() (answer: Int) {
  answer = reduce(checkedAdd, [1, -2, 9223372036854775807], 0)
}