bf629a2 | plum | pyrossh

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

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

bf629a2 — Peter John 2026-09-03T19:47:08+05:30

feat(plum): trait conformance checking, Stringable->ToStr, finish str.plum

Files changed (24) hide show

Cargo.lock +487 -12
README.md +5 -2
examples/types.plum +1 -1
libs/std/buffer.plum +1 -1
libs/std/http.plum +156 -22
libs/std/list.plum +2 -2
libs/std/map.plum +3 -3
libs/std/option.plum +1 -1
libs/std/result.plum +1 -1
libs/std/str.plum +96 -7
libs/std/time.plum +1 -1
libs/std/uuid.plum +1 -1
plum-checker/src/lib.rs +114 -2
plum-checker/src/monomorphize.rs +19 -3
plum-checker/tests/checker_tests.rs +126 -0
plum-cli/Cargo.toml +1 -0
plum-cli/src/main.rs +48 -0
plum-runtime/Cargo.lock +489 -8
plum-runtime/Cargo.toml +1 -0
plum-runtime/src/main.rs +43 -0
test/sample.plum +1 -1
tooling/tree-sitter-plum/test/corpus/type.txt +1 -1
website/src/content/docs/declarations/enum.md +1 -1
website/src/content/docs/index.mdx +2 -2

Cargo.lock CHANGED Viewed

@@ -89,7 +89,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -100,7 +100,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -135,7 +135,7 @@ dependencies = [
  "addr2line 0.25.1",
  "cfg-if",
  "libc",
- "miniz_oxide",
+ "miniz_oxide 0.8.9",
  "object 0.37.3",
  "rustc-demangle",
  "windows-link",
@@ -507,6 +507,17 @@ dependencies = [
  "winapi",
 ]
+[[package]]
+name = "displaydoc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.0",
+]
 [[package]]
 name = "either"
 version = "1.16.0"
@@ -547,7 +558,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -568,6 +579,17 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+[[package]]
+name = "flate2"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide 0.9.1",
+ "zlib-rs",
+]
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -580,6 +602,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
 [[package]]
 name = "futures"
 version = "0.3.33"
@@ -765,12 +796,116 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+[[package]]
+name = "icu_collections"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+[[package]]
+name = "icu_locale_core"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+[[package]]
+name = "icu_normalizer"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+[[package]]
+name = "icu_normalizer_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
+[[package]]
+name = "icu_properties"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+[[package]]
+name = "icu_properties_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"
+[[package]]
+name = "icu_provider"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
 [[package]]
 name = "id-arena"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+[[package]]
+name = "idna_adapter"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
 [[package]]
 name = "indexmap"
 version = "2.14.0"
@@ -898,6 +1033,12 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+[[package]]
+name = "litemap"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
 [[package]]
 name = "log"
 version = "0.4.33"
@@ -964,6 +1105,16 @@ dependencies = [
  "adler2",
 ]
+[[package]]
+name = "miniz_oxide"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
 [[package]]
 name = "object"
 version = "0.37.3"
@@ -1003,6 +1154,12 @@ version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d211803b9b6b570f68772237e415a029d5a50c65d382910b879fb19d3271f94d"
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 [[package]]
 name = "petgraph"
 version = "0.6.5"
@@ -1046,6 +1203,7 @@ dependencies = [
  "toml_edit",
  "tree-sitter",
  "tree-sitter-plum",
+ "ureq",
  "wasmtime",
 ]
@@ -1085,6 +1243,15 @@ dependencies = [
  "serde",
 ]
+[[package]]
+name = "potential_utf"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661"
+dependencies = [
+ "zerovec",
+]
 [[package]]
 name = "pretty_assertions"
 version = "1.4.1"
@@ -1226,6 +1393,20 @@ version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
 [[package]]
 name = "rustc-demangle"
 version = "0.1.28"
@@ -1248,7 +1429,42 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.61.2",
+]
+[[package]]
+name = "rustls"
+version = "0.23.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06"
+dependencies = [
+ "log",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+[[package]]
+name = "rustls-pki-types"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
+dependencies = [
+ "zeroize",
+]
+[[package]]
+name = "rustls-webpki"
+version = "0.103.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
 ]
 [[package]]
@@ -1337,6 +1553,12 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+[[package]]
+name = "simd-adler32"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -1370,6 +1592,12 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 [[package]]
 name = "supports-color"
 version = "3.0.2"
@@ -1413,6 +1641,17 @@ dependencies = [
  "unicode-ident",
 ]
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
 [[package]]
 name = "target-lexicon"
 version = "0.13.5"
@@ -1429,7 +1668,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -1448,7 +1687,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
 dependencies = [
  "rustix",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -1501,6 +1740,16 @@ dependencies = [
  "syn 3.0.0",
 ]
+[[package]]
+name = "tinystr"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
 [[package]]
 name = "tokio"
 version = "1.53.0"
@@ -1694,6 +1943,46 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+[[package]]
+name = "ureq"
+version = "2.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
+dependencies = [
+ "base64",
+ "flate2",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-pki-types",
+ "url",
+ "webpki-roots 0.26.11",
+]
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -1938,7 +2227,7 @@ dependencies = [
  "wasmtime-internal-unwinder",
  "wasmtime-internal-versioned-export-macros",
  "wat",
- "windows-sys",
+ "windows-sys 0.61.2",
  "wit-parser",
 ]
@@ -1989,7 +2278,7 @@ dependencies = [
  "sha2",
  "toml",
  "wasmtime-environ",
- "windows-sys",
+ "windows-sys 0.61.2",
  "zstd",
 ]
@@ -2065,7 +2354,7 @@ dependencies = [
  "rustix",
  "wasmtime-environ",
  "wasmtime-internal-versioned-export-macros",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -2089,7 +2378,7 @@ dependencies = [
  "cfg-if",
  "libc",
  "wasmtime-internal-core",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -2161,6 +2450,24 @@ dependencies = [
  "wasm-bindgen",
 ]
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.9",
+]
+[[package]]
+name = "webpki-roots"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
+dependencies = [
+ "rustls-pki-types",
+]
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -2183,7 +2490,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -2198,6 +2505,15 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -2207,6 +2523,70 @@ dependencies = [
  "windows-link",
 ]
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 [[package]]
 name = "winnow"
 version = "0.7.15"
@@ -2241,12 +2621,41 @@ dependencies = [
  "wasmparser 0.252.0",
 ]
+[[package]]
+name = "writeable"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 [[package]]
 name = "yansi"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+[[package]]
+name = "yoke"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "synstructure",
+]
 [[package]]
 name = "zerocopy"
 version = "0.8.54"
@@ -2267,6 +2676,72 @@ dependencies = [
  "syn 2.0.119",
 ]
+[[package]]
+name = "zerofrom"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+dependencies = [
+ "zerofrom-derive",
+]
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "synstructure",
+]
+[[package]]
+name = "zeroize"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+[[package]]
+name = "zerotrie"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+[[package]]
+name = "zerovec"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+[[package]]
+name = "zerovec-derive"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.0",
+]
+[[package]]
+name = "zlib-rs"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12"
 [[package]]
 name = "zmij"
 version = "1.0.23"

