rip-lang 3.6.1 → 3.7.0

package/CHANGELOG.md

@@ -7,7 +7,33 @@ 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.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.0-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-1219%2F1219-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.0 | 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           # 1219 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*

package/docs/RIP-LANG.md

@@ -2,7 +2,7 @@
 
 # Rip Language Reference
 
-Rip is a modern reactive language that compiles to ES2022 JavaScript. It combines CoffeeScript's elegant syntax with built-in reactivity primitives. Zero dependencies, self-hosting, ~10,300 LOC.
+Rip is a modern reactive language that compiles to ES2022 JavaScript. It combines CoffeeScript's elegant syntax with built-in reactivity primitives. Zero dependencies, self-hosting, ~10,800 LOC.
 
 ---
 
@@ -121,6 +121,10 @@ else
 status = active ? "on" : "off"
 result = x > 5 ? "big" : "small"
 
+# Ternary (Python-style postfix)
+status = "active" if online else "offline"
+label = "big" if x > 5 else "small"
+
 # NOTE: Subscript in ternary true-branch needs parentheses
 item = found ? (arr[0]) : default
 
@@ -227,6 +231,15 @@ until done
 loop
   data = fetch()
   break if data.complete
+
+# Loop N times
+loop 5
+  console.log "hi"
+# Compiles to: for (let _i = 0; _i < 5; _i++) { ... }
+
+# Loop with variable or expression
+loop retries
+  attempt!
 ```
 
 ## Comprehensions
@@ -275,6 +288,7 @@ Multiple lines
 | `of` | `k of obj` | Object key existence |
 | `?` (postfix) | `a?` | Existence check (`a != null`) |
 | `?` (ternary) | `a ? b : c` | Ternary conditional |
+| `if...else` (postfix) | `b if a else c` | Python-style ternary |
 | `?.` `?.[]` `?.()` | `a?.b` `a?.[0]` `a?.()` | Optional chaining (ES6) |
 | `?[]` `?()` | `a?[0]` `a?(x)` | Optional chaining shorthand |
 | `??` | `a ?? b` | Nullish coalescing |
@@ -293,6 +307,15 @@ Multiple lines
 | `!` | Void | `def process!` | Suppresses implicit return |
 | `!?` | Otherwise | `val !? 5` | Default if undefined or throws |
 | `=~` | Match | `str =~ /pat/` | Ruby-style regex match, captures in `_` |
+| `::` | Prototype | `String::trim` | `String.prototype.trim` |
+| `[-n]` | Negative index | `arr[-1]` | `arr.at(-1)` |
+| `*` | String repeat | `"-" * 40` | `"-".repeat(40)` |
+| `<` `<=` | Chained comparison | `1 < x < 10` | `(1 < x) && (x < 10)` |
+| `\|>` | Pipe | `x \|> fn` or `x \|> fn(y)` | `fn(x)` or `fn(x, y)` |
+| `.=` | 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 test |
+| `not of` | Not of | `k not of obj` | Negated key existence |
 
 ## Assignment Operators
 
@@ -333,6 +356,10 @@ status = active ? 'on' : 'off'
 result = valid ? obj.field : null
 output = ready ? compute() : fallback
 
+# Python-style postfix ternary
+status = "active" if online else "offline"
+label = "big" if x > 5 else "small"
+
 # Nested
 level = score > 90 ? 'A' : score > 80 ? 'B' : score > 70 ? 'C' : 'F'
 
@@ -349,6 +376,155 @@ result = riskyOperation() !? "default"
 # If riskyOperation() throws or returns null/undefined, result = "default"
 ```
 
