rip-lang 3.6.2 → 3.7.3

package/CHANGELOG.md

@@ -7,7 +7,43 @@ All notable changes to Rip will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [3.6.0] - 2026-02-10
+## [3.7.3] - 2026-02-11
+
+### Fixes & Polish
+
+- **Interface `::` fix** — `::` type annotations in interface bodies no longer produce double colons in `.d.ts` output.
+- **`.=` dot chain support** — `obj.name .= toUpperCase()` now works (walks back full property chain).
+- **`*` merge auto-init** — `*foo = {...}` auto-creates `foo` if undefined via `??= {}`.
+- **`loop n` uses `it`** — Loop counter is accessible as `it` inside the body.
+- **Syntax highlighting** — `|>` pipe operator added to VS Code, Vim, Playground, and rip-print.
+
+## [3.7.0] - 2026-02-11
+
+### Pipe Operator (`|>`)
+
+- **First-arg insertion pipe** — `x |> fn` compiles to `fn(x)`, and `x |> fn(y)` compiles to `fn(x, y)`. Combines the simplicity of F#-style pipes with multi-arg support like Elixir — no placeholder syntax needed. Left-associative, chains naturally: `5 |> double |> add(1)`.
+- Works with dotted references (`x |> Math.sqrt`, `x |> console.log`) and dotted calls (`x |> obj.method(y)` → `obj.method(x, y)`).
+- Implicit calls close at pipe boundaries — `x |> fn 1 |> bar 2` works correctly without parens.
+
+### Method Assignment (`.=`) — A Rip Original
+
+- **Compound method assignment** — `x .= trim()` compiles to `x = x.trim()`. The method-call equivalent of `+=`. No other language has this. Combined with implicit `it`, enables concise transformation pipelines: `items .= filter -> it.active` then `items .= map -> it.name`.
+
+### Prototype Operator (`::`)
+
+- **CoffeeScript-style prototype access restored** — `String::trim` compiles to `String.prototype.trim`. Disambiguated from type annotations by spacing: `::` with no space is prototype, `::` with a space is a type annotation. Both coexist cleanly.
+
+### `loop n` — Repeat N Times
+
+- **Counted loop** — `loop 5 -> body` compiles to `for (let _i = 0; _i < 5; _i++) { body }`. Works with literals, variables, and expressions.
+
+### Implicit `it` Parameter
+
+- **Auto-injected parameter** — Arrow functions with no explicit params that reference `it` in the body automatically inject `it` as the parameter. `arr.filter -> it > 5` compiles to `arr.filter(function(it) { return (it > 5); })`. Works with both `->` and `=>`. Stops at nested function boundaries.
+
+### Negative Indexing
+
+- **Python-style negative indexing** — `arr[-1]` compiles to `arr.at(-1)`, `arr[-2]` to `arr.at(-2)`, etc. Works on arrays and strings. Optional variant: `arr?[-1]` → `arr?.at(-1)`. Only literal negative numbers trigger the transform; variable indexes pass through unchanged.
 
 ### Browser Runtime — Full Async/Await Support
 

package/README.md

@@ -9,15 +9,15 @@
 </p>
 
 <p align="center">
-  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-3.6.0-blue.svg" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-3.7.3-blue.svg" alt="Version"></a>
   <a href="#zero-dependencies"><img src="https://img.shields.io/badge/dependencies-ZERO-brightgreen.svg" alt="Dependencies"></a>
-  <a href="#"><img src="https://img.shields.io/badge/tests-1140%2F1140-brightgreen.svg" alt="Tests"></a>
+  <a href="#"><img src="https://img.shields.io/badge/tests-1225%2F1225-brightgreen.svg" alt="Tests"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License"></a>
 </p>
 
 ---
 
-Rip is a modern language inspired by CoffeeScript. It compiles to **ES2022** (classes, `?.`, `??`, modules), adds about a **dozen new operators**, includes **built-in reactivity**, and sports a self-hosting compiler with **zero dependencies** — all in about 10,300 lines of code.
+Rip is a modern language inspired by CoffeeScript. It compiles to **ES2022** (classes, `?.`, `??`, modules), adds about a **dozen new operators**, includes **built-in reactivity**, and sports a self-hosting compiler with **zero dependencies** — all in about 10,800 lines of code.
 
 > **No imports. No hooks. No dependency arrays. Just write code.**
 
