jade-lang 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb2b101369a0d671ca8f2aa020e7113a49f22e700491e5d14f7e574f62ee17ec
-  data.tar.gz: 7e017dbe893887f9e7ac3dfcb5c434474085771f5062ee509cf8e9ee9682ddd6
+  metadata.gz: f1bbeb934a5bbbeb19cfeddeb18f59798c37380a34d514110f42e07dab206525
+  data.tar.gz: 1f68a227a953fa57f875274f409bf93aa7269bbadfc4b3abc7634ea1d6b283c2
 SHA512:
-  metadata.gz: 45578bee3ec52655fbba6a0cd7a053a6ad65c9981760edd86e2966fd671958a63fc08fb0120b58fda73298c584773a8e6a4c92eb71b2c11d79228bb88a905e16
-  data.tar.gz: 698a60f7e747a8042e32f5da24b8c6c322d25a470e3a65f0ed6dfeb61a89c67cc6394ab993115c8c42e9305e75db9b5445f7b5a42a74974832a2c5cd268fe209
+  metadata.gz: 87f7c7e84b193ee2dba6e989f493ca36cf4bc6a58ba7d4c38519aedf5052908263cea802e917b11555396edce72c1ae4af5ff687676f13e123d37858c9643e8f
+  data.tar.gz: 0d2f3e20d4e1863a567310355a04bc7eb0fb73c49b629db3f0f6162ce2a009ddf821420558962e35052f0a5859d035b196483ead990659f0c73700ad97b4abfb

data/AGENTS.md

