Initial Dever 0.0.1

test/rust/fixtures/id.dever

@@ -0,0 +1,101 @@
+type Count {
+  expected: Id
+  total: Int
+}
+
+encode(text: Text) (answer: Id) {
+  answer = dever.id.fromText(text)
+}
+
+decode(value: Id) (answer: Text) {
+  answer = dever.id.toText(value)
+}
+
+roundtrip(text: Text) (answer: Text) {
+  answer = dever.id.toText(dever.id.fromText(text))
+}
+
+encodeAll(texts: List<Text>) (answer: List<Id>) {
+  answer = each(dever.id.fromText, texts)
+}
+
+countMatch(value: Id, state: Count) (next: Count) {
+  next = state
+  next.total = state.total + matching(value == state.expected)
+}
+
+matching(value: true) (answer: Int) { answer = 1 }
+matching(value: false) (answer: Int) { answer = 0 }
+
+countEqual(values: List<Id>, expected: Id) (answer: Int) {
+  state = reduce(countMatch, values, Count { expected = expected
+ total = 0 })
+  answer = state.total
+}
+
+readKey(key: Id, values: Map<Id, Int>) (answer: Int) {
+  answer = present(get(values, key))
+}
+
+present(value: Int) (answer: Int) { answer = value }
+present(value: null) (answer: Int) { answer = 0 }
+
+lookup(values: Map<Id, Int>, keys: List<Id>) (answer: Int) {
+  answer = sum(readKey, keys, values)
+}
+
+insert(text: Text, state: Map<Id, Int>) (next: Map<Id, Int>) {
+  next = put(state, dever.id.fromText(text), length(text))
+}
+
+buildMap(texts: List<Text>) (answer: Map<Id, Int>) {
+  answer = reduce(insert, texts, {})
+}
+
+buildEntries(texts: List<Text>) (answer: List<MapEntry<Id, Int>>) {
+  answer = entries(buildMap(texts))
+}
+
+optionalId(value: Id) (answer: Text) { answer = dever.id.toText(value) }
+optionalId(value: null) (answer: Text) { answer = "missing" }
+
+duplicate(left: Text, right: Text) (answer: Map<Id, Int>) {
+  answer = { dever.id.fromText(left) = 1
+ dever.id.fromText(right) = 2 }
+}
+
+duplicateEntry() (answer: Map<Id, Int>) {
+  answer = duplicate("same", "same")
+}
+
+failureEntry() (answer: Id) {
+  answer = dever.id.fromText(dever.bytes.toText(dever.bytes.fromInts([255])))
+}
+
+verify() (answer: Bool) {
+  original = encode("雪🙂")
+  alias = original
+  original = encode("changed")
+  answer = decode(alias) == "雪🙂" and decode(original) == "changed"
+  answer = answer and encode("same") == encode("same") and encode("Same") != encode("same")
+  answer = answer and encode("é") != encode("é") and roundtrip("  雪\n\t") == "  雪\n\t"
+  answer = answer and optionalId(encode("")) == "" and optionalId(null) == "missing"
+  nul = dever.bytes.toText(dever.bytes.fromInts([97, 0, 98]))
+  answer = answer and roundtrip(nul) == nul
+  ids = encodeAll(["a", "a", "b"])
+  answer = answer and countEqual(ids, encode("a")) == 2 and countEqual([], encode("")) == 0
+  answer = answer and first(ids) == encode("a") and first(encodeAll([])) == null
+  state = Count { expected = alias
+    total = 2 }
+  changed = state
+  changed.expected = encode("new")
+  answer = answer and decode(state.expected) == "雪🙂" and decode(changed.expected) == "new"
+  values = buildMap(["雪", "a", "雪", "🙂"])
+  updated = put(values, encode("a"), 9)
+  removed = remove(updated, encode("雪"))
+  answer = answer and get(values, encode("a")) == 1 and get(updated, encode("a")) == 9
+  answer = answer and length(removed) == 2 and get(removed, encode("雪")) == null
+  answer = answer and lookup(values, encodeAll(["a", "missing", "雪"])) == 2
+  answer = answer and buildEntries(["a", "b", "a"]) == entries(buildMap(["a", "b"]))
+  answer = answer and values != buildMap(["a", "雪", "🙂"])
+}