README.md CHANGED Viewed

@@ -234,7 +234,7 @@ type Point =
   x: Int
   y: Int
-type Named(Stringable) =    # implements Stringable
+type Named(ToStr) =    # implements ToStr
   name: Str
 trait Shape =
@@ -253,6 +253,8 @@ enum Option =
 Full example: [`examples/types.plum`](examples/types.plum).
+`type X(TraitName, ...) = ...`'s trait claims are checked: `plum-checker` verifies `X` actually defines every method `TraitName` declares, with a matching param count/types and return type (a return/param type the trait itself can't parameterize, like `Err`'s `cause() -> Option`, matches any concrete instantiation an implementer declares, e.g. `Option[MyError]`). A trait name that isn't actually declared anywhere (`Comparable`/`Readable`/`Writable` are used this way in a few places in `libs/std` today) is silently unenforced rather than an error, since there's nothing real yet to check it against.
 ### Generics
 Generic type parameters are single letters only: `a`, `b`, `c`, `d`.
@@ -389,7 +391,8 @@ hello, world!
 Some things parse and type-check but don't compile to wasm yet — `plum-wasm-codegen` reports a clear error rather than silently producing wrong code:
 - interpolating a `Float` value in a string (`Str`/`Int`/`Bool` interpolation, and plain non-interpolated literals, all compile) — correct decimal formatting of a float is a substantial separate undertaking (something like Grisu/Ryu), scoped out for now