@@ -0,0 +1,164 @@
+# Writing Jade
+
+Idiom and gotchas. This file is deliberately not a function list — that's
+what `jade q api` is for, and a copy here would rot.
+
+## Ask the compiler, not the source
+
+| Question | Command |
+|---|---|
+| Does this function exist? What does it take? | `jade q api List` / `jade q api List.fold` |
+| Which module has a `fold`? | `jade q find fold` |
+| How is a lambda / `implements` block written? | `jade q syntax lambda` |
+| Did what I just wrote compile? | `jade check path/to/file.jd` |
+
+**Grepping the stdlib does not work, and fails quietly.** Stdlib modules are
+written two ways — Jade in a heredoc (`Maybe`, `Result`, `Decimal`) and a Ruby
+DSL (`List`, `String`, `Dict`, `Decode`) — so half of them never spell `def`,
+and none contains the string `List.map` you would search for. Extension
+modules (`Sql.*`) live in a gem that isn't in the tree at all. A grep that
+comes back empty tells you nothing.
+
+Inside a project, `jade q api` covers the stdlib, your own modules, and any
+extension gem's, each tagged with an `origin`.
+
+## Reach for the combinator
+
+A `case` that just unwraps and rewraps is the long way round.
+
+| Instead of | Write |
+|---|---|
+| `case m in Just(x) then f(x) in Nothing then Nothing end` | `Maybe.map(m, f)` |
+| `case m in Just(x) then x in Nothing then d end` | `Maybe.with_default(m, d)` |
+| `case m in Just(x) then f(x) in Nothing then Nothing end` where `f` returns `Maybe` | `Maybe.and_then(m, f)` |
+| `case r in Ok(x) then Ok(f(x)) in Err(e) then Err(e) end` | `Result.map(r, f)` |
+| `case r in Ok(x) then x in Err(_) then d end` | `Result.with_default(r, d)` |
+| a hand-written `==` | nothing — `Eq` derives |
+| a hand-written decoder for a struct | nothing — `Decode.from_json` derives it |
+
+These read best piped:
+
+```jade
+def label(m: Maybe(User)) -> String
+  m
+    |> Maybe.map((u) -> { u.name })
+    |> Maybe.with_default("anonymous")
+end
+```
+
+`case` earns its place when you're actually distinguishing variants — the
+`Result` arm that reports a different error, the union with five constructors.
+Write one `in` branch per variant rather than an `else` fallback; `else` is for
+matching literals, where exhaustiveness isn't available.
+
+**`map` changes the element type.** `Maybe.map : (Maybe(a), (a) -> b) ->
+Maybe(b)`. If you were told otherwise, that was hover, which reports a
+collapsed `(a) -> a` for the stdlib functions backing an interface — a known
+bug, see `~/vault/claude/jade/bugs/hover-collapses-stdlib-type-vars.md`.
+`jade q api` reads the declaration and is right.
+
+## Imports
+
+Auto-imported, no `import` needed: **`Basics`, `Maybe`, `Tuple`, `List`,
+`Char`, `String`, `Result`, `Task`, `Bytes`**.
+
+Everything else needs an explicit `import`: **`Dict`, `Set`, `Decode`,
+`Decode.Params`, `Encode`, `Calendar`, `Clock`, `Decimal`, `Show`, `Debug`**.
+`Show.show(x)` without `import Show` is "I cannot find a `Show.show`
+variable" — the function exists, the import doesn't.
+
+`import Dict` gets you the module. To name its *type* unqualified you have to
+ask for it:
+
+```jade
+import Dict exposing (Dict)      -- then: def go -> Dict(String, Int)
+import Dict                      -- then: def go -> Dict.Dict(String, Int)
+```
+
+**Zero-argument entries are values, not calls.** `Dict.empty`, `Decode.bool`,
+`Encode.null` — no parentheses. `Dict.empty()` is a compile error.
+
+## Interfaces
+
+The built-ins live in `Basics`: `Eq`, `Comparable`, `Appendable`, `Mappable`,
+`Chainable`, `Numeric`. Plus `Show` (in `Show`), `Decodable` (in `Decode`),
+`Encodable` (in `Encode`).
+
+Declare and implement:
+
+```jade
+interface Sized(a) with
+  size : a -> Int
+end
+
+
+implements Sized(Basket) with
+  size: (b) -> { List.length(b.items) }
+end
+```
+
+The right-hand side is an inline lambda or a function reference
+(`size: basket_size`).
+
+Two things to keep straight:
+
+- **The interface parameter is the constructor, not the applied type.**
+  `Mappable f` has `map : f(a), (a -> b) -> f(b)` — `f` is `Maybe`, not
+  `Maybe(a)`. Getting this wrong is why the impl target reads
+  `Mappable(Maybe(a))`.
+- **`jade q api` tells you what already has an instance.** `jade q api
+  Decode.Decodable` lists every implementing type under `implemented_by`;
+  a struct's entry lists what it `implements`. Check before writing one.
+
+### What derives, what doesn't
+
+Verified against the compiler:
+
+| | Structs / unions |
+|---|---|
+| `Eq` (`==`) | derives |
+| `Show` | derives |
+| `Encodable` / `Decodable` | derives |
+| `Comparable` (`<`, `List.sort`) | **does not derive** |
+
+`List.sort` on a list of structs is `No implementation of Basics.Comparable
+for Point`. Write the instance, or sort by a projection with
+`List.sort_by`.
+
+## Encoding and decoding
+
+`Encode.encode(value)` derives the encoder from the value's type;
+`Decode.from_json(json)` derives the decoder from the **return type**. A
+struct round-trips with neither written by hand:
+
+```jade
+def parse(json: String) -> Result(User, DecodeError)
+  Decode.from_json(json)
+end
+```
+
+Derivation reaches through structural types, so anything built from encodable
+parts is encodable: `List(a)`/`Set(a)` → array, `Maybe(a)` → the value or
+`null`, tuples → positional array, `Dict(k, v)` → array of `[k, v]` pairs (a
+JSON object only admits string keys), a struct → object keyed by field name, a
+union whose variants take no arguments → the variant name in snake_case.
+
+Outside that list — a union carrying arguments, say — write
+`implements Encodable(T)` / `Decodable(T)` yourself; nothing but you knows the
+shape it should take.
+
+Reach for the explicit combinators (`Decode.field`, `Decode.required`,
+`Decode.index`) when the JSON doesn't match the struct one-to-one. Use
+`Decode.Params` for PATCH-style input, where a missing field means "don't
+touch" rather than an error.
+
+Full treatment: [docs/json.md](docs/json.md).
+
+## Where else to look
+
+- [docs/syntax.md](docs/syntax.md) — the language, form by form.
+- [examples/](examples/) — nine files, compiled and asserted by
+  `spec/examples_spec.rb`, so they're verified idiom rather than samples that
+  drifted. `interfaces.jd` and `pattern_matching.jd` earn their keep.
+- [docs/interop.md](docs/interop.md) — the Ruby boundary, ports, `uses`.
+- [docs/stdlib.md](docs/stdlib.md) — what each module is for.

