Feat/adt rework

.github/workflows/ci.yml

@@ -264,29 +264,3 @@ jobs:
 
       - name: Run stdlib tests
         run: ./tin test stdlib/...
-
-      - name: Run shell test scripts
-        run: |
-          for f in \
-            examples/compiler_errors/test_errors.sh \
-            examples/const_fields_errors.sh \
-            examples/ctfe_stress_dispatch.sh \
-            examples/ctfe_stress_ir_checks.sh \
-            examples/escape_promotion.sh \
-            examples/incremental_cache_verify.sh \
-            examples/interop_errors.sh \
-            examples/maranget_exhaustive.sh \
-            examples/method_where_errors.sh \
-            examples/operator_errors.sh \
-            examples/operator_overload_phase0.sh \
-            examples/pattern_where_errors.sh \
-            examples/pure_fold_ir_checks.sh \
-            examples/pure_soundness_errors.sh \
-            examples/scoped_struct_tags_errors.sh \
-            examples/trait_coercion_errors.sh \
-            examples/unreachable_arm_warnings.sh \
-            examples/interop_closure_returns/run.sh \
-            examples/interop_stacktrace/run.sh; do
-            echo "=== $f ==="
-            bash "$f"
-          done

.gitignore

@@ -45,6 +45,9 @@ core.*
 vgcore.*
 massif.out.*
 
+# Working notes
+notes/
+
 # IDE / editor
 /utils/tin-intellij/.kotlin/
 .idea

README.md

@@ -18,14 +18,37 @@ fn fib(n u32) u32 =
 
 echo fib(10)
 
+// Result + `try`: parse, propagate, done.
+use errors
+use { Result } from result
+use strings
+
+fn parse_pair(s string) Result[(i64, i64), errors::Err] =
+  let parts = strings::split(s, ",")
+
+  if len(parts) != 2:
+    return Err(errors::new("need two comma-separated ints"))
+
+  let a = try strings::parse_int(parts[0])
+  let b = try strings::parse_int(parts[1])
+
+  return Ok((a, b))
+
+fn main() Result[Unit, errors::Err] =
+  let (x, y) = try parse_pair("12,30")
+
+  echo "{x} + {y} = {x + y}"
+
+  return Ok(())
+
 // Structs with methods
-struct person =
+struct Person =
   name string
   age  u8
 
-  fn show(this person) string = return "{this.name} is {this.age}"
+  fn show(this Person) string = return "{this.name} is {this.age}"
 
-let pete = person{name: "Pete", age: 20}
+let pete = Person{name: "Pete", age: 20}
 echo pete.show()
 
 // Fibers and channels
@@ -57,27 +80,30 @@ go build -o tin .
 ./tin run examples/hello.tin
 ```
 
-That's it. There are no install targets; treat the `tin` binary as
-relocatable and put it on your `PATH` if you want.
+That's the whole install: no install target, no package manager, no
+project file. The `tin` binary is relocatable; drop it on your `PATH` if
+you want.
 
 ### Common commands
 
 ```sh
 tin run    file.tin           # compile and execute
 tin build  file.tin -o out    # produce a native binary
 tin build  --lib file.tin     # produce a relocatable .o
-tin test   path/...           # run all `test` blocks under path/, recursive
+tin test   path/...           # run every `test` block under path/, recursive
 tin repl                      # interactive REPL (preload with `tin repl file.tin`)
 tin clean                     # wipe the .build/ cache
 ```
 
-`tin run` and `tin test` content-hash every input file (entry source,
-imported packages, `//!+` C sources) and skip lex/parse/codegen entirely
-when the cache directory's `sbom.txt` matches. Cache lives at
-`.build/<run|test>/<file>_<md5>/`.
+`tin run` and `tin test` content-hash every input (entry source,
+imported packages, `//!+` C sources) and skip the entire lex / parse /
+codegen pipeline when the cache directory's `sbom.txt` matches. The
+cache lives at `.build/<run|test>/<file>_<md5>/` -- delete it manually
+with `tin clean` or just `rm -rf .build/`.
 
-For tighter loops on the test suite: `tin test --fast path/...` drops to
-`-O0` so LLVM's optimizer doesn't dominate compile time.
+For tight inner loops on the test suite: `tin test --fast path/...`
+drops to `-O0` so LLVM's optimizer stops dominating the wall-clock
+compile time.
 
 ## Dependencies
 