-- The generic-field-type gap that used to block `libs/std`'s real `List[T]`/`Node[T]` from compiling at all (a class/enum-variant field declared with a concrete instantiation of another generic type, e.g. `Node.next: Option[Node]`) is fixed — `List[T]`'s methods (`get`/`length`/`add`/`set`/`removeAt`/`remove`/`clear`/`reverse`/`each`/`map`/`reduce`/`sort`/`join`, including its `Stringable`-bounded dispatch) are exercised directly, at their real generic type, by the `test` blocks at the bottom of [`libs/std/list.plum`](libs/std/list.plum) itself (run via `plum test libs/std/list.plum`) — not a non-generic stand-in.
+- The generic-field-type gap that used to block `libs/std`'s real `List[T]`/`Node[T]` from compiling at all (a class/enum-variant field declared with a concrete instantiation of another generic type, e.g. `Node.next: Option[Node]`) is fixed — `List[T]`'s methods (`get`/`length`/`add`/`set`/`removeAt`/`remove`/`clear`/`reverse`/`each`/`map`/`reduce`/`sort`/`join`, including its `ToStr`-bounded dispatch) are exercised directly, at their real generic type, by the `test` blocks at the bottom of [`libs/std/list.plum`](libs/std/list.plum) itself (run via `plum test libs/std/list.plum`) — not a non-generic stand-in.
 - `Map[K, V]` previously hit a *different* bug here: a top-level function whose own declared return type was a fully-concrete generic instantiation (e.g. `fun makeMap() -> Map[Str, Int] = ...`) caused monomorphization to eagerly (and incorrectly) attempt to specialize an unrelated generic type's method (`Option.filter`) at an unresolved type variable, producing a spurious `expected Option, found Option$V` type error even though `filter` was never called anywhere in the program. Root cause: `maybeRewriteReturn` (in `plum-checker/src/monomorphize.rs`) treated ANY return type merely NAMING a known generic class/enum as still-unresolved and in need of rewriting from the body's inferred tail type — even when that name already carried concrete type args (`List[Str]`, `Map[Str, Int]`), clobbering an already-correct declared return type with a stale, unmangled one inferred through tables monomorphization hadn't finished refreshing yet. Fixed by only treating a BARE reference (no `[...]` at all, e.g. `-> Box`) as needing that rewrite; a companion fix pre-resolves every ordinary (non-generic) fn/method's signature into the type tables before any body rewriting begins, so cross-file call order no longer matters. `Option.andThen`/`Result.map`/`Result.mapErr` (a single extra generic, possibly nested inside a closure's return type) are now implemented and working. `Map.map` (needing TWO new generic params nested inside a closure's return type, on a class rather than an enum) is now implemented too, once `specializeFn` was fixed to also substitute a method's own extra generics inside its BODY (not just its params/return) — an explicit bracketed construction like `Map[X, Y](items: ...)` written directly in a method's own body previously kept the literal letters "X"/"Y" forever, silently minting bogus specializations that corrupted unrelated template compilation elsewhere in the program. A second, narrower gap remains: a closure-literal argument whose body does field access on its own param (`|p| cb(p.key, p.val)`) still can't type-check once more than one specialization of the same generic class shares that field name (e.g. both `Pair$Str$Int` and `Pair$Str$Str` declare `key`/`val`) — the checker's field-usage heuristic for inferring a closure param's class becomes ambiguous and gives up; `Map.map`'s own body sidesteps this by using a manual linked-list walk (matching `keys`/`values`/`each`'s existing style) instead of `List.map` with a field-accessing closure
 - A generic class/enum method whose return type nests that SAME class/enum inside itself (`List[T].chunk(self) -> List[List[T]]`) used to stack-overflow the compiler for every program merely importing the class, whether or not anything called the method — fixed; `List.chunk`/`List.partition` now ship and work as a working example of the pattern (build any inner `List[T]` value via an EXISTING ordinary method, e.g. `self.sublist(...)`, never a second bare `List(...)` construction in the same body, which is ambiguous with the method's own return-type fallback)
 - A ternary as a closure's own inline body (`|n| cond ? a : b`) used to parse as an OUTER ternary wrapping the whole closure instead (`(|n| cond) ? a : b`) — a grammar shift/reduce ambiguity where `closure`'s default precedence (0) beat `ternary_expression`'s deliberately-low `PREC.conditional` (-1) at the point the parser decides whether to keep extending the closure's body or reduce it as already-complete. Fixed by giving `closure` its own even-lower precedence (`PREC.closure = -2`, `tooling/tree-sitter-plum/grammar.js`) so the parser now always prefers letting a ternary (or anything else valid there) keep extending the closure's inline body — see `examples/closures.plum`'s `"closure with an inline ternary body runs correctly"` test.
+- `libs/std/str.plum` is otherwise complete (including `endsWith`/`pad`/`truncate`, filled in alongside the `ToStr`-conformance work below), but three methods remain deliberately unimplemented `todo` stubs (they compile fine and trap at runtime if actually called, rather than failing to compile — a different flavor of gap than the rest of this section): `test`/`matchPattern`/`matchAll`/`replace`/`replaceAll`/`search` all need a real `Regex` type/engine, which doesn't exist anywhere in `libs/std` yet; `deburr` (diacritic stripping, `é` -> `e`) needs a full Unicode decomposition table; `template` (lodash's `_.template`) needs the ability to compile and run Plum source from a `Str` value at runtime — there's no `eval`/dynamic-codegen capability in the language to build it on.

examples/types.plum CHANGED Viewed

@@ -2,7 +2,7 @@ type Point =
   x: Int
   y: Int
-type Named(Stringable) =
+type Named(ToStr) =
   name: Str
 type Box[T] =

libs/std/buffer.plum CHANGED Viewed

@@ -12,7 +12,7 @@ import std/str
 # `bytes.Buffer`'s asymptotic behavior — unlike the previous `Str`-backed
 # version of this type, which recopied everything written so far on every
 # write.
-type Buffer(Stringable) =
+type Buffer(ToStr) =
   data: []Byte
   len: Int

libs/std/http.plum CHANGED Viewed

@@ -1,28 +1,162 @@
 module std
+import std/buffer
+import std/json
+import std/list
-import std/path
+import std/map
+import std/option
+import std/result
-import std/os
+import std/str
-import std/http/content_type
+# An HTTP response: status code, response headers, and the raw response
+# body as a `Str` (a byte array, so binary bodies round-trip intact).
 type Response =
-  headers: Map(Str, Str)
-  body: Buffer
   status: Int
+  headers: Map[Str, Str]
+  body: Str
+  # 2xx status codes are success; everything else (redirects, 4xx, 5xx) is
+  # surfaced here rather than as an `Err` from `request` — a non-2xx
-# builds a Response by reading the file at `file_path` and inferring its content type.
+  # response is still a complete, well-formed HTTP exchange, not a failed
-# NOTE: the original used a `Response::create()` fluent builder chain
-# (`.header(...).contentType(...).body(...).status(...)`), but this language has
-# no "::" static-call syntax and no mutating "with"-style builder methods, so
-# this constructs the Response directly instead.
-fun createFileResponse(file_path: Str) -> Response =
+  # one (`request` itself only fails for transport-level problems like a
-  content := content_type.fromExt(file_path.ext())
-  data := os.readFile(file_path)
+  # DNS/connection error).
-  Response(headers: Map(), body: data, status: 200)
-fun index() -> Response =
+  fun ok(self) -> Bool =
+    self.status >= 200 && self.status < 300
+  # Parses `body` as JSON. Fails the same way `Json.fromStr` does for a
+  # response body that isn't valid JSON.
+  fun json(self) -> Result[Json, JsonParseError] =
+    return Json.fromStr(self.body)
+fun emptyHeaders() -> Map[Str, Str] =
+  return Map[Str, Str](items: List[Pair[Str, Str]](head: None, tail: None, size: 0))
+# A single blocking network round trip — this VM has no async/event-loop
+# mechanism, so `rawHttpRequest` runs to completion before returning (same
+# idea as `libs/std/os.plum`'s `rawReadFile`). `headers` is `"Key: Value"`
+# lines joined by `\n` (`""` for none). The result packs an outcome flag,
+# then either the status code and response headers (success) or an error
+# message (failure), as fields joined by `\x01`, up to the first `\x00` —
+# everything after that byte is the raw response body. `\x00`/`\x01` can
+# never occur in the metadata fields themselves (the flag/status are
+# decimal digits, header names/values and the error message are always
+# plain text), so they safely mark where the opaque body bytes start even
+# when the body itself is arbitrary binary data.
+extern fun rawHttpRequest(method: Str, url: Str, headers: Str, body: Str) -> Str
+# Packs `headers` into the `"Key: Value"`-per-line format `rawHttpRequest`
+# expects for its own `headers` argument.
+fun encodeHeaders(headers: Map[Str, Str]) -> Str =
+  buf := Buffer()
+  headers.each(|k, v|
+    if buf.length() > 0
-  createFileResponse("index.html")
+      buf.write("\n")
+    buf.write(k)
+    buf.write(": ")
+    buf.write(v))
+  return buf.toStr()
+# The reverse of `encodeHeaders`, for the response headers `rawHttpRequest`
+# packs into its result.
-fun serveFile(file_path: Str) -> Response =
+fun decodeHeaders(raw: Str) -> Map[Str, Str] =
+  result := emptyHeaders()
+  if raw == ""
+    return result
+  raw.split("\n", 0).each(|line|
+    idx := line.indexOf(": ")
+    if idx >= 0
+      key := line.sub(0, idx)
+      val := line.sub(idx + 2, line.length())
+      result.set(key, val))
+  return result
+# Performs a single HTTP request and waits for the full response. Fails
+# only for a transport-level problem (DNS failure, connection refused, TLS
+# error, ...) — an HTTP-level error status (404, 500, ...) is still a
+# successful round trip, returned as `Ok(Response(...))` with that status
+# (check `Response.ok()`).
+fun request(method: Str, url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+  raw := rawHttpRequest(method, url, encodeHeaders(headers), body)
+  sep := raw.indexOf("\x00")
+  meta := sep >= 0 ? raw.sub(0, sep) : raw
+  resp_body := sep >= 0 ? raw.sub(sep + 1, raw.length()) : ""
+  parts := meta.split("\x01", 3)
+  flag := parts.get(0).unwrapOr("")
+  if flag != "1"
+    return Err(parts.get(2).unwrapOr("http request failed"))
+  match Int.fromStr(parts.get(1).unwrapOr(""))
+    Ok(status) =>
+      return Ok(Response(status: status, headers: decodeHeaders(parts.get(2).unwrapOr("")), body: resp_body))
+    Err(e) =>
+      return Err("invalid status code in http response: {e}")
+fun get(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =
+  return request("GET", url, headers, "")
+fun head(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =
+  return request("HEAD", url, headers, "")
+fun delete(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =
+  return request("DELETE", url, headers, "")
+fun post(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+  return request("POST", url, headers, body)
+fun put(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+  return request("PUT", url, headers, body)
+fun patch(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =
+  return request("PATCH", url, headers, body)
+# Convenience wrapper: sends `body` as a JSON `Str`, adding a
+# `Content-Type: application/json` header, and parses the response back as
+# JSON via `Response.json()`.
+fun postJson(url: Str, headers: Map[Str, Str], body: Json) -> Result[Response, Str] =
+  headers.set("Content-Type", "application/json")
+  return post(url, headers, body.toStr())
+test "encodeHeaders/decodeHeaders round-trip a header map"
+  h := emptyHeaders()
+  h.set("Content-Type", "application/json")
+  h.set("Accept", "*/*")
-  content := content_type.fromExt(file_path.ext())
+  decoded := decodeHeaders(encodeHeaders(h))
+  expect decoded.get("Content-Type").unwrap() == "application/json"
+  expect decoded.get("Accept").unwrap() == "*/*"
-  data := os.readFile(file_path)
+test "decodeHeaders returns an empty map for an empty string"
-  Response(headers: Map(), body: data, status: 200)
+  expect decodeHeaders("").isEmpty() == True
+test "get performs a real HTTP round trip"
+  match get("https://httpbin.org/get", emptyHeaders())
+    Ok(resp) =>
+      expect resp.ok() == True
+      expect resp.status == 200
+    Err(_) =>
+      expect True == False
+test "get reports a non-2xx status without failing the request"
+  match get("https://httpbin.org/status/404", emptyHeaders())
+    Ok(resp) =>
+      expect resp.ok() == False
+      expect resp.status == 404
+    Err(_) =>
+      expect True == False
+test "post sends a body and the server echoes it back"
+  match post("https://httpbin.org/post", emptyHeaders(), "hello world")
+    Ok(resp) =>
+      expect resp.ok() == True
+      match resp.json()
+        Ok(j) =>
+          expect j.asMap().unwrap().get("data").unwrap().asStr().unwrap() == "hello world"
+        Err(_) =>
+          expect True == False
+    Err(_) =>
+      expect True == False
+test "request fails for an unreachable host"
+  match get("http://this-host-does-not-exist.invalid/", emptyHeaders())
+    Ok(_) =>
+      expect True == False
+    Err(_) =>
+      expect True == True

libs/std/list.plum CHANGED Viewed

@@ -12,7 +12,7 @@ type Node[T] =
 # A list is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
 # It contains the pointers to the start and end nodes (head, tail) and maintains the size as well
-type List[T: Stringable](Stringable) =
+type List[T: ToStr](ToStr) =
   head: Option[Node[T]]
   tail: Option[Node[T]]
   size: Int
@@ -460,7 +460,7 @@ type List[T: Stringable](Stringable) =
           break
     res.toStr()
-  # `List[T: Stringable](Stringable)` declared implementing `Stringable`
+  # `List[T: ToStr](ToStr)` declared implementing `ToStr`
   # from the start but never actually defined `toStr` — harmless for a
   # PLAIN `List[Int]`/`List[Str]`/etc (nothing needs to call `.toStr()` on
   # the LIST ITSELF, just on its elements, which `join` above already

libs/std/map.plum CHANGED Viewed

@@ -7,11 +7,11 @@ import std/option
 # `toStr` (unlike `Option`'s — see `libs/std/option.plum`'s note on
 # `toOptionStr`) IS safe as an ordinary method here: `Pair[K, V]` is only
 # ever used as `List[Pair[K, V]]`'s element type inside `Map[K, V]`, and
-# `List[T: Stringable]` already requires its own `T` to support `toStr` —
+# `List[T: ToStr]` already requires its own `T` to support `toStr` —
-# so a `Pair` used as a `List` element always has `K`/`V: Stringable` too,
+# so a `Pair` used as a `List` element always has `K`/`V: ToStr` too,
 # and `List`'s own eagerly-compiled `join`/`toStr` (which call `.toStr()` on
 # every element) need this to exist for every `Map` specialization anyway.
-type Pair[K, V](Stringable) =
+type Pair[K, V](ToStr) =
   key: K
   val: V

libs/std/option.plum CHANGED Viewed

@@ -112,7 +112,7 @@ enum Option =
   # `toStr` — so an `Option.toStr` calling `.toStr()` on the wrapped value
   # would fail to compile for THAT specialization even though nothing ever
   # actually calls `.toStr()` on an `Option[Node[Int]]`. Use `toOptionStr`
-  # below (an explicit stringifier callback, not an implicit `T: Stringable`
+  # below (an explicit stringifier callback, not an implicit `T: ToStr`
   # bound) wherever printing an `Option` is needed.
   fun toOptionStr(self, valueToStr: fn(T) -> Str) -> Str =
     match self

libs/std/result.plum CHANGED Viewed

@@ -116,7 +116,7 @@ enum Result =
   # No implicit `toStr(self) -> Str` — see the identical note on
   # `Option.toOptionStr` in `libs/std/option.plum`: a method that assumes
-  # `T`/`E: Stringable` gets compiled for EVERY specialization of `Result`
+  # `T`/`E: ToStr` gets compiled for EVERY specialization of `Result`
   # anywhere in the program (there's no lazy/on-demand method compilation),
   # so an implicit bound like this can break an unrelated specialization
   # whose payload doesn't support it. Explicit stringifier callbacks instead.

libs/std/str.plum CHANGED Viewed

@@ -3,13 +3,13 @@ module std
 import std/list
 # Any type that can be converted to a str needs to implement this trait
-trait Stringable =
+trait ToStr =
   toStr() -> Str
 # A Str is an array of contiguous data stored in memory with a null termination using hex 0x00 or ASCII 0x00.
 # It is immutable and cannot be modified. It is copied for any changes and saved to a new memory location.
 # The previous str is freed if its reference count is 0 within the block.
-type Str(Comparable, Stringable, Readable, Writable) =
+type Str(Comparable, ToStr, Readable, Writable) =
   data: Buffer
   # Number of bytes in the string. Every other method below is built on top of
@@ -104,6 +104,9 @@ type Str(Comparable, Stringable, Readable, Writable) =
   fun startsWith(self, search: Str) -> Bool =
     matchesAt(self, search, 0, search.length())
+  fun endsWith(self, search: Str) -> Bool =
+    matchesAt(self, search, self.length() - search.length(), search.length())
   fun concat(self, other: Str) -> Str =
     self + other
@@ -247,9 +250,28 @@ type Str(Comparable, Stringable, Readable, Writable) =
   fun escapeRegExp(self) -> Str =
     escapeRegExpFrom(self, 0, self.length())
+  # Pads BOTH sides of `self` with repeated copies of `sub` until its length
+  # is at least `count`, split as evenly as possible between the two sides
+  # (the left side gets any odd byte of the remainder, matching lodash's
+  # `_.pad`). Inherits `padStart`/`padEnd`'s own overshoot behavior when
+  # `sub` doesn't evenly divide the needed amount on either side.
-  fun pad(self) -> Str =
+  fun pad(self, sub: Str, count: Int) -> Str =
+    len := self.length()
+    if len >= count || sub.length() == 0
+      return self
+    total := count - len
+    left := total / 2
+    right := total - left
+    return self.padStart(sub, len + left).padEnd(sub, len + left + right)
+  # `template` (lodash's `_.template`) compiles a string containing
+  # `<%= expr %>`-style placeholders into a REUSABLE function that renders it
+  # against different data each call — that needs the ability to compile and
+  # run Plum source AT RUNTIME (from a `Str` value, not a `.plum` file), which
+  # the language has no way to do (no `eval`, no dynamic codegen from within
+  # a running program). Left as a known gap rather than a fundamentally
+  # different, simpler feature (e.g. a one-shot find/replace) under the same
-    todo
+  # name.
   fun template(self) -> Str =
     todo
@@ -262,8 +284,17 @@ type Str(Comparable, Stringable, Readable, Writable) =
   fun trimStart(self) -> Str =
     trimStartFrom(self, 0, self.length())
+  # Truncates `self` to at most `length` bytes (INCLUDING the "..." suffix,
+  # lodash's default `omission` string) if it's longer than `length`; returns
+  # `self` unchanged otherwise. `length` too small to fit the full "..."
+  # itself just returns as many of its leading bytes as fit.
-  fun truncate(self) -> Str =
+  fun truncate(self, length: Int) -> Str =
+    if self.length() <= length
-    todo
+      return self
+    omission := "..."
+    if length <= omission.length()
+      return omission.sub(0, length)
+    return self.sub(0, length - omission.length()) + omission
   fun unescape(self) -> Str =
     unescapeFrom(self, 0, self.length())
@@ -526,3 +557,61 @@ test "string interpolation supports a method call taking a closure literal"
 test "string interpolation supports a ternary expression"
   n := 5
   expect "{n > 0 ? "positive" : "non-positive"}" == "positive"
+# ---- Str method regression tests ----
+test "endsWith matches a real suffix and rejects a non-suffix or an over-long search"
+  expect "hello.plum".endsWith(".plum") == True
+  expect "hello.plum".endsWith(".rs") == False
+  expect "hi".endsWith("hello") == False
+test "startsWith/endsWith/contains/indexOf agree on a shared example"
+  s := "the quick brown fox"
+  expect s.startsWith("the") == True
+  expect s.endsWith("fox") == True
+  expect s.contains("quick") == True
+  expect s.indexOf("brown") == 10
+  expect s.indexOf("missing") == -1
+test "trim/trimStart/trimEnd strip only leading/trailing whitespace"
+  expect "  hi  ".trim() == "hi"
+  expect "  hi  ".trimStart() == "hi  "
+  expect "  hi  ".trimEnd() == "  hi"
+  expect "hi".trim() == "hi"
+test "repeat concatenates self count times, and is empty for count <= 0"
+  expect "ab".repeat(3) == "ababab"
+  expect "ab".repeat(0) == ""
+  expect "ab".repeat(-1) == ""
+test "padStart/padEnd/pad grow a string to at least the target length"
+  expect "5".padStart("0", 3) == "005"
+  expect "5".padEnd("0", 3) == "500"
+  expect "hi".pad("-", 6) == "--hi--"
+  expect "hi".pad("-", 5) == "-hi--"
+  expect "hello".pad("-", 3) == "hello"
+test "truncate shortens a too-long string with a trailing ellipsis"
+  expect "hello world".truncate(8) == "hello..."
+  expect "hi".truncate(8) == "hi"
+  expect "hello world".truncate(2) == ".."
+test "toLower/upperCase/capitalize/lowerFirst/upperFirst case-convert as expected"
+  expect "Hello World".toLower() == "hello world"
+  expect "Hello World".upperCase() == "HELLO WORLD"
+  expect "hello".capitalize() == "Hello"
+  expect "Hello".lowerFirst() == "hello"
+  expect "hello".upperFirst() == "Hello"
+test "camelCase/snakeCase/kebabCase/startCase convert a multi-word phrase"
+  expect "foo bar baz".camelCase() == "fooBarBaz"
+  expect "foo bar baz".snakeCase() == "foo_bar_baz"
+  expect "foo bar baz".kebabCase() == "foo-bar-baz"
+  expect "foo bar baz".startCase() == "Foo Bar Baz"
+test "reverse reverses by character, not by raw byte"
+  expect "hello".reverse() == "olleh"
+test "escape/unescape round-trip HTML-sensitive characters"
+  expect "<a href=\"x\">&'</a>".escape() == "&lt;a href=&quot;x&quot;&gt;&amp;&#39;&lt;/a&gt;"
+  expect "&lt;a href=&quot;x&quot;&gt;&amp;&#39;&lt;/a&gt;".unescape() == "<a href=\"x\">&'</a>"

libs/std/time.plum CHANGED Viewed

@@ -6,7 +6,7 @@ import std/str
 extern fun rawNowMillis() -> Int
 # A single point in time, stored as milliseconds since the Unix epoch.
-type Time(Stringable) =
+type Time(ToStr) =
   value: Int
   fun toMillis(self) -> Int =

libs/std/uuid.plum CHANGED Viewed

@@ -5,7 +5,7 @@ import std/str
 # A UUID, stored as its canonical 36-character
 # `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form.
-type Uuid(Stringable) =
+type Uuid(ToStr) =
   value: Str
   fun toStr(self) -> Str =

plum-checker/src/lib.rs CHANGED Viewed

@@ -260,9 +260,111 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEnv,
     (global_env, classes, methods, enum_variants, enum_params)
 }
+/// A `Type`'s name for comparison purposes only — deliberately ignores `.generics`
+/// entirely (on both sides), so a trait's bare return/param type (`cause() ->
+/// Option`, unable to name a concrete payload since a trait has no instance to
+/// infer one from) is treated as compatible with ANY instantiation an implementer
+/// declares (`cause(self) -> Option[JsonParseError]`) — a real but deliberately
+/// coarse check (arity + base type names), not full structural/generic equality.
+fn paramTypeCompareName(pt: &ast::ParamType) -> Option<&str> {
+    match pt {
+        ast::ParamType::Type(t) => Some(t.name.as_str()),
+        ast::ParamType::Variadic(t) => Some(t.name.as_str()),
+        // A function-value param type has no single "name" to compare — never
+        // matches a trait method's plain `Type` param either way, but no real
+        // trait in `libs/std` declares one today, so this never actually fires.
+        ast::ParamType::Fn(_, _) => None,
+    }
+}
+/// Verifies every `type X(TraitName, ...) = ...` claim against `TraitName`'s own
+/// declared methods — until now, `implements` was pure documentation with zero
+/// enforcement (a class could claim any trait, real or not, and never define a
+/// single one of its methods, with nothing ever catching it). A `TraitName` that
+/// doesn't resolve to any declared `trait` in this source (e.g. `Comparable`,
+/// `Readable`, `Writable` — used across `libs/std` but never actually declared
+/// anywhere) is silently SKIPPED rather than an error: those names are still
+/// purely aspirational today, and erroring on them would break every existing
+/// type that names one, for reasons unrelated to whether it actually implements
+/// its REAL trait claims. Runs on the pre-monomorphization source deliberately —
+/// a generic class's own methods (and a real trait's own declared signatures,
+/// which are never specialized at all) read naturally here, before mangling
+/// folds a method's concrete return/param types into new, unrelated-looking
+/// names (`Option[JsonParseError]` -> `Option$JsonParseError`).
+fn checkTraitConformance(source: &ast::Source) -> Vec<CheckError> {
+    let mut errors = Vec::new();
+    let traits: BTreeMap<&str, &ast::Trait> = source.items.iter()
+        .filter_map(|i| match i { ast::Item::Trait(t) => Some((t.name.as_str(), t)), _ => None })
+        .collect();
+    let methods_by_receiver: BTreeMap<(&str, &str), &ast::Fn> = source.items.iter()
+        .filter_map(|i| match i {
+            ast::Item::Fn(f) => f.type_param.as_deref().map(|recv| ((recv, f.name.as_str()), f)),
+            _ => None,
+        })
+        .collect();
+    for item in &source.items {
+        let ast::Item::Class(c) = item else { continue };
+        for trait_name in &c.implements {
+            let Some(tr) = traits.get(trait_name.as_str()) else { continue };
+            for tm in &tr.methods {
+                let Some(f) = methods_by_receiver.get(&(c.name.as_str(), tm.name.as_str())) else {
+                    errors.push(CheckError {
+                        message: format!("class '{}' claims to implement trait '{}' but is missing method '{}'", c.name, trait_name, tm.name),
+                    });
+                    continue;
+                };
+                if f.params.len() != tm.params.len() {
+                    errors.push(CheckError {
+                        message: format!(
+                            "class '{}' method '{}' (implementing trait '{}'): expected {} param(s), got {}",
+                            c.name, tm.name, trait_name, tm.params.len(), f.params.len()
+                        ),
+                    });
+                    continue;
+                }
+                for (i, (fp, tp)) in f.params.iter().zip(tm.params.iter()).enumerate() {
+                    let (actual, expected) = (paramTypeCompareName(&fp.ty), paramTypeCompareName(&tp.ty));
+                    if actual != expected {
+                        errors.push(CheckError {
+                            message: format!(
+                                "class '{}' method '{}' (implementing trait '{}'): param {} ('{}'): expected type '{}', got '{}'",
+                                c.name, tm.name, trait_name, i, tp.name,
+                                expected.unwrap_or("<fn>"), actual.unwrap_or("<fn>")
+                            ),
+                        });
+                    }
+                }
+                match (&f.returns, &tm.returns) {
+                    (Some(ft), Some(tt)) if ft.name != tt.name => {
+                        errors.push(CheckError {
+                            message: format!(
+                                "class '{}' method '{}' (implementing trait '{}'): expected return type '{}', got '{}'",
+                                c.name, tm.name, trait_name, tt.name, ft.name
+                            ),
+                        });
+                    }
+                    (None, Some(tt)) => {
+                        errors.push(CheckError {
+                            message: format!(
+                                "class '{}' method '{}' (implementing trait '{}'): expected return type '{}', got none",
+                                c.name, tm.name, trait_name, tt.name
+                            ),
+                        });
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+    errors
+}
 pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
+    // Runs against the ORIGINAL (pre-monomorphization) source, deliberately —
+    // see `checkTraitConformance`'s own doc comment for why.
+    let mut errors: Vec<CheckError> = checkTraitConformance(source);
     let source = monomorphize::monomorphizeSource(source).map_err(|e| vec![CheckError { message: e }])?;
-    let mut errors: Vec<CheckError> = Vec::new();
     let (global_env, classes, methods, enum_variants, enum_params) = buildGlobalTables(&source);
     let min_required = buildMinRequiredArgs(&source);
     let ctx = CheckCtx { classes: &classes, methods: &methods, enum_variants: &enum_variants, enum_params: &enum_params, min_required: &min_required };
@@ -1099,7 +1201,17 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                             None => Ok(PlumType::TVar("_".to_string())),
                         },
                     },
+                    // An unresolved generic method return (e.g. `Result[T, E].unwrap()`'s
+                    // bare `T`, which this checker's `PlumType` erases entirely — see
+                    // `types.rs`'s `TNamed` having no type-argument slot) reaches here as
+                    // a plain `TVar`, not a real "wrong type". Field access on it is
+                    // "unmodeled" the same way an unknown enum's fields already are just
+                    // above (`ctx.enum_params.get` returning `None`) — allow it and let
+                    // codegen (which DOES track concrete monomorphized types) catch a
+                    // genuine mismatch. Only a definitely-wrong concrete type (`Int`,
+                    // `Str`, ...) still hard-errors here.
+                    PlumType::TVar(_) => Ok(PlumType::TVar("_".to_string())),
-                    _ => Err(format!("cannot access field '{}' on non-class type {}", field_name, obj_ty)),
+                    other => Err(format!("cannot access field '{}' on non-class type {}", field_name, other)),
                 },
                 ast::AttrKind::Method(call) => match methodReceiverName(&obj_ty) {
                     Some(class_name) => match ctx.methods.get(&(class_name.clone(), call.name.clone())) {

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -1622,12 +1622,28 @@ impl<'a> Monomorphizer<'a> {
     fn fnBareGenericRefs(&self, f: &ast::Fn) -> Vec<String> {
         let mut names: Vec<String> = Vec::new();
         for p in &f.params {
-            let n = match &p.ty {
+            let t = match &p.ty {
-                ast::ParamType::Type(t) => &t.name,
+                ast::ParamType::Type(t) => t,
-                ast::ParamType::Variadic(t) => &t.name,
+                ast::ParamType::Variadic(t) => t,
                 // TODO: fn-value params don't yet participate in bare-generic resolution.
                 ast::ParamType::Fn(_, _) => continue,
             };
+            // A param already fully instantiated with concrete type arguments
+            // (`headers: Map[Str, Str]`) is NOT a bare reference to the generic
+            // template — only the truly bare spelling (`headers: Map`, no `[...]`
+            // at all) needs this function's own per-call-site specialization.
+            // Without this check, ANY function taking an already-concrete
+            // generic-typed param (however unrelated to its own logic) was
+            // wrongly routed through `fns_bare_generic`'s worklist instead of
+            // the ordinary per-item pass, silently dropping it from `m.produced`
+            // under its original name — the caller's own inferred return type
+            // (via `fn_return_generic_enum`, which doesn't consult this
+            // classification at all) still looked correct, masking the missing
+            // function until codegen.
+            if !t.generics.is_empty() {
+                continue;
+            }
+            let n = &t.name;
             if (self.classes_generic.contains_key(n.as_str()) || self.enums_generic_by_name.contains_key(n.as_str()))
                 && !names.iter().any(|x| x == n)
             {

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -906,3 +906,129 @@ fun bad(nums: ...Int) -> Int =
     let source = parse(src);
     assert!(checkSource(&source).is_err());
 }
+#[test]
+fn classImplementingTraitWithMatchingMethodPasses() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+  fun greet(self, name: Str) -> Str =
+    \"beep {name}\"
+";
+    let source = parse(src);
+    assert!(checkSource(&source).is_ok(), "expected Ok, got: {:?}", checkSource(&source));
+}
+#[test]
+fn classClaimingTraitButMissingMethodIsError() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+";
+    let source = parse(src);
+    let result = checkSource(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs.iter().any(|e| e.message.contains("missing method 'greet'")), "got: {:?}", errs);
+}
+#[test]
+fn classClaimingTraitWithWrongParamCountIsError() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+  fun greet(self) -> Str =
+    \"beep\"
+";
+    let source = parse(src);
+    let result = checkSource(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs.iter().any(|e| e.message.contains("expected 1 param(s), got 0")), "got: {:?}", errs);
+}
+#[test]
+fn classClaimingTraitWithWrongParamTypeIsError() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+  fun greet(self, name: Int) -> Str =
+    \"beep\"
+";
+    let source = parse(src);
+    let result = checkSource(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs.iter().any(|e| e.message.contains("expected type 'Str', got 'Int'")), "got: {:?}", errs);
+}
+#[test]
+fn classClaimingTraitWithWrongReturnTypeIsError() {
+    let src = "\
+trait Greeter =
+  greet(name: Str) -> Str
+type Robot(Greeter) =
+  id: Int
+  fun greet(self, name: Str) -> Int =
+    0
+";
+    let source = parse(src);
+    let result = checkSource(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs.iter().any(|e| e.message.contains("expected return type 'Str', got 'Int'")), "got: {:?}", errs);
+}
+#[test]
+fn classClaimingUndeclaredTraitNameIsNotEnforced() {
+    // `Comparable`/`Readable`/`Writable`-style names used across `libs/std` but
+    // never declared as a real `trait` anywhere — silently unenforced, not an
+    // error, since there is nothing real to check it against.
+    let src = "\
+type Robot(NotARealTrait) =
+  id: Int
+";
+    let source = parse(src);
+    assert!(checkSource(&source).is_ok(), "expected Ok, got: {:?}", checkSource(&source));
+}
+#[test]
+fn classImplementingTraitWithGenericReturnTypeMismatchIsPermitted() {
+    // A trait method's own return type can never name a concrete payload (it
+    // has no instance to infer one from) — an implementer instantiating that
+    // same generic type with a concrete arg is still a match (base type name
+    // only; see `checkTraitConformance`'s doc comment).
+    let src = "\
+enum Option[T] =
+  | Some[T]
+  | None
+trait Err =
+  cause() -> Option
+type MyErr(Err) =
+  pos: Int
+  fun cause(self) -> Option[MyErr] =
+    None
+";
+    let source = parse(src);
+    assert!(checkSource(&source).is_ok(), "expected Ok, got: {:?}", checkSource(&source));
+}

plum-cli/Cargo.toml CHANGED Viewed

@@ -17,3 +17,4 @@ tree-sitter = "0.26"
 tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }
 toml_edit = "0.22"
 wasmtime = "47"
+ureq = "2.10"

plum-cli/src/main.rs CHANGED Viewed

@@ -389,11 +389,59 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Re
                     Ok(())
                 })))
             }
+            ("plum", "rawHttpRequest") => {
+                let func_ty = imp.ty().func().cloned()
+                    .ok_or_else(|| anyhow::anyhow!("plum::rawHttpRequest import must be a function"))?;
+                Ok(wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty.clone(), move |mut caller, params, results| {
+                    let method = readStrArg(&mut caller, &params[0])?;
+                    let url = readStrArg(&mut caller, &params[1])?;
+                    let headers = readStrArg(&mut caller, &params[2])?;
+                    let body = readStrArg(&mut caller, &params[3])?;
+                    let raw = performHttpRequest(&method, &url, &headers, &body);
+                    results[0] = wasmtime::Val::AnyRef(Some(makeStrResult(&mut caller, &func_ty, raw.as_bytes())?));
+                    Ok(())
+                })))
+            }
             (m, n) => anyhow::bail!("unsupported host import {m}::{n}"),
         }
     }).collect()
 }