@@ -38,7 +38,7 @@ get '/users/:id' ->                 # RESTful API endpoint, comma-less
 
 **What makes Rip different:**
 - **Modern output** — ES2022 with native classes, `?.`, `??`, modules
-- **New operators** — `!`, `!?`, `//`, `%%`, `=~`, `.new()`, and more
+- **New operators** — `!`, `!?`, `//`, `%%`, `=~`, `|>`, `.new()`, and more
 - **Reactive operators** — `:=`, `~=`, `~>` as language syntax
 - **Optional types** — `::` annotations, `::=` aliases, `.d.ts` emission
 - **Zero dependencies** — everything included, even the parser generator
@@ -122,6 +122,21 @@ for x as iterable              # ES6 for-of on any iterable
 
 for x as! asyncIterable        # Async iteration shorthand
   console.log x                # Equivalent to: for await x as asyncIterable
+
+loop                           # Infinite loop (while true)
+  process!
+loop 5                         # Repeat N times
+  console.log "hi"
+```
+
+### Implicit `it`
+
+Arrow functions with no params that reference `it` auto-inject it as the parameter:
+
+```coffee
+users.filter -> it.active          # → users.filter(function(it) { ... })
+names = users.map -> it.name       # no need to name a throwaway variable
+orders.filter -> it.total > 100    # works with any expression
 ```
 
 ### Reactivity
@@ -168,6 +183,7 @@ Compiles to `.js` (types erased) + `.d.ts` (types preserved) — full IDE suppor
 | `!?` (otherwise) | `val !? 5` | Default only if `undefined` |
 | `?` (existence) | `x?` | True if `x != null` |
 | `?:` (ternary) | `x > 0 ? 'yes' : 'no'` | JS-style ternary expression |
+| `if...else` (postfix) | `"yes" if cond else "no"` | Python-style ternary expression |
 | `?.` `?.[]` `?.()` | `a?.b` `a?.[0]` `a?.()` | Optional chaining (ES6) |
 | `?[]` `?()` | `a?[0]` `a?(x)` | Optional chaining shorthand |
 | `??` | `a ?? b` | Nullish coalescing |
@@ -177,6 +193,15 @@ Compiles to `.js` (types erased) + `.d.ts` (types preserved) — full IDE suppor
 | `=~` | `str =~ /Hello, (\w+)/` | Match (captures in `_`) |
 | `[//, n]` | `str[/Hello, (\w+)/, 1]` | Extract capture n |
 | `.new()` | `Dog.new()` | Ruby-style constructor |
+| `::` (prototype) | `String::trim` | `String.prototype.trim` |
+| `[-n]` (negative index) | `arr[-1]` | Last element via `.at()` |
+| `*` (string repeat) | `"-" * 40` | String repeat via `.repeat()` |
+| `<` `<=` (chained) | `1 < x < 10` | Chained comparisons |
+| `\|>` (pipe) | `x \|> fn` or `x \|> fn(y)` | Pipe operator (first-arg insertion) |
+| `not in` | `x not in arr` | Negated membership test |
+| `not of` | `k not of obj` | Negated key existence |
+| `.=` (method assign) | `x .= trim()` | `x = x.trim()` — compound method assignment |
+| `*` (merge assign) | `*obj = {a: 1}` | `Object.assign(obj, {a: 1})` |
 | `or return` | `x = get() or return err` | Guard clause (Ruby-style) |
 | `?? throw` | `x = get() ?? throw err` | Nullish guard |
 
@@ -254,9 +279,9 @@ See [@rip-lang/ui](packages/ui/) for the full framework: file-based router, reac
 | **Reactivity** | None | Built-in |
 | **Dependencies** | Multiple | Zero |
 | **Self-hosting** | No | Yes |
-| **Lexer** | 3,558 LOC | 1,867 LOC |
-| **Compiler** | 10,346 LOC | 3,292 LOC |
-| **Total** | 17,760 LOC | ~10,300 LOC |
+| **Lexer** | 3,558 LOC | 1,958 LOC |
+| **Compiler** | 10,346 LOC | 3,378 LOC |
+| **Total** | 17,760 LOC | ~10,800 LOC |
 
 Smaller codebase, modern output, built-in reactivity.
 
@@ -291,25 +316,25 @@ await rip("res = fetch! 'https://api.example.com/todos/1'; res.json!")  // → {
 
 ```
 Source  ->  Lexer  ->  emitTypes  ->  Parser  ->  S-Expressions  ->  Codegen  ->  JavaScript
-           (1,867)    (types.js)     (357)       ["=", "x", 42]     (3,292)      + source map
+           (1,958)    (types.js)     (359)       ["=", "x", 42]     (3,378)      + source map
 ```
 
 Simple arrays (with `.loc`) instead of AST node classes. The compiler is self-hosting — `bun run parser` rebuilds from source.
 
 | Component | File | Lines |
 |-----------|------|-------|
-| Lexer + Rewriter | `src/lexer.js` | 1,867 |
-| Compiler + Codegen | `src/compiler.js` | 3,292 |
-| Type System | `src/types.js` | 719 |
+| Lexer + Rewriter | `src/lexer.js` | 1,958 |
+| Compiler + Codegen | `src/compiler.js` | 3,378 |
+| Type System | `src/types.js` | 1,099 |
 | Component System | `src/components.js` | 1,240 |
 | Source Maps | `src/sourcemaps.js` | 122 |
-| Parser (generated) | `src/parser.js` | 357 |
-| Grammar | `src/grammar/grammar.rip` | 935 |
+| Parser (generated) | `src/parser.js` | 359 |
+| Grammar | `src/grammar/grammar.rip` | 945 |
 | Parser Generator | `src/grammar/solar.rip` | 916 |
-| REPL | `src/repl.js` | 707 |
+| REPL | `src/repl.js` | 582 |
 | Browser Entry | `src/browser.js` | 119 |
 | Tags | `src/tags.js` | 63 |
-| **Total** | | **~10,325** |
+| **Total** | | **~10,774** |
 
 ---
 
@@ -319,7 +344,7 @@ Rip includes optional packages for full-stack development:
 
 | Package | Version | Purpose |
 |---------|---------|---------|
-| [rip-lang](https://www.npmjs.com/package/rip-lang) | 3.6.0 | Core language compiler |
+| [rip-lang](https://www.npmjs.com/package/rip-lang) | 3.7.3 | Core language compiler |
 | [@rip-lang/api](packages/api/) | 1.1.4 | HTTP framework (Sinatra-style routing, 37 validators) |
 | [@rip-lang/server](packages/server/) | 1.1.3 | Multi-worker app server (hot reload, HTTPS, mDNS) |
 | [@rip-lang/db](packages/db/) | 1.1.2 | DuckDB server with official UI (pure Bun FFI) |
@@ -365,7 +390,7 @@ rip file.rip           # Run
 rip -c file.rip        # Compile
 rip -t file.rip        # Tokens
 rip -s file.rip        # S-expressions
-bun run test           # 1140 tests
+bun run test           # 1225 tests
 bun run parser         # Rebuild parser
 bun run browser        # Build browser bundle
 ```

package/docs/NOTES.md

@@ -0,0 +1,93 @@
+<img src="https://raw.githubusercontent.com/shreeve/rip-lang/main/docs/rip.png" style="width:50px" /> <br>
+
+# Rip — Notes
+
+Ideas, future plans, and design thoughts for Rip.
+
+---
+
+## Standard Library (`stdlib`)
+
+Rip is a zero-dependency language, but a small standard library of useful
+utilities would save users from writing the same one-liners in every project.
+These are **not** language features — they're plain functions that could ship
+as a prelude or optional import.
+
+### Candidates
+
+```coffee
+# Printing (Ruby's p)
+p = console.log
+
+# Exit with optional code (uses implicit `it`)
+exit = -> process.exit(it)
+
+# Tap — call a function for side effects, return the original value
+# Useful in pipe chains: data |> tap(console.log) |> process
+tap = (v, fn) -> fn(v); v
+
+# Identity — returns its argument unchanged
+# Useful as a default callback: items.filter(id)
+id = -> it
+
+# No-op — does nothing
+# Useful as a default handler: onClick ?= noop
+noop = ->
+
+# String method aliases (shorter names for common checks)
+String::starts = String::startsWith
+String::ends   = String::endsWith
+String::has    = String::includes
+
+# Clamp a value to a range
+clamp = (v, lo, hi) -> Math.min(Math.max(v, lo), hi)
+
+# Sleep for N milliseconds (returns a Promise)
+sleep = (ms) -> new Promise (resolve) -> setTimeout resolve, ms
+
+# Times helper — call a function N times, collect results
+times = (n, fn) -> (fn(i) for i in [0...n])
+```
+
+### Design Questions
+
+- **Prelude vs import?** Should these be injected automatically (like Go's
+  `fmt` or Rip's reactive runtime), or explicitly imported (`import { p, tap }
+  from '@rip-lang/std'`)? Leaning toward explicit — Rip's philosophy is zero
+  magic in the output.
+
+- **Scope?** Keep it tiny. A stdlib that grows to 500 functions defeats the
+  purpose. Each entry should save real keystrokes on something people do
+  constantly.
+
+- **Node vs Browser?** Some helpers (like `exit`) are Node-only. Others (like
+  `p`, `tap`, `sleep`) work everywhere. May want to split into `std` (universal)
+  and `std/node` (server-only).
+
+---
+
+## Future Syntax Ideas
+
+Ideas that have been discussed but not yet implemented. Each would need
+design discussion before building.
+
+- **`defer`** — Go-style cleanup that runs when the function exits. Compiles
+  to try/finally. `defer file.close()`.
+
+- **`is a` / `isnt a`** — Readable instanceof. `x is a String` → 
+  `x instanceof String`.
+
+- **`.starts?` / `.ends?` / `.has?`** — Ruby-style question-mark methods.
+  `url.starts? "https"` → `url.startsWith("https")`.
+
+- **Pattern matching** — `match value` with destructuring arms. Big feature,
+  needs careful design.
+
+- **Reactive resource operator (`~>?`)** — Language-level `createResource`.
+  `user ~>? fetch!("/api/users/#{id}").json!` gives `user.loading`,
+  `user.error`, `user.data`. Park until real-world usage shows demand.
+
+- **Pipe operator (`|>`) — Hack-style placeholder** — Currently Rip uses
+  Elixir-style first-arg insertion. A `%` placeholder for arbitrary position
+  (`data |> fn(1, %, 3)`) could be added later if needed. Current design
+  covers 95%+ of cases.

package/docs/RIP-GUIDE.md

@@ -117,6 +117,7 @@ else
 
 # Ternary
 status = active ? "on" : "off"
+label = "big" if x > 5 else "small"
 
 # Postfix
 console.log "hi" if ready
@@ -147,11 +148,26 @@ for key, value of object
 for i in [1..10]         # inclusive (1 to 10)
 for i in [1...10]        # exclusive (1 to 9)
 
+# Loop N times
+loop 5
+  console.log "hi"
+
 # Comprehensions
 squares = (x * x for x in [1..10])
 evens = (x for x in items when x % 2 is 0)
 ```
 
+### Implicit `it`
+
+Arrow functions with no params that reference `it` auto-inject it as the parameter:
+
+```coffee
+users.filter -> it.active          # instead of (u) -> u.active
+names = users.map -> it.name       # instead of (u) -> u.name
+orders.filter -> it.total > 100    # works with any expression
+items.map => it.toUpperCase()      # works with fat arrows too
+```
+
 ---
 
 ## Operators
@@ -174,6 +190,15 @@ Rip extends JavaScript with powerful operators:
 | `:=` | State | `count := 0` | Reactive signal |
 | `~=` | Computed | `doubled ~= x * 2` | Reactive computed |
 | `~>` | Effect | `~> console.log x` | Reactive side effect |
+| `::` | Prototype | `String::trim` | `String.prototype.trim` |
+| `[-n]` | Negative index | `arr[-1]` | `arr.at(-1)` |
+| `*` | String repeat | `"-" * 40` | `"-".repeat(40)` |
+| `<` `<=` | Chained | `1 < x < 10` | `(1 < x) && (x < 10)` |
+| `.=` | Method assign | `x .= trim()` | `x = x.trim()` |
+| `*` | Merge assign | `*obj = {a: 1}` | `Object.assign(obj, {a: 1})` |
+| `not in` | Not in | `x not in arr` | Negated membership |
+| `not of` | Not of | `k not of obj` | Negated key existence |
+| `if...else` | Postfix ternary | `"a" if x else "b"` | `x ? "a" : "b"` |
 | `**` | Power | `2 ** 10` | `1024` |
 | `..` | Range | `[1..5]` | Inclusive range |
 | `...` | Spread/rest | `[...a, ...b]` | ES6 spread |
@@ -211,6 +236,19 @@ if text =~ /Hello, (\w+)/
 domain = "user@example.com"[/@(.+)$/, 1]  # "example.com"
 ```
 
+### Pipe Operator (`|>`)
+
+Pipes a value into a function as the first argument. Chains left-to-right:
+
+```coffee
+5 |> double                      # → double(5)
+5 |> add(3)                      # → add(5, 3)
+5 |> double |> add(1)            # → add(double(5), 1)
+data |> JSON.stringify(null, 2)  # → JSON.stringify(data, null, 2)
+```
+
+If the right side is a bare reference, it's called with the piped value. If the right side is already a call, the piped value is inserted as the first argument. This is the Elixir-style pipe — cleaner than F# (multi-arg works) and simpler than Hack (no placeholder needed).
+
 ### Guard Clauses
 
 ```coffee
@@ -633,7 +671,7 @@ rip -d file.rip            # Generate .d.ts
 rip -t file.rip            # Show tokens
 rip -s file.rip            # Show S-expressions
 rip -q -c file.rip         # Quiet (no headers)
-bun run test               # Run test suite (1,140 tests)
+bun run test               # Run test suite
 ```
 
 ---

package/docs/RIP-INTERNALS.md

@@ -45,7 +45,7 @@ class BinaryOp {
 ["+", left, right]  // That's it!
 ```
 
-**Result:** CoffeeScript's compiler is 17,760 LOC. Rip's is ~10,300 LOC — smaller, yet includes a complete reactive runtime, type system, component system, and source maps.
+**Result:** CoffeeScript's compiler is 17,760 LOC. Rip's is ~10,800 LOC — smaller, yet includes a complete reactive runtime, type system, component system, and source maps.
 
 > **Transform the IR (s-expressions), not the output (strings).**
 
@@ -66,7 +66,7 @@ console.log(code);
 | Feature | CoffeeScript | Rip |
 |---------|-------------|------|
 | Optional chaining | 4 soak operators | ES6 `?.` / `?.[]` / `?.()` + shorthand `?[]` / `?()` |
-| Ternary | No | `x ? a : b` |
+| Ternary | No | `x ? a : b` and `a if x else b` |
 | Regex features | Basic | Ruby-style (`=~`, indexing, captures in `_`) |
 | Async shorthand | No | Dammit operator (`!`) |
 | Void functions | No | `def fn!` |
@@ -77,7 +77,7 @@ console.log(code);
 | Dependencies | Multiple | **Zero** |
 | Parser generator | External (Jison) | **Built-in (Solar)** |
 | Self-hosting | No | **Yes** |
-| Total LOC | 17,760 | ~10,300 |
+| Total LOC | 17,760 | ~10,800 |
 
 ## Design Principles
 
@@ -93,7 +93,7 @@ console.log(code);
 
 ```
 Source Code  →  Lexer  →  emitTypes  →  Parser  →  S-Expressions  →  Codegen  →  JavaScript
-                (1,867)    (types.js)    (357)       (arrays + .loc)     (3,292)      + source map
+                (1,958)    (types.js)    (359)       (arrays + .loc)     (3,378)      + source map
                               ↓
                            file.d.ts (when types: "emit")
 ```
@@ -102,14 +102,14 @@ Source Code  →  Lexer  →  emitTypes  →  Parser  →  S-Expressions  →  C
 
 | File | Purpose | Lines | Modify? |
 |------|---------|-------|---------|
-| `src/lexer.js` | Lexer + Rewriter | 1,867 | Yes |
-| `src/compiler.js` | Compiler + Code Generator | 3,292 | Yes |
-| `src/types.js` | Type System (lexer sidecar) | 719 | Yes |
+| `src/lexer.js` | Lexer + Rewriter | 1,958 | Yes |
+| `src/compiler.js` | Compiler + Code Generator | 3,378 | Yes |
+| `src/types.js` | Type System (lexer sidecar) | 1,099 | Yes |
 | `src/components.js` | Component System (compiler sidecar) | 1,240 | Yes |
 | `src/sourcemaps.js` | Source Map V3 Generator | 122 | Yes |
 | `src/tags.js` | HTML Tag Classification | 63 | Yes |
 | `src/parser.js` | Generated parser | 357 | No (auto-gen) |
-| `src/grammar/grammar.rip` | Grammar specification | 935 | Yes (carefully) |
+| `src/grammar/grammar.rip` | Grammar specification | 945 | Yes (carefully) |
 | `src/grammar/solar.rip` | Parser generator | 916 | No |
 
 ## Example Flow
@@ -579,4 +579,4 @@ rip> .js      # Toggle JS display
 
 ---
 
-*Rip 3.4 — 1,140 tests passing — Zero dependencies — Self-hosting — ~10,300 LOC*
+*Rip 3.7 — 1,219 tests passing — Zero dependencies — Self-hosting — ~10,800 LOC*