ast/ast.go

@@ -68,6 +68,12 @@ type FuncDecl struct {
 	IsStatic       bool
 	IsExtern       string // non-empty = extern symbol name
 	IsVirtual      bool   // true for "fn f() T = virtual" in trait declarations
+
+	// RetTypeHasWildcard records whether RetType contained a WildcardType
+	// before generic substitution. Preserved through monomorphization so
+	// call sites can opt into wildcard-driven coercion ("call-site
+	// generics") for the return value.
+	RetTypeHasWildcard bool
 }
 
 // TypeConstraint bounds a type parameter with a boolean expression of trait
@@ -138,6 +144,7 @@ type StructDecl struct {
 	base
 	Name        string
 	TypeParams  []string
+	Wildcards   []string         // call-site-supplied wildcard slot names (e.g. `_: W` in `struct Foo[T, _: W]`)
 	Constraints []TypeConstraint // generic type constraints: where t is addable
 	Fields      []StructField
 	Methods     []*FuncDecl
@@ -201,12 +208,25 @@ type UnionDecl struct {
 // Each variant carries zero or more positional or named fields.
 // At least one variant must carry a payload (pure-nullary shapes should
 // use `enum` instead).
+//
+// ADTs may also implement traits, mirroring struct trait impls:
+//
+//	data Result[T, E](tryable[T, Result[T, E]]) =
+//	  Ok(v T)
+//	  Err(msg E)
+//
+//	  fn tryable[T, Result[T, E]]::is_err(this Result[T, E]) bool = ...
+//
+// Trait impls live in the Implements list; method bodies live in Methods.
 type DataDecl struct {
 	base
 	Name        string
 	TypeParams  []string
+	Wildcards   []string // call-site-supplied wildcard slot names (e.g. `_: W` in `data Foo[T, _: W]`)
 	Constraints []TypeConstraint
 	Variants    []DataVariant
+	Implements  []TypeExpr  // trait impls listed in parens, mirrors StructDecl.Implements
+	Methods     []*FuncDecl // method bodies for trait impls, mirrors StructDecl.Methods
 }
 
 type DataVariant struct {
@@ -525,6 +545,16 @@ type AsExpr struct {
 	Type TypeExpr
 }
 
+// TypeRefNode lifts a TypeExpr into expression position.  Used so the parser
+// can place a complex type (e.g. `fn(i64) i64`) inside an IndexExpr's Index
+// slot when the brackets are being used for type-arg instantiation rather
+// than runtime indexing.  Downstream resolvers (exprToTypeParamKey,
+// typeNodeToString, typeNodeToTypeExpr) unwrap the carried TypeExpr.
+type TypeRefNode struct {
+	base
+	Type TypeExpr
+}
+
 type SizeofExpr struct {
 	base
 	Type TypeExpr
@@ -876,6 +906,20 @@ type AwaitExpr struct {
 	Future Node
 }
 
+// TryExpr propagates a fallible-typed expression: `try foo()`.
+// Codegen desugars to:
+//
+//	let __t = expr
+//	if __t.tryable::is_err():
+//	  return __t.tryable::err_value()
+//	__t.tryable::ok_value()
+//
+// The enclosing fn must return a type compatible with err_value's return.
+type TryExpr struct {
+	base
+	Inner Node
+}
+
 // YieldStmt voluntarily yields the current fiber's time slice.
 type YieldStmt struct{ base }
 
@@ -1003,3 +1047,21 @@ type VoidType struct{}
 
 func (v *VoidType) typeExprMarker() {}
 func (v *VoidType) String() string  { return "void" }
+
+// WildcardType is the `_` placeholder permitted only in trait-bound
+// positions. It denotes an existentially-bound slot the impl picks.
+// Name is empty for anonymous `_`; non-empty for `_: T` where T is the
+// caller-supplied name used to refer to the slot inside the trait body
+// or impl methods.
+type WildcardType struct {
+	Name string // "" for anonymous `_`, otherwise the introduced name
+}
+
+func (w *WildcardType) typeExprMarker() {}
+func (w *WildcardType) String() string {
+	if w.Name == "" {
+		return "_"
+	}
+
+	return "_: " + w.Name
+}