+/// Performs one blocking HTTP round trip for `plum::rawHttpRequest` and packs
+/// the outcome into the wire format `libs/std/http.plum`'s `request` expects
+/// (see that extern's doc comment): `"1\x01<status>\x01<headers>\x00<body>"`
+/// on success, `"0\x01\x01<message>\x00"` for a transport-level failure. A
+/// non-2xx HTTP status (404, 500, ...) is NOT a failure here — it's still a
+/// complete response, so it goes through the success branch with its own
+/// status code.
+fn performHttpRequest(method: &str, url: &str, headers: &str, body: &str) -> String {
+    let agent = ureq::Agent::new();
+    let mut req = agent.request(method, url);
+    for line in headers.split('\n') {
+        if let Some((k, v)) = line.split_once(": ") {
+            req = req.set(k, v);
+        }
+    }
+    let result = if body.is_empty() { req.call() } else { req.send_string(body) };
+    match result {
+        Ok(resp) | Err(ureq::Error::Status(_, resp)) => {
+            let status = resp.status();
+            let mut header_lines = String::new();
+            for name in resp.headers_names() {
+                if let Some(v) = resp.header(&name) {
+                    if !header_lines.is_empty() {
+                        header_lines.push('\n');
+                    }
+                    header_lines.push_str(&format!("{name}: {v}"));
+                }
+            }
+            let body_text = resp.into_string().unwrap_or_default();
+            format!("1\x01{status}\x01{header_lines}\x00{body_text}")
+        }
+        Err(e) => format!("0\x01\x01{e}\x00"),
+    }
+}
 /// A pseudo-random `i64` seeded from the wall clock — `xorshift64*`, cheap and
 /// dependency-free (no `rand` crate in this workspace). Not cryptographically
 /// secure; fine for `Int.random`/`List.shuffle`/`Uuid.v4`, none of which need

