c4ee6ec | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

c4ee6ec — Peter John 2026-09-02T21:21:38+05:30

test(libs/std): add Map test coverage; document two new compiler gaps found attempting Map.map

Files changed (1) hide show

libs/std/map.plum +80 -6

libs/std/map.plum CHANGED Viewed

@@ -138,9 +138,83 @@ type Map[K, V] =
           break
     return result
+  # `map` is left unimplemented — two DISTINCT compiler gaps were found
+  # while attempting it (2026-09-02), both real and both deeper than this
+  # one method:
+  #
+  # 1. A generic method's BODY is never substituted for its OWN extra
+  #    generics — `specializeFn` only substitutes PARAM/RETURN types,
+  #    cloning the body as-is. An explicit `Map[X, Y](items: List[Pair[X,
-  # `map` (which would need TWO new generic params, `X`/`Y`, both nested
+  #    Y]](...))` construction written directly in `map`'s body therefore
-  # inside a closure's return type `Pair[X, Y]` rather than directly bare —
-  # `resolveMethodOwnGenerics`/`methodOwnGenericParams` only handle a
+  #    keeps the LITERAL letters "X"/"Y" forever, which `resolveFieldType`
-  # closure-typed param whose return IS directly the bare extra-generic
+  #    then treats as if they were real concrete type names — silently
+  #    manufacturing bogus `List$X`/`Pair$X`-style "specializations" that
+  #    corrupt unrelated `List`/`Node` template compilation elsewhere in the
+  #    SAME program (confirmed: broke `List.add`/`sort`/`find`/etc, none of
+  #    which `map` even touches). Worked around by building the result via
+  #    `self.items.map(...)` (whose own extra-generic resolution IS
+  #    per-call-site, not body-substitution-dependent) plus a BARE `Map(items:
+  #    ...)` construction relying on `current_return_type`, matching
+  #    `keys`/`values` above — this part alone got further than before.
+  # 2. Once past that, `self.items.map(|p| cb(p.key, p.val))` still fails:
+  #    `plum-checker/src/lib.rs`'s `inferExpr` never propagates a method
+  #    CALL's own declared param types down as an "expected type" hint when
+  #    inferring a closure-literal ARGUMENT — it only guesses a closure
+  #    param's type from field-ACCESS patterns within the closure's own body
+  #    (`resolveClosureParamFromFieldUsage`), which can't know `p`'s class is
+  #    `Pair` at all here. Fixing this needs threading an expected `PlumType`
-  # letter, like `List.map`'s `cb: fn(T) -> U`) is left unimplemented; same
+  #    through `inferExpr`'s closure-literal handling at (at least) 8 call
+  #    sites in `lib.rs` — a materially bigger, riskier change than
+  #    warranted for this one method; not attempted.
+  fun map(self) =
+    todo
+fun makeStrIntMapForTest() -> Map[Str, Int] =
+  return Map[Str, Int](items: List[Pair[Str, Int]](head: None, tail: None, size: 0))
+test "get/set/has round-trip and set replaces an existing key in place"
+  m := makeStrIntMapForTest()
+  expect m.has("a") == False
+  m.set("a", 1)
+  expect m.has("a") == True
+  expect m.get("a").unwrap() == 1
+  expect m.length() == 1
+  m.set("a", 2)
+  expect m.get("a").unwrap() == 2
+  expect m.length() == 1
+test "putIfAbsent only sets a key that isn't already present"
+  m := makeStrIntMapForTest()
+  m.putIfAbsent("a", 1)
+  m.putIfAbsent("a", 2)
+  expect m.get("a").unwrap() == 1
+test "remove deletes an entry and clear empties the map"
+  m := makeStrIntMapForTest()
+  m.set("a", 1)
+  m.set("b", 2)
+  m.remove("a")
+  expect m.has("a") == False
+  expect m.length() == 1
+  m.clear()
+  expect m.isEmpty() == True
+test "keys/values list every entry's key/value in insertion order"
+  m := makeStrIntMapForTest()
+  m.set("a", 1)
+  m.set("b", 2)
+  expect m.keys().join(",") == "a,b"
+  expect m.values().join(",") == "1,2"
+test "each calls the callback with every key and value"
+  m := makeStrIntMapForTest()
+  m.set("a", 1)
+  m.set("b", 2)
+  # A closure captures its outer variables BY VALUE at creation time, so
-  # limitation noted on `Option`'s `andThen` in `libs/std/option.plum`.
+  # reassigning a captured `Int` inside the callback wouldn't be visible out
+  # here — mutate a captured `List` (a class, reference semantics) instead.
+  # `makeList(0)` (its arg infers `T = Int` for the empty list that follows).
+  seen := makeList(0)
+  seen.clear()
+  m.each(|k, v| seen.add(v))
+  expect seen.join(",") == "1,2"