type SearchPair {
  text: Text
  pattern: Text
}

matched(value: true) (answer: Int) { answer = 120 }
matched(value: false) (answer: Int) { answer = 0 }

containsItem(pair: SearchPair, total: Int) (answer: Int) {
  answer = total + matched(text.contains(pair.text, pair.pattern))
}

containsAll(values: List<SearchPair>) (answer: Int) {
  answer = reduce(containsItem, values, 0)
}

appendTextPiece(piece: Text, state: Text) (answer: Text) {
  answer = state + piece
}

concatenateText(pieces: List<Text>) (answer: Text) {
  answer = reduce(appendTextPiece, pieces, "")
}

appendBytesPiece(piece: Bytes, state: Bytes) (answer: Bytes) {
  answer = dever.bytes.concat(state, piece)
}

concatenateBytes(pieces: List<Bytes>) (answer: Bytes) {
  answer = reduce(appendBytesPiece, pieces, dever.bytes.fromText(""))
}

chain(value: Text) (answer: Text) {
  answer = "[" + value + ":" + value + "]"
}

pair(value: Text) (answer: Text) {
  answer = value + value
}

echo(value: Text) (answer: Text) {
  answer = value
}

joined(value: Text) (answer: Text) {
  answer = (echo(value) + "/") + (value + echo(value))
}

checkedText(value: Int) (answer: Text) {
  checked = value + 1
  answer = "ok"
}

type Problem {
  error Denied(message: Text)
}

denied() (answer: Text) {
  fail(Problem.Denied("first"))
}

failureEntry() (answer: Text) {
  answer = wrap(prefix(denied())) + checkedText(9223372036854775807)
}

faultEntry() (answer: Text) {
  answer = wrap(suffix(checkedText(9223372036854775807))) + denied()
}

verify() (answer: Bool) {
  original = echo("雪🌲")
  copy = original
  copy = copy + "/" + copy
  answer = chain("") == "[:]" and chain(original) == "[雪🌲:雪🌲]"
  answer = answer and joined(original) == "雪🌲/雪🌲雪🌲"
  answer = answer and pair(original) == "雪🌲雪🌲" and original == "雪🌲"
  answer = answer and copy == "雪🌲/雪🌲"
  temporary = echo(original)
  saved = temporary
  wrapped = wrap(temporary)
  answer = answer and wrapped == "【雪🌲】" and saved == "雪🌲"
  answer = answer and wrap(echo("")) == "【】"
  answer = answer and prefix(echo(original)) == "前雪🌲" and suffix(echo(original)) == "雪🌲后"
  answer = answer and original == "雪🌲"
  answer = answer and temporarySuffix(original) == "雪🌲后" and temporarySuffix("") == "后"
  answer = answer and echo(echo(original)) == original
  answer = answer and forwardedSuffix(original) == "雪🌲后" and original == "雪🌲"
  answer = answer and wrap(prefix(suffix(original))) == "【前雪🌲后】"
  answer = answer and wrap(prefix(suffix(""))) == "【前后】"
  answer = answer and wrap(pair(original)) == "【雪🌲雪🌲】" and original == "雪🌲"
  unique = echo("风")
  nested = wrap(prefix(suffix(unique)))
  answer = answer and nested == "【前风后】"
  row = TextRow { name = original }
  copied = sameRow(row)
  copied.name = "风"
  values = [1, 2]
  changed = append(sameList(values), 3)
  answer = answer and row.name == original and copied.name == "风"
  answer = answer and values == [1, 2] and changed == [1, 2, 3]
  answer = answer and sameList(sameList(values)) == values and length(sameList([])) == 0
  answer = answer and sameOptional(null) == null and sameOptional(original) == original
  seed = echo("始")
  saved_seed = seed
  combined = reduce(joinPart, ["雪", "", "🌲"], seed)
  answer = answer and combined == "始雪🌲" and saved_seed == "始"
  answer = answer and reduce(joinPart, [], original) == original
  answer = answer and reduce(joinPart, [original, original], "") == "雪🌲雪🌲"
  answer = answer and reduce(joinPart, stream(["雪", "", "🌲"]), "始") == "始雪🌲"
  owned = echo("雪Ab")
  search = SearchPair { text = owned
pattern = text.lower(owned) }
  answer = answer and search.text == "雪Ab" and search.pattern == "雪ab"
  search.pattern = "改"
  answer = answer and search.text == "雪Ab"
  repeated = SearchPair { text = original
pattern = original }
  repeated.text = "改"
  answer = answer and repeated.pattern == original and original == "雪🌲"
}

recordFailureEntry() (answer: SearchPair) {
  owned = echo("原值")
  answer = SearchPair { text = owned
pattern = denied() + checkedText(9223372036854775807) }
}

joinPart(item: Text, state: Text) (answer: Text) { answer = state + item }

wrap(value: Text) (answer: Text) { answer = "【" + value + "】" }

prefix(value: Text) (answer: Text) { answer = "前" + value }

suffix(value: Text) (answer: Text) { answer = value + "后" }

temporarySuffix(value: Text) (answer: Text) { answer = echo(value) + "后" }

forwardedSuffix(value: Text) (answer: Text) { answer = suffix(echo(echo(value))) }

type TextRow { name: Text }

sameRow(value: TextRow) (answer: TextRow) { answer = value }

sameList(value: List<Int>) (answer: List<Int>) { answer = value }

sameOptional(value: Text?) (answer: Text?) { answer = value }

keepFirst(first: Text, second: Text) (answer: Text) { answer = first }

argumentFailureEntry() (answer: Text) {
  answer = keepFirst("ok", denied())
}

checkedEcho(value: Text) (answer: Text) {
  checked = 9223372036854775807 + length(value)
  answer = value
}

identityFaultEntry() (answer: Text) {
  answer = wrap(checkedEcho("雪"))
}
listContains(values: List<Text>, target: Text) (found: Bool) {
  found = contains(values, target)
}