plum-runtime/Cargo.lock CHANGED Viewed

@@ -11,6 +11,12 @@ dependencies = [
  "gimli",
 ]
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 [[package]]
 name = "allocator-api2"
 version = "0.2.21"
@@ -345,6 +351,17 @@ dependencies = [
  "winapi",
 ]
+[[package]]
+name = "displaydoc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
 [[package]]
 name = "either"
 version = "1.17.0"
@@ -385,7 +402,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -406,6 +423,17 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+[[package]]
+name = "flate2"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+ "zlib-rs",
+]
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -418,6 +446,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
 [[package]]
 name = "futures"
 version = "0.3.33"
@@ -563,12 +600,116 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+[[package]]
+name = "icu_collections"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+[[package]]
+name = "icu_locale_core"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+[[package]]
+name = "icu_normalizer"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+[[package]]
+name = "icu_normalizer_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
+[[package]]
+name = "icu_properties"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+[[package]]
+name = "icu_properties_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"
+[[package]]
+name = "icu_provider"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
 [[package]]
 name = "id-arena"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+[[package]]
+name = "idna_adapter"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
 [[package]]
 name = "indexmap"
 version = "2.14.0"
@@ -670,6 +811,12 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+[[package]]
+name = "litemap"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
 [[package]]
 name = "log"
 version = "0.4.33"