data/CHANGELOG.md

@@ -6,6 +6,219 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.5.0]
+
+### Added
+
+- **`jade check [FILE...]`** type-checks and prints diagnostics without
+  generating anything — the same front end the language server runs, exiting 1
+  if there were errors. With no arguments it checks every `.jd` under the
+  source root. Closes the loop for editors, CI, and anything that just edited a
+  file and wants to know whether it invented a function.
+- **`jade q api [MODULE|NAME]`** and **`jade q find TERM`** report the public
+  surface of everything a module can call — signatures, interface constraints,
+  a struct's fields, a type's variants and what it implements, an interface and
+  what implements it — read out of the registry rather than the source. Source
+  is the wrong thing to read: stdlib modules are written two ways (Jade in a
+  heredoc, a Ruby DSL), so grepping `lib/jade/stdlib/` finds neither `List.map`
+  nor half the modules' functions at all, and an extension gem's modules aren't
+  in your tree to grep. Inside a project the listing spans the stdlib, the
+  project's own modules and any extension gem's, each tagged with its `origin`;
+  without a `jade.json` it falls back to the stdlib, so the query still answers
+  from any directory. A module that won't compile is reported under `skipped`
+  rather than silently missing.
+- **`jade q syntax [FORM]`** reports how a form is written — `lambda` is
+  `(args) -> { body }`, plus `def`, `type`, `struct`, `case`, `if`, `module`,
+  `import`, `interface`, `implements`, `uses`. Signatures answer "does this
+  function exist and what does it take", never "how is a lambda spelled", and
+  that second question has its own wrong answers. It serves the corpus the
+  editor already offers as completions, so the two can't drift; needs no
+  project and reads no files.
+
+- **`AGENTS.md`** — idiom and gotchas for writing Jade: reach for `Maybe.map` /
+  `with_default` over a `case` that only unwraps and rewraps, which stdlib
+  modules are auto-imported and which need an `import`, that zero-argument
+  entries are values and `Dict.empty()` is a compile error, what derives (`Eq`,
+  `Show`, `Encodable`, `Decodable`) and what doesn't (`Comparable`), and how
+  interfaces and encode/decode fit together. Deliberately not a function list —
+  that's `jade q api`, and a copy would rot. Every claim in it was checked
+  against the compiler.
+- The gem now ships `docs/` and `AGENTS.md`, so a project that installs
+  jade-lang gets them instead of README links pointing at nothing.
+
+### Changed
+
+- **Decoding a row returned from a port is roughly eight times cheaper.**
+  A derived decoder was a composition of combinators rebuilt and walked
+  for every row; a profile put 88% of the time inside the interpreter and
+  70 allocations on a four-field row. Deriving now emits one node
+  carrying every key, its decoder and the constructor, applied once
+  rather than curried through a closure per field; the interpreter
+  returns values unwrapped, with failures on a sentinel, so nothing
+  allocates a `Result` per node; and each descriptor decodes itself
+  instead of being matched out of a twenty-branch `case`. A four-field
+  row went 9.58 to 1.19 µs and 70 allocations to 5.
+- **`Decimal`, `Clock.Instant` and `Calendar.Date` read their text form
+  in Ruby** rather than parsing it through Jade-level combinators, which
+  cost a fresh decoder, two `Maybe`s and a tuple for every value. The
+  text forms are unchanged, so JSON output and existing ports are
+  unaffected. One input changes meaning: a trailing exponent marker
+  (`"825e-4e"`) used to read as `825e-4`, because splitting on every
+  `"e"` dropped the empty trailing piece, and is rejected now.
+- **Encoding a value back out to Ruby is cheaper by the same route.** A
+  derived record encoder built a pair per field and folded the list back
+  into a hash, with an intrinsic lookup for both per field per value; it
+  builds the hash directly. `Encodable(Instant)` writes its string in
+  Ruby next to the reader that parses it. Handing a four-field struct
+  back to a Ruby caller cost 2.26 µs/row over the internal form and now
+  costs 0.17 — what a caller waits for and what `Internal` measures have
+  converged.
+- **`Calendar.from_rata_die` is closed form.** It walked a year at a time
+  to find the year, then December backwards to find the month, allocating
+  a `Month` and a tuple per step through two twelve-branch `case`
+  statements. It is reached from `Clock.to_iso`, `Clock.on_date` and
+  `Calendar.add`, so this is not only an interop win — any Jade code
+  doing date arithmetic pays it.
+- The `case` completion snippet offers one `in` branch per variant instead of
+  an `else` fallback. `else` is for matching literals, where exhaustiveness
+  isn't available — not the default shape of a `case`.
+- **A missing qualified name now suggests the one you meant.** `List.fold_left`
+  answers ``help: did you mean `List.fold`?`` instead of a bare "not found" —
+  the candidates are the module's exposed values, so the suggestion is drawn
+  from what actually exists. Suggestions go through the alias the module was
+  imported under (`L.post`, not `Ledger.post`), since that's what the call site
+  can say. Local variables, types and constructors already did this;
+  module-qualified access was the gap.
+
+### Fixed
+
+- **Operator precedence was lost inside an infix chain's operands.**
+  `(1 + 2 * 3) + 0` was 9, `(10 - 4 / 2) + 0` was 3, and
+  `id(1 + 2 * 3) + 0` was 9. Shunting-yard ran on a chain's own operators
+  but treated every operand as an atom and returned it unfixed, so a
+  grouping, a call argument, a lambda body, a ternary branch or a record
+  value sitting in a chain kept the shape the parser built — left to
+  right, no precedence. Standing alone the same expression was fine,
+  which is why `1 + 2 * 3` and `(1 + 2 * 3)` both gave 7 and nothing
+  caught it. **This changes generated output for code that hit it**: a
+  project that commits generated artifacts and CI-checks them for drift
+  will see a diff, and the new bytes are the correct arithmetic.
+- **`Clock.on_date` reported the previous day for pre-1970 instants.**
+  `Clock.floor_div` subtracted one from the quotient for a negative
+  dividend with a remainder — the right correction when `/` truncates
+  toward zero, which Jade's doesn't; it already floors, so it floored
+  twice. `at_time` was unaffected, so `to_iso(-1)` read
+  `"1969-12-30T23:59:59Z"`: the time right, the date a day out. Exact
+  midnight was always correct, because the double correction only applies
+  when there is a remainder.
+- **Anonymous records decoded from the same shape now compare equal.**
+  The derived decoder built its constructor from a bare `Data.define`,
+  which mints a fresh class each time the decoder is built, so
+  `{ x: 1, y: "a" }` decoded twice compared false. It resolves through
+  the same interned registry record literals already used. Note this does
+  not unify decoded records with *literals* in the general case —
+  literals hoist to a per-module constant, so two modules with the same
+  shape still get different classes.
+- **The tuple decoders no longer build their constructor with
+  `Method#curry`.** A curried `Method` built once and called on every
+  decode corrupts the heap under GC compaction — a near-null "try to mark
+  T_NONE object" crash after enough rows. It is the pattern the
+  constructor-curry regression spec exists to prevent; that spec reads
+  generated code, so the stdlib's own copy was invisible to it.
+- **`Result.on_error` can change the error type**, as its signature has always
+  claimed. The `Ok` arm handed back the input rather than rebuilding it, which
+  unified the outgoing error type with the incoming one, so
+  `Result(Int, String) -> Result(Int, Int)` did not compile. Recovering into a
+  different error type is the reason the function takes `e -> Result(a, f)`.
+- **A signature no longer renders two distinct type variables as one.** Hover
+  reported `Maybe.map : (Maybe(a), (a) -> a) -> Maybe(a)` — a function unable
+  to change the element type, which is a different function from the one that
+  exists. Variables are identified by an id but print as a name, and nothing
+  upstream keeps names distinct; rendering now re-letters a clash instead of
+  emitting the same name twice. Declared names are kept where they don't
+  collide, so annotated signatures read as written.
+
+- **`docs/stdlib.md` named nine functions that don't exist.** `Char.is_digit`,
+  `is_alpha`, `is_alpha_num`, `is_upper`, `is_lower` were renamed to `digit?`,
+  `alpha?`, `alpha_numeric?`, `upper?`, `lower?` when predicates took the `?`
+  suffix and the doc never followed; `String.contains` is `contains?`,
+  `Dict.member` is `member?`, `Tuple.map_first` / `map_second` were never
+  implemented, and `Decode.at` doesn't exist (`Decode.index` does). Every
+  qualified name in `docs/stdlib.md` and `AGENTS.md` now checks out against the
+  registry.
+
+## [0.4.0]
+
+### Changed
+
+- **Port arguments are encoded on the way out**, the mirror of the return value
+  being decoded on the way back. A port declared `Instant, Int -> Task(Instant,
+  Never)` used to hand Ruby a live `Jade::Clock::Instant` while demanding an ISO
+  string back; both sides are now the wire form. **Every argument type needs an
+  `Encodable` instance** — a port taking one without it is a compile error
+  (``Port `shift` cannot encode argument 1 (`Shape`): no Encodable instance``)
+  rather than a value leaking Jade's internals into Ruby. Declare the argument
+  as `Decode.Value` to opt out and pass it untouched. A port whose arguments are
+  primitives is unaffected; one taking a struct, a `Clock`/`Calendar`/`Decimal`
+  type, or a type variable now receives encoded data, so its Ruby side needs
+  updating.
+
+### Added
+
+- `Show`, an interface rendering a value the way Jade writes it: `show(B(2))`
+  is `"B(2)"`, `show(Point(3, 4))` is `"Point { x: 3, y: 4 }"`, a list shows
+  through its elements. Instances ship for the primitives and derive for
+  unions, structs and records — including a variant that mixes a type
+  parameter with a concrete type. A function shows as `<function>` rather than
+  refusing. `Never` has an instance too, so an annotated `Result(a, Never)` —
+  what a port-free task returns — is showable; it raises rather than printing
+  a plausible string, since it has no values to render.
+- `Debug.log(label, value)` prints `label: value` to stderr and returns the
+  value untouched, so it drops into a pipeline without changing it.
+- `Encodable` and `Decodable` derive for tuples, `Dict` and `Set`, from their
+  elements' instances — the same way `List` and `Maybe` already did. The
+  combinators (`Encode.tuple`, `Decode.dict`, …) existed all along; nothing
+  resolved them, so a `(String, Int)` port argument or a `Task(Dict(k, v), e)`
+  arm was rejected for want of an instance. A tuple crosses as a positional
+  array, a dict as `[key, value]` pairs, a set as an array that drops
+  duplicates on the way back. Adds the two functions the set instances needed,
+  `Encode.set` and `Decode.set`.
+- `Encodable` and `Decodable` instances for `Decode.Value`, both the identity,
+  plus the `Decode.value` and `Encode.value` functions behind them. `Value` is
+  the un-decoded value, and it opted out of conversion only as a whole arm or
+  argument: `List(Value)`, `Maybe(Value)`, and a struct with a `Value` field
+  had no instance to derive from and were rejected at the boundary.
+- A parse error inside a `uses`, `interface`, or `implements` block where the
+  entries are separated by newlines instead of commas says so, instead of only
+  reporting the next entry as an unexpected token.
+
+### Fixed
+
+- `Eq` derives for a union whose variants carry concrete types. `B(1) == B(1)`
+  over `type Box = B(Int) | Empty` took the compiler down with a
+  `NoMatchingPatternError`; `Just(1) == Just(1)` only worked because `Maybe`'s
+  payload is a type parameter. Variants mixing a parameter with a concrete
+  type derive too.
+- Diagnostic source excerpts are sliced by byte offset. Spans and line starts
+  are the lexer's byte offsets, but the excerpt was cut and measured in
+  characters, so one multi-byte glyph anywhere earlier in the file shifted every
+  later excerpt and its caret — `def notify_channel(…)` printed as
+  `f notify_channel(…)`.
+- Exhaustiveness checking no longer collapses when the scrutinee is a tuple.
+  `case (a, b)` over two `Maybe`s reported `Missing cases: (_, _)` with all four
+  arms present, and the `else` that silenced it hid genuinely missing cases from
+  then on. Two bugs: a tuple's element types were replaced with fresh type
+  variables, and specializing on a constructor dropped the types of every column
+  after it. A constructor the first column never mentions is now answered from
+  the rows that would have covered it, which is also what keeps a recursive type
+  from expanding forever — the recursion guard that used to do that job is gone,
+  and with it the false "exhaustive" verdicts it caused on any second column.
+- The missing-constructor diagnostic tells you which `exposing` list is missing
+  the `(..)`. When the defining module already exposes `Route(..)` and it's the
+  importer's `import Routes exposing (Route)` that brought in the type alone, it
+  no longer sends you to the wrong file. It also fires for a variant whose name
+  differs from its type's (`Home` of `Route`), which previously got no hint.
+
 ## [0.3.1]
 
 ### Fixed
