0e1801a | plum

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

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

0e1801a — Peter John 2026-07-19T21:52:28+05:30

test: add example programs covering the language's current syntax

Files changed (9) hide show

examples/basics.plum +28 -0
examples/control_flow.plum +29 -0
examples/functions.plum +17 -0
examples/match.plum +45 -0
examples/methods.plum +26 -0
examples/strings.plum +11 -0
examples/types.plum +25 -0
plum-checker/tests/examples_test.rs +48 -0
plum-wasm-codegen/tests/examples_test.rs +85 -0

examples/basics.plum ADDED Viewed

@@ -0,0 +1,28 @@
+module basics
+import std/io
+MAX_RETRIES = 3
+PI = 3.14159
+GREETING = "hello"
+main() =
+  dec = 42
+  hex = 0xFF
+  bin = 0b1010
+  flt = 3.14
+  flt2 = 12.0f
+  name = "plum"
+  yes = True
+  no = False
+  sum = 1 + 2 * 3 - 4 / 2
+  bits = 0b1100 & 0b1010 | 0b0001
+  shifted = 1 << 4
+  cmp = sum > 0 && bits != 0 || False
+  grouped = {1 + 2} * {3 - 1}
+  picked = cmp ? sum : bits
+  negated = -sum
+  positive = +sum
+  inverted = !cmp
+  a, b = 1, 2

examples/control_flow.plum ADDED Viewed

@@ -0,0 +1,29 @@
+loopSum(limit: Int) -> Int =
+  total = 0
+  for i in 0..limit
+    if i == 3
+      continue
+    if i == 8
+      break
+    total = total + i
+  return total
+classify(n: Int) -> Str =
+  if n < 0
+    return "negative"
+  else if n == 0
+    return "zero"
+  else
+    return "positive"
+countdown(start: Int) -> Int =
+  i = start
+  while i > 0
+    i = i - 1
+  return i
+placeholder() =
+  todo
+checkPositive(n: Int) =
+  assert n > 0

examples/functions.plum ADDED Viewed

@@ -0,0 +1,17 @@
+addInts(a: Int, b: Int) -> Int =
+  a + b
+greet() =
+  todo
+withDefault(a: Int, step: Int = 1) -> Int =
+  a + step
+sumAll(nums: ...Int) -> Int =
+  todo
+wrap(value: a) -> Bool =
+  True
+pair(first: a, second: b) -> Bool =
+  True

examples/match.plum ADDED Viewed

@@ -0,0 +1,45 @@
+enum Color =
+  | Red
+  | Green
+  | Blue
+enum Option =
+  | Some(Int)
+  | None
+describeNumber(n: Int) -> Str =
+  match n
+    0 =>
+      "zero"
+    1 =>
+      "one"
+    _ =>
+      "many"
+describeBool(b: Bool) -> Int =
+  match b
+    True =>
+      1
+    False =>
+      0
+bindExample(n: Int) -> Int =
+  match n
+    x =>
+      x
+describeColor(c: Color) -> Str =
+  match c
+    Red =>
+      "red"
+    Green =>
+      "green"
+    Blue =>
+      "blue"
+describeOption(opt: Option) -> Int =
+  match opt
+    Some(v) =>
+      v
+    None =>
+      0

examples/methods.plum ADDED Viewed

@@ -0,0 +1,26 @@
+type Cat =
+  name: Str
+  age: Int
+getAge<Cat>() -> Int =
+  self.age
+birthday<Cat>() -> Int =
+  self.age + 1
+type Wrapper =
+  inner: Cat
+  tag: Int
+innerAge<Wrapper>() -> Int =
+  self.inner.age
+makeCat() -> Cat =
+  Cat(name: "Whiskers", age: 3)
+main() -> Int =
+  c = makeCat()
+  a = c.getAge()
+  b = c.birthday()
+  w = Wrapper(inner: c, tag: 1)
+  a + b + w.innerAge()

examples/strings.plum ADDED Viewed

@@ -0,0 +1,11 @@
+greet(name: Str) -> Str =
+  "Hello, {name}!"
+report(count: Int, total: Int) -> Str =
+  "{count} of {total} complete"
+empty() -> Str =
+  ""
+escaped() -> Str =
+  "line one\nline two\ttabbed \"quoted\""

examples/types.plum ADDED Viewed

@@ -0,0 +1,25 @@
+type Point =
+  x: Int
+  y: Int
+type Named(Stringable) =
+  name: Str
+type Box(a) =
+  value: a
+trait Shape =
+  area() -> Float
+  perimeter() -> Float
+trait Comparable(a: Ord) =
+  compareTo(other: a) -> Int
+enum Color =
+  | Red
+  | Green
+  | Blue
+enum Option =
+  | Some(Int)
+  | None

plum-checker/tests/examples_test.rs ADDED Viewed

