decimalClass(value: null) (answer: Int) pure { answer = 2 }
decimalClass(value: Decimal < 0.0) (answer: Int) pure { answer = -1 }
decimalClass(value: 0.0) (answer: Int) pure { answer = 0 }
decimalClass(value: other) (answer: Int) pure { answer = 1 }

decimalEdge(value: Decimal <= 1.0) (answer: Int) pure { answer = 0 }
decimalEdge(value: Decimal >= 1.000000000000000000000000000000001) (answer: Int) pure { answer = 1 }

floatClass(value: other) (answer: Int) pure { answer = 2 }
floatClass(value: 1.0e0) (answer: Int) pure { answer = 1 }
floatClass(value: 0.0e0) (answer: Int) pure { answer = 0 }
floatClass(value: null) (answer: Int) pure { answer = -1 }

floatTotal(values: List<Float?>) (answer: Int) pure {
  answer = sum(floatClass, values)
}

zeroInverse(value: 0.0e0) (answer: Float) pure { answer = 1.0e0 / value }
zeroInverse(value: other) (answer: Float) pure { answer = 0.0e0 }

combined(left: other, right: other) (answer: Int) pure { answer = 6 }
combined(left: null, right: Int < 0) (answer: Int) pure { answer = 1 }
combined(left: false, right: other) (answer: Int) pure { answer = 4 }
combined(left: other, right: Int < 0) (answer: Int) pure { answer = 5 }
combined(left: null, right: other) (answer: Int) pure { answer = 2 }
combined(left: false, right: Int < 0) (answer: Int) pure { answer = 3 }

verify() (answer: Bool) {
  decimals = decimalClass(-0.1) == -1 and decimalClass(-0.0) == 0 and decimalClass(0.1) == 1 and decimalClass(null) == 2
  edges = decimalEdge(1.0) == 0 and decimalEdge(1.000000000000000000000000000000001) == 1
  floats = floatClass(null) == -1 and floatClass(1.0e0) == 1 and floatClass(-0.0e0) == 0
  special = floatClass(0.0e0 / 0.0e0) == 2 and floatClass(1.0e0 / 0.0e0) == 2 and floatClass(-1.0e0 / 0.0e0) == 2
  signs = zeroInverse(-0.0e0) < 0.0e0 and zeroInverse(0.0e0) > 0.0e0
  absent = combined(null, -9223372036854775808) == 1 and combined(null, 0) == 2
  disabled = combined(false, -1) == 3 and combined(false, 9223372036854775807) == 4
  enabled = combined(true, -1) == 5 and combined(true, 0) == 6
  batch = floatTotal([]) == 0 and floatTotal([null, -0.0e0, 1.0e0, -1.0e0]) == 2
  optional = optionalTotal([], null) == null and optionalTotal([1, 2], null) == 3 and optionalTotal([1, 2], 4) == 7
  context = shifted([1, 2], null) == [1, 2] and shifted([1, 2], 3) == [4, 5] and length(shifted([], 3)) == 0
  original = optionalTotal([3], null)
  changed = cleared(original)
  copies = original == 3 and changed.old == 3 and changed.changed == null
  nullable_signs = nullableInverse(null) == 0.0e0 and nullableInverse(-0.0e0) < 0.0e0 and nullableInverse(0.0e0) > 0.0e0
  answer = decimals and edges and floats and special and signs and absent and disabled and enabled and batch and optional and context and copies and nullable_signs
}

accumulate(value: Int, state: null) (answer: Int?) pure { answer = value }
accumulate(value: Int, state: Int) (answer: Int?) pure { answer = state + value }

optionalTotal(values: List<Int>, initial: Int?) (answer: Int?) pure {
  answer = reduce(accumulate, values, initial)
}

offset(value: Int, extra: null) (answer: Int) pure { answer = value }
offset(value: Int, extra: Int) (answer: Int) pure { answer = value + extra }

shifted(values: List<Int>, extra: Int?) (answer: List<Int>) pure {
  answer = each(offset, values, extra)
}

cleared(value: Int?) (old: Int?, changed: Int?) pure {
  old = value
  value = null
  changed = value
}

nullableInverse(value: null) (answer: Float) pure { answer = 0.0e0 }
nullableInverse(value: Float) (answer: Float) pure { answer = 1.0e0 / value }