@@ -697,6 +844,16 @@ dependencies = [
  "rustix",
 ]
+[[package]]
+name = "miniz_oxide"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
 [[package]]
 name = "object"
 version = "0.39.1"
@@ -715,6 +872,12 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 [[package]]
 name = "petgraph"
 version = "0.6.5"
@@ -741,6 +904,7 @@ checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
 name = "plum-runtime"
 version = "0.1.0"
 dependencies = [
+ "ureq",
  "wasmtime",
 ]
@@ -756,6 +920,15 @@ dependencies = [
  "serde",
 ]
+[[package]]
+name = "potential_utf"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661"
+dependencies = [
+ "zerovec",
+]
 [[package]]
 name = "proc-macro2"
 version = "1.0.107"
@@ -849,6 +1022,20 @@ dependencies = [
  "smallvec",
 ]
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
 [[package]]
 name = "rustc-demangle"
 version = "0.1.28"
@@ -871,7 +1058,42 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.61.2",
+]
+[[package]]
+name = "rustls"
+version = "0.23.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06"
+dependencies = [
+ "log",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+[[package]]
+name = "rustls-pki-types"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
+dependencies = [
+ "zeroize",
+]
+[[package]]
+name = "rustls-webpki"
+version = "0.103.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
 ]
 [[package]]