@@ -0,0 +1,48 @@
+use plum_checker::check_source;
+use plum_core::AstParser;
+fn examples_dir() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples")
+}
+fn example_files() -> Vec<std::path::PathBuf> {
+    let mut files: Vec<_> = std::fs::read_dir(examples_dir())
+        .expect("examples/ directory should exist")
+        .filter_map(|e| e.ok())
+        .map(|e| e.path())
+        .filter(|p| p.extension().and_then(|e| e.to_str()) == Some("plum"))
+        .collect();
+    files.sort();
+    assert!(!files.is_empty(), "examples/ should contain at least one .plum file");
+    files
+}
+/// Every example must parse with zero ERROR/MISSING nodes and pass `check_source`.
+/// These files exist specifically to prove each piece of the currently-supported
+/// grammar surface actually works end to end, not just in isolated unit tests.
+#[test]
+fn every_example_parses_and_type_checks() {
+    let mut parser = tree_sitter::Parser::new();
+    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
+    for path in example_files() {
+        let src = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("failed to read {}: {}", path.display(), e));
+        let tree = parser.parse(&src, None).unwrap_or_else(|| panic!("failed to parse {}", path.display()));
+        assert!(
+            !tree.root_node().has_error(),
+            "{} has a parse error:\n{}",
+            path.display(),
+            tree.root_node().to_sexp()
+        );
+        let ap = AstParser::new(&src);
+        let source = ap.parse_source(tree.root_node());
+        let result = check_source(&source);
+        assert!(
+            result.is_ok(),
+            "{} failed type checking: {:?}",
+            path.display(),
+            result.err().map(|errs| errs.into_iter().map(|e| e.message).collect::<Vec<_>>())
+        );
+    }
+}

plum-wasm-codegen/tests/examples_test.rs ADDED Viewed

@@ -0,0 +1,85 @@
+use plum_wasm_codegen::compile_source;
+use plum_core::AstParser;
+fn examples_dir() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples")
+}
+fn parse_file(name: &str) -> plum_core::ast::Source {
+    let path = examples_dir().join(name);
+    let src = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("failed to read {}: {}", path.display(), e));
+    let mut parser = tree_sitter::Parser::new();
+    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
+    let tree = parser.parse(&src, None).unwrap_or_else(|| panic!("failed to parse {}", path.display()));
+    assert!(!tree.root_node().has_error(), "{} has a parse error", path.display());
+    let ap = AstParser::new(&src);
+    ap.parse_source(tree.root_node())
+}
+fn assert_compiles(name: &str) -> Vec<u8> {
+    let source = parse_file(name);
+    let bytes = compile_source(&source).unwrap_or_else(|e| panic!("{} failed to compile: {}", name, e));
+    let result = wasmparser::validate(&bytes);
+    assert!(result.is_ok(), "{} produced invalid wasm: {:?}", name, result.err());
+    bytes
+}
+/// Examples that stick to currently-supported codegen features (primitives, control
+/// flow, classes/methods) must actually compile to valid wasm — not just parse and
+/// type-check.
+#[test]
+fn basics_compiles() {
+    assert_compiles("basics.plum");
+}
+#[test]
+fn control_flow_compiles() {
+    assert_compiles("control_flow.plum");
+}
+#[test]
+fn functions_compiles() {
+    assert_compiles("functions.plum");
+}
+#[test]
+fn types_compiles() {
+    // Only class/trait/enum declarations, no function bodies to lower — should still
+    // produce a valid (if unexciting) module.
+    assert_compiles("types.plum");
+}
+#[test]
+fn methods_compiles_and_runs_correctly() {
+    let bytes = assert_compiles("methods.plum");
+    let engine = wasmtime::Engine::default();
+    let module = wasmtime::Module::new(&engine, &bytes).expect("module should be loadable");
+    let mut store = wasmtime::Store::new(&engine, ());
+    let instance = wasmtime::Instance::new(&mut store, &module, &[]).expect("module should instantiate");
+    let main = instance
+        .get_typed_func::<(), i64>(&mut store, "main")
+        .expect("main should have signature () -> i64");
+    let result = main.call(&mut store, ()).expect("main should not trap");
+    // makeCat() -> Cat(age: 3); a = getAge() = 3; b = birthday() = 4;
+    // w.innerAge() = inner.age = 3 => 3 + 4 + 3 = 10
+    assert_eq!(result, 10);
+}
+/// match.plum and strings.plum intentionally exercise syntax beyond what codegen
+/// currently lowers (non-Bool enum-tag/constructor match patterns, string
+/// interpolation) — they must fail loudly with a clear message, not silently
+/// produce wrong wasm.
+#[test]
+fn match_example_reports_clear_unsupported_pattern_errors() {
+    let source = parse_file("match.plum");
+    let err = compile_source(&source).expect_err("non-Bool enum-tag patterns are not yet supported");
+    assert!(err.contains("enum variant pattern"), "got: {}", err);
+}
+#[test]
+fn strings_example_reports_clear_interpolation_error() {
+    let source = parse_file("strings.plum");
+    let err = compile_source(&source).expect_err("string interpolation is not yet supported");
+    assert!(err.contains("interpolation"), "got: {}", err);
+}