@@ -115,7 +328,8 @@ Initial release.
 - `jade` CLI dispatcher: `fmt`, `lsp`, `q`.
 - Language server and headless query interface for editor/agent tooling.
 
-[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.3.1...HEAD
+[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/agustinrhcp/jade/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/agustinrhcp/jade/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/agustinrhcp/jade/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/agustinrhcp/jade/compare/v0.1.1...v0.2.0

data/README.md

@@ -148,7 +148,7 @@ at compile time, no annotation needed. You can define your own, with
 implementations dispatched by type:
 
 ```jade
-module Shows exposing (describe)
+module Labels exposing (person_label)
 
 struct Person = {
   name: String,
@@ -156,18 +156,18 @@ struct Person = {
 }
 
 
-interface Show(a) with
-  show : a -> String
+interface Labelled(a) with
+  label : a -> String
 end
 
 
-implements Show(Person) with
-  show: (p) -> { p.name ++ " (" ++ String.from_int(p.age) ++ ")" }
+implements Labelled(Person) with
+  label: (p) -> { p.name ++ " (" ++ String.from_int(p.age) ++ ")" }
 end
 
 
-def describe(p: Person) -> String
-  show(p)
+def person_label(p: Person) -> String
+  label(p)
 end
 ```
 
@@ -333,7 +333,9 @@ Worst case: you wrote Ruby with a nicer authoring layer for a while.
 
 There's a language server — type errors, inferred types, and jump-to-definition
 in any editor that speaks LSP. For tools that don't, `jade q` answers the same
-questions as one-shot JSON (hover, definition, references, symbols).
+questions as one-shot JSON (hover, definition, references, symbols), `jade q
+api` reports the stdlib's signatures, and `jade check` type-checks a file and
+prints what's wrong.
 
 In our experience coding agents like Claude Code and Cursor handle Jade well:
 the syntax is close enough to the ML family (Elm, OCaml, Haskell) that models
@@ -346,9 +348,11 @@ for us so far.
 A single `jade` binary fronts the toolchain:
 
 ```
+jade check [file...]      # type-check; exits 1 on errors, generates nothing
 jade fmt [-i|-c] [file]   # format .jd source (stdin or file)
 jade lsp                  # language server over stdio (hover, defn, refs, diagnostics)
 jade q hover FILE:L:C     # headless JSON queries — hover/symbols/defn/refs
+jade q api List.fold      # stdlib signatures, read from the registry
 ```
 
 `jade fmt` is deterministic and idempotent; wire it into your editor or a
@@ -357,8 +361,9 @@ pre-commit hook.
 ## Standard library
 
 `Basics`, `String`, `Char`, `List`, `Dict`, `Set`, `Tuple`, `Maybe`, `Result`,
-`Task`, `Decode`, `Encode`, `Bytes`, `Calendar`, `Clock`, `Decimal`. Stdlib operations
-compile inline rather than through a runtime dispatch layer.
+`Task`, `Decode`, `Encode`, `Bytes`, `Calendar`, `Clock`, `Decimal`, `Show`,
+`Debug`. Stdlib operations compile inline rather than through a runtime
+dispatch layer.
 
 ## Docs
 
@@ -374,8 +379,8 @@ compile inline rather than through a runtime dispatch layer.
 
 Early and experimental — being tried out on small projects.
 
-**In progress:** `Comparable` / `Show` derivation for user types, partial
-record types in signatures, a stable REPL.
+**In progress:** `Comparable` derivation for user types, partial record types
+in signatures, a stable REPL.
 
 **Not great for:** throwaway scripts, libraries you ship to other Ruby
 projects (they'd inherit the dependency), and performance-critical hot paths