@@ -959,6 +1181,12 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+[[package]]
+name = "simd-adler32"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -980,6 +1208,12 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 [[package]]
 name = "syn"
 version = "2.0.119"
@@ -1002,6 +1236,17 @@ dependencies = [
  "unicode-ident",
 ]
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
 [[package]]
 name = "target-lexicon"
 version = "0.13.5"
@@ -1018,7 +1263,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -1070,6 +1315,16 @@ dependencies = [
  "syn 3.0.3",
 ]
+[[package]]
+name = "tinystr"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
 [[package]]
 name = "toml"
 version = "0.9.12+spec-1.1.0"
@@ -1127,6 +1382,46 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+[[package]]
+name = "ureq"
+version = "2.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
+dependencies = [
+ "base64",
+ "flate2",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-pki-types",
+ "url",
+ "webpki-roots 0.26.11",
+]
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 [[package]]
 name = "uuid"
 version = "1.24.0"
@@ -1315,7 +1610,7 @@ dependencies = [
  "wasmtime-internal-unwinder",
  "wasmtime-internal-versioned-export-macros",
  "wat",
- "windows-sys",
+ "windows-sys 0.61.2",
  "wit-parser",
 ]
@@ -1366,7 +1661,7 @@ dependencies = [
  "sha2",
  "toml",
  "wasmtime-environ",
- "windows-sys",
+ "windows-sys 0.61.2",
  "zstd",
 ]