+## Method Assignment (`.=`)
+
+A Rip original. Compound assignment for method calls — apply a method to a
+variable and assign the result back in one step:
+
+```coffee
+# Without .= — repeat the variable name every time
+items = items.filter -> it.active
+items = items.map -> it.name
+items = items.sort (a, b) -> a.localeCompare b
+str = str.trim()
+str = str.toLowerCase()
+
+# With .= — name it once, transform in place
+items .= filter -> it.active
+items .= map -> it.name
+items .= sort (a, b) -> a.localeCompare b
+str .= trim()
+str .= toLowerCase()
+```
+
+`x .= method(args)` compiles to `x = x.method(args)`. It's the method-call
+equivalent of `+=` — just as `x += 5` means `x = x + 5`, `x .= trim()`
+means `x = x.trim()`.
+
+This operator is unique to Rip. Other languages have `+=`, `-=`, `*=`, and
+other arithmetic compound assignments, but none extend the concept to method
+calls. Combined with implicit `it`, this enables remarkably concise data
+transformation pipelines:
+
+```coffee
+users .= filter -> it.active
+users .= map -> it.name
+users .= sort()
+```
+
+Works with any method — built-in or custom, with or without arguments.
+
+## Merge Assignment (`*`)
+
+A Rip original. Merge properties into an existing object without repeating
+its name:
+
+```coffee
+# Without * — repeat the object name or use verbose Object.assign
+Object.assign config,
+  host: "localhost"
+  port: 3000
+  debug: true
+
+# With * — clean and direct
+*config =
+  host: "localhost"
+  port: 3000
+  debug: true
+
+# Single line
+*opts = {method: "POST", body: data}
+
+# Dotted paths
+*el.style =
+  color: "red"
+  fontSize: "14px"
+
+# Merge user overrides into defaults
+*defaults = userConfig
+```
+
+`*target = value` compiles to `Object.assign(target, value)`. The `*` reads
+as "spread these into" — the same concept as `...` spread but as an
+assignment. This is unique to Rip.
+
+Common use cases: config objects, options bags, state initialization, DOM
+styling, merging defaults with overrides — anywhere you're setting multiple
+properties on an existing object.
+
+## Prototype Operator (`::`)
+
+Access `.prototype` with `::` (CoffeeScript-style). Disambiguated from type annotations by spacing:
+
+```coffee
+# Prototype access (no space after ::)
+String::starts = String::startsWith
+String::ends   = String::endsWith
+String::has    = String::includes
+
+# Now you can use them
+"hello".starts "he"        # true
+"hello.rip".ends ".rip"    # true
+"error: bad".has "error"   # true
+
+# Define new prototype methods
+String::shout = -> @toUpperCase() + "!"
+"hello".shout()            # "HELLO!"
+
+# Type annotations (space after ::) — unaffected
+name:: string = "Alice"
+def greet(name:: string):: string
+  "Hello, #{name}!"
+```
+
+The rule is simple: `::` with **no space** before an identifier is prototype access. `::` with a **space** is a type annotation.
+
+## Negative Indexing
+
+Literal negative indexes compile to `.at()` for Python-style access from the end:
+
+```coffee
+arr = [10, 20, 30, 40, 50]
+
+arr[-1]          # → arr.at(-1)  — 50 (last)
+arr[-2]          # → arr.at(-2)  — 40 (second to last)
+str[-1]          # works on strings too
+
+arr?[-1]         # → arr?.at(-1) — optional variant
+
+# Positive and variable indexes are unchanged
+arr[0]           # → arr[0]      — normal access
+arr[i]           # → arr[i]      — variable index
+```
+
+Only literal negative numbers trigger the `.at()` transform. Variable indexes pass through as-is.
+
+## Pipe Operator (`|>`)
+
+Pipes a value into a function as its first argument. Chains left-to-right:
+
+```coffee
+# Simple reference — value becomes the sole argument
+5 |> double                      # → double(5)
+10 |> Math.sqrt                  # → Math.sqrt(10)
+"hello" |> console.log           # → console.log("hello")
+
+# Multi-arg — value is inserted as the FIRST argument
+5 |> add(3)                      # → add(5, 3)
+data |> filter(isActive)         # → filter(data, isActive)
+"World" |> greet("!")            # → greet("World", "!")
+
+# Chaining — reads left-to-right like a pipeline
+5 |> double |> add(1) |> console.log
+# → console.log(add(double(5), 1))
+
+# Works with dotted methods
+users |> Array.from              # → Array.from(users)
+data |> JSON.stringify(null, 2)  # → JSON.stringify(data, null, 2)
+```
+
+This is the **Elixir-style** pipe — strictly better than F#'s (which only supports bare function references) and cleaner than Hack's (which requires a `%` placeholder). No special syntax to learn; if the right side is a call, the left value goes first.
+
 ---
 
 # 4. Functions
@@ -420,6 +596,41 @@ def findUser(id)
   null
 ```
 
+## Implicit `it` Parameter
+
+Arrow functions with no explicit parameters that reference `it` in the body automatically inject `it` as the parameter:
+
+```coffee
+# Without `it` — must name a throwaway variable
+users.filter (u) -> u.active
+names = users.map (u) -> u.name
+
+# With `it` — cleaner
+users.filter -> it.active
+names = users.map -> it.name
+orders.filter -> it.total > 100
+
+# Works with fat arrows too
+items.map => it.toUpperCase()
+
+# Nested arrows — each level gets its own `it`
+# Only the innermost param-less arrow with `it` is affected
+groups.map -> it.items.filter -> it.active
+
+# Explicit params still work normally
+items.sort (a, b) -> a - b
+```
+
+Compiles to standard JavaScript — `it` becomes a regular function parameter:
+
+```coffee
+arr.filter -> it > 5
+# → arr.filter(function(it) { return (it > 5); })
+
+arr.map => it.name
+# → arr.map(it => it.name)
+```
+
 ## Calling Functions
 
 ```coffee
@@ -1165,4 +1376,4 @@ count = 10  # Logs: "Count: 10, Doubled: 20"
 
 ---
 
-*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*