insertText(item: Text, state: Map<Text, Text>) (next: Map<Text, Text>) {
  next = put(state, item, item)
}

buildText(values: List<Text>) (answer: Map<Text, Text>) {
  answer = reduce(insertText, values, {})
}

textWeight(entry: MapEntry<Text, Text>) (answer: Int) {
  answer = length(entry.key) + length(entry.value)
}

ownedText(values: List<Text>) (answer: Int) {
  answer = sum(textWeight, entries(buildText(values)))
}

borrowedText(values: Map<Text, Text>) (answer: Int) {
  answer = sum(textWeight, entries(values))
}

insertNested(item: Text, state: Map<Text, List<Text>>) (next: Map<Text, List<Text>>) {
  next = put(state, item, [item, item])
}

buildNested(values: List<Text>) (answer: Map<Text, List<Text>>) {
  answer = reduce(insertNested, values, {})
}

textSize(value: Text) (answer: Int) {
  answer = length(value)
}

nestedWeight(entry: MapEntry<Text, List<Text>>) (answer: Int) {
  answer = length(entry.key) + sum(textSize, entry.value)
}

ownedNested(values: List<Text>) (answer: Int) {
  answer = sum(nestedWeight, entries(buildNested(values)))
}

borrowedNested(values: Map<Text, List<Text>>) (answer: Int) {
  answer = sum(nestedWeight, entries(values))
}

verify() (answer: Bool) {
  values = ["雪山", "oak", "雪山"]
  text = buildText(values)
  nested = buildNested(values)
  answer = ownedText(values) == 10 and borrowedText(text) == 10
  answer = answer and ownedNested(values) == 15 and borrowedNested(nested) == 15
  answer = answer and borrowedText(text) == 10 and borrowedNested(nested) == 15
  answer = answer and values == ["雪山", "oak", "雪山"]
  answer = answer and ownedText([]) == 0 and ownedNested([]) == 0
  mixed = { 1 = "a"
    2 = "雪" }
  answer = answer and readMixed(mixed) == 5 and get(mixed, 1) == "a"
  answer = answer and texts(text) == ["雪山", "oak"] and borrowedText(text) == 10
  answer = answer and nestedValues(nested) == [["雪山", "雪山"], ["oak", "oak"]]
  answer = answer and borrowedNested(nested) == 15
  answer = answer and firstText("雪") == "雪" and lookupText("oak") == "oak"
  answer = answer and nullableFirst(null) == null and nullableFirst("kept") == "kept"
  answer = answer and get({ "item" = "kept" }, "missing") == null
  answer = answer and nullableLookup(null) == null and nullableLookup("kept") == "kept"
  selected = selectText("kept")
  answer = answer and selected.first_value == "kept" and selected.lookup_value == "kept"
  picked = filterText(text, "oak")
  answer = answer and each(entryText, picked) == ["oak"]
  answer = answer and findText(text, "oak") == first(picked)
  answer = answer and findText(text, "absent") == null and length(filterText(text, "absent")) == 0
  answer = answer and findText({}, "absent") == null and length(filterText({}, "absent")) == 0
  answer = answer and each(entryNested, filterNested(nested, "oak")) == [["oak", "oak"]]
  answer = answer and findNested(nested, "oak") == first(filterNested(nested, "oak"))
  answer = answer and findNested(nested, "absent") == null
  answer = answer and filterMixed(mixed, 2) == entries({ 2 = "雪" })
  same = { "first" = "match"
    "second" = "match" }
  answer = answer and filterText(same, "match") == entries(same)
  answer = answer and findText(same, "match") == first(entries(same))
  changed = each(entryText, picked)
  changed = append(changed, "独立值")
  answer = answer and changed == ["oak", "独立值"] and get(text, "oak") == "oak"
  answer = answer and borrowedText(text) == 10 and borrowedNested(nested) == 15
}

mixedWeight(entry: MapEntry<Int, Text>) (answer: Int) {
  answer = entry.key + length(entry.value)
}

readMixed(values: Map<Int, Text>) (answer: Int) {
  answer = sum(mixedWeight, entries(values))
}

entryText(entry: MapEntry<Text, Text>) (answer: Text) {
  answer = entry.value
}

texts(values: Map<Text, Text>) (answer: List<Text>) {
  answer = each(entryText, entries(values))
}

entryNested(entry: MapEntry<Text, List<Text>>) (answer: List<Text>) {
  answer = entry.value
}

nestedValues(values: Map<Text, List<Text>>) (answer: List<List<Text>>) {
  answer = each(entryNested, entries(values))
}

firstText(value: Text) (answer: Text?) {
  answer = first([value])
}

lookupText(value: Text) (answer: Text?) {
  answer = get({ "item" = value }, "item")
}

nullableFirst(value: Text?) (answer: Text?) {
  answer = first([value])
}

nullableLookup(value: Text?) (answer: Text?) {
  answer = get({ "item" = value }, "item")
}

selectText(value: Text) (first_value: Text?, lookup_value: Text?) {
  values = [value]
  mapping = { "item" = value }
  first_value = first(values)
  lookup_value = get(mapping, "item")
}

matchText(entry: MapEntry<Text, Text>, target: Text) (answer: Bool) {
  answer = entry.value == target
}

filterText(values: Map<Text, Text>, target: Text) (answer: List<MapEntry<Text, Text>>) {
  answer = filter(matchText, entries(values), target)
}

findText(values: Map<Text, Text>, target: Text) (answer: MapEntry<Text, Text>?) {
  answer = find(matchText, entries(values), target)
}

matchNested(entry: MapEntry<Text, List<Text>>, target: Text) (answer: Bool) {
  answer = entry.key == target
}

filterNested(values: Map<Text, List<Text>>, target: Text) (answer: List<MapEntry<Text, List<Text>>>) {
  answer = filter(matchNested, entries(values), target)
}

findNested(values: Map<Text, List<Text>>, target: Text) (answer: MapEntry<Text, List<Text>>?) {
  answer = find(matchNested, entries(values), target)
}

matchMixed(entry: MapEntry<Int, Text>, minimum: Int) (answer: Bool) {
  answer = entry.key >= minimum
}

filterMixed(values: Map<Int, Text>, minimum: Int) (answer: List<MapEntry<Int, Text>>) {
  answer = filter(matchMixed, entries(values), minimum)
}