@@ -1442,7 +1737,7 @@ dependencies = [
  "rustix",
  "wasmtime-environ",
  "wasmtime-internal-versioned-export-macros",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -1466,7 +1761,7 @@ dependencies = [
  "cfg-if",
  "libc",
  "wasmtime-internal-core",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -1528,6 +1823,24 @@ dependencies = [
  "wast",
 ]
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.9",
+]
+[[package]]
+name = "webpki-roots"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
+dependencies = [
+ "rustls-pki-types",
+]
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -1550,7 +1863,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -1565,6 +1878,15 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -1574,6 +1896,70 @@ dependencies = [
  "windows-link",
 ]
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 [[package]]
 name = "winnow"
 version = "0.7.15"
@@ -1605,6 +1991,101 @@ dependencies = [
  "wasmparser 0.252.0",
 ]
+[[package]]
+name = "writeable"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
+[[package]]
+name = "yoke"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "synstructure",
+]
+[[package]]
+name = "zerofrom"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+dependencies = [
+ "zerofrom-derive",
+]
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "synstructure",
+]
+[[package]]
+name = "zeroize"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+[[package]]
+name = "zerotrie"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+[[package]]
+name = "zerovec"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+[[package]]
+name = "zerovec-derive"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+[[package]]
+name = "zlib-rs"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12"
 [[package]]
 name = "zmij"
 version = "1.0.23"

plum-runtime/Cargo.toml CHANGED Viewed

@@ -11,6 +11,7 @@ path = "src/main.rs"
 [dependencies]
 wasmtime = "47"
+ureq = "2.10"
 # Stand on its own rather than joining the parent directory's workspace: `plum
 # build` compiles this crate on demand with PLUM_WASM_PATH set, and it would

plum-runtime/src/main.rs CHANGED Viewed

@@ -193,11 +193,54 @@ fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Ve
                     Ok(())
                 }))
             }
+            ("plum", "rawHttpRequest") => {
+                let func_ty = imp.ty().func().cloned().expect("plum::rawHttpRequest import should be a function");
+                wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty.clone(), move |mut caller, params, results| {
+                    let method = readStrArg(&mut caller, &params[0])?;
+                    let url = readStrArg(&mut caller, &params[1])?;
+                    let headers = readStrArg(&mut caller, &params[2])?;
+                    let body = readStrArg(&mut caller, &params[3])?;
+                    let raw = performHttpRequest(&method, &url, &headers, &body);
+                    results[0] = wasmtime::Val::AnyRef(Some(makeStrResult(&mut caller, &func_ty, raw.as_bytes())?));
+                    Ok(())
+                }))
+            }
             (m, n) => panic!("unsupported host import {m}::{n}"),
         }
     }).collect()
 }
+/// See the identical helper in `plum-cli/src/main.rs` — this crate is built
+/// fresh per `plum build` invocation, not linked against `plum-cli`, so the
+/// logic is duplicated rather than shared.
+fn performHttpRequest(method: &str, url: &str, headers: &str, body: &str) -> String {
+    let agent = ureq::Agent::new();
+    let mut req = agent.request(method, url);
+    for line in headers.split('\n') {
+        if let Some((k, v)) = line.split_once(": ") {
+            req = req.set(k, v);
+        }
+    }
+    let result = if body.is_empty() { req.call() } else { req.send_string(body) };
+    match result {
+        Ok(resp) | Err(ureq::Error::Status(_, resp)) => {
+            let status = resp.status();
+            let mut header_lines = String::new();
+            for name in resp.headers_names() {
+                if let Some(v) = resp.header(&name) {
+                    if !header_lines.is_empty() {
+                        header_lines.push('\n');
+                    }
+                    header_lines.push_str(&format!("{name}: {v}"));
+                }
+            }
+            let body_text = resp.into_string().unwrap_or_default();
+            format!("1\x01{status}\x01{header_lines}\x00{body_text}")
+        }
+        Err(e) => format!("0\x01\x01{e}\x00"),
+    }
+}
 /// See the identical helper in `plum-cli/src/main.rs` — this crate is built
 /// fresh per `plum build` invocation, not linked against `plum-cli`, so the
 /// logic is duplicated rather than shared.

test/sample.plum CHANGED Viewed

@@ -216,7 +216,7 @@ fun random() -> Float = # generate random number
 fun fromStr() -> Result(Int, Err) = # convert Str to Int
   Ok(0)
-type Int(Comparable, Stringable)
+type Int(Comparable, ToStr)
 fun toFloat<Int>() -> Float = # convert Int to Float
   Float(self)

tooling/tree-sitter-plum/test/corpus/type.txt CHANGED Viewed

@@ -6,7 +6,7 @@ type Dog =
   name: Str
   age: B
-type Cat(Stringable) =
+type Cat(ToStr) =
   name: Str
   age: Int

website/src/content/docs/declarations/enum.md CHANGED Viewed

@@ -6,7 +6,7 @@ description: These are basic types
 An Algebraic Data Type
 ```rs
-enum Ordering: Stringable {
+enum Ordering: ToStr {
   LT
   EQ
   GT

website/src/content/docs/index.mdx CHANGED Viewed

@@ -55,11 +55,11 @@ fn toCelsius(f: float): float =
 fn addItems(items ...str) =
   list.add(items)
-trait Stringable where
+trait ToStr where
   fn toStr(): str
 // `Cat is a speciecs of felidae
-struct Cat is Stringable, Equal, Comparable =
+struct Cat is ToStr, Equal, Comparable =
   | name: str
   | age:  int