jade-sql 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5986c28a9014fcf2a656282a1c34d0303a2c6e37d10dbb5b1eb8591c5a1ebaf
-  data.tar.gz: 378c771dc40c70f3567727e4475b8383f28a723be48beff82dc5f5c25ea6e8f5
+  metadata.gz: 203373e2a0789908e800cda5e81acee5883edb436205ec016f281549451218cd
+  data.tar.gz: 3338e7d2e8132fdf4ed4de0e8b53658d8a2cce64ee8f13394cc7dca53413906c
 SHA512:
-  metadata.gz: c09395f48662acf1c6ae08189f700229d03a23dbcfe170725f681094cb76357665dc18775c441eb7961f6afcdc841bf035e4fbe1da4d43e8bfe8d3e23f997af1
-  data.tar.gz: 52fe13eb1ed8ec5c43db442d85923e972b35c26e2be57939e75b8d0f0bb16817ab45404abd3db9ff640b7609e0d4491e199278691c9e07253be97f1bd298a5ed
+  metadata.gz: f5e68d85a8d74169946d1368aa91ef46fe99c05a6b3250a5f11b44cc0ee13f75c66b3e1a3bbe59febb9c63ebee3f32ea419396444dffb699fa239a211f943821
+  data.tar.gz: 4ad41bf4b0b780a78b599bba48bd90f7b14a35dfd2564a38b8153bbeec8dd8a7abd77a08d6c43db9888df49096429702aa31d2a6ceebd606446023d729988dd7

data/docs/building.md

@@ -28,22 +28,18 @@ bundle exec rake jade:schema \
 ```
 
 Type map: `bigint`/`integer`/`smallint` → `Int`, `numeric`/`decimal` →
-`Decimal` (from `Sql.Decimal`), `double precision`/`real` → `Float`,
-`varchar`/`text`/`char` → `String`, `boolean` → `Bool`, `jsonb`/`json` →
-`Decode.Value`, `date` → `Calendar.Date`, `timestamp` → `Clock.Instant`,
-`uuid` → `Uuid` (from `Sql.Uuid`). Unknown types fail loudly with the
-table+column name.
-
-`numeric`/`decimal` map to `Sql.Decimal` — an exact base-10 value
-(`mantissa * 10^exponent`), never `Float`, so no precision is lost. Genuine
-floating-point columns (`double precision`/`real`) map to `Float`. `bytea`
-isn't mapped yet, though jade's `Bytes` is the natural target.
-
-`Sql.Decimal` implements `Numeric`, so `+`/`-`/`*` work and stay exact.
-Mirroring `BigDecimal`, `/` can't represent a repeating quotient, so it
-rounds half-up to a default scale (use `div(a, b, scale)` for explicit
-control, `round(d, scale)` to round); division by zero raises. `to_i`
-truncates toward zero and `to_float` converts (lossily, on purpose).
+`Decimal` (jade's stdlib exact decimal), `double precision`/`real` →
+`Float`, `varchar`/`text`/`char` → `String`, `boolean` → `Bool`,
+`jsonb`/`json` → `Decode.Value`, `date` → `Calendar.Date`, `timestamp` →
+`Clock.Instant`, `uuid` → `Uuid` (from `Sql.Uuid`). Unknown types fail
+loudly with the table+column name.
+
+`numeric`/`decimal` map to the stdlib `Decimal` — an exact base-10 value
+(`coefficient * 10^exponent`), never `Float`, so no precision is lost.
+Genuine floating-point columns (`double precision`/`real`) map to `Float`.
+`bytea` isn't mapped yet, though jade's `Bytes` is the natural target. See
+jade-lang's `Decimal` for the full API (`of`/`scaled`/`parse`, arithmetic,
+`round`, `to_i`/`to_float`).
 
 For each table, the generator emits:
 
@@ -109,6 +105,23 @@ Notes:
   fills one slot in declared order.
 - `to_sql(q)` returns `(String, List(Value))`.
 
+### Predicates
+
+`eq`, `gt`, `gte`, `lt`, `lte` compare two `Expr(a)` and yield `Expr(Bool)`;
+`is_null` / `is_not_null` take one; `and` joins two; `in_` matches a list.
+`now` is the DB clock (`now()`), for time comparisons:
+
+```jade
+import Sql exposing (column, gt, now, to_expr)
+
+a.starts_at |> gte(to_expr(cutoff))          # a.starts_at >= ?
+column("s", "expires_at") |> gt(now)         # s.expires_at > now()
+```
+
+`now` is `Expr(Instant)` — the *DB* transaction clock, not the app clock.
+It's the right tool for `WHERE` filters; for `created_at`/`updated_at` use
+`Sql.Mutation.timestamped` (below), which uses the app clock like Rails.
+
 ### Sorting and grouping
 
 `order(q, e)` appends an ASC term, `order_desc(q, e)` a DESC term, and
@@ -443,38 +456,25 @@ sparse_changes
 
 ### Timestamps
 
-`Mutation.insert`/`update` emit only the columns you explicitly set —
-they don't auto-fill `created_at` / `updated_at`. Two ways to handle
-NOT NULL timestamp columns:
-
-**1. DB-side defaults (recommended).** Let the schema own timestamp
-policy:
-
-```sql
-ALTER TABLE patients ALTER COLUMN created_at SET DEFAULT now();
-ALTER TABLE patients ALTER COLUMN updated_at SET DEFAULT now();
-```
-
-The mutation builder stays a thin SQL emitter; the DB fills in
-defaults for any column the INSERT didn't list.
-
-**2. Explicit injection in app code.** When you want Jade to carry the
-timestamp values (Rails-style), tack assignments onto the list before
-the call:
+`insert`/`update` emit only the columns you set — they don't auto-fill
+`created_at` / `updated_at`. Opt in per-write with `timestamped`, which
+works like ActiveRecord: `created_at` + `updated_at` on insert, `updated_at`
+only on update.
 
 ```jade
-def with_timestamps(assigns: List(Assignment), now: Instant)
-    -> List(Assignment)
-  assigns ++ [assign("created_at", now), assign("updated_at", now)]
-end
+import Sql.Mutation exposing (insert, timestamped, update)
 
-def create(p: Patient, now: Instant) -> Mutation(Int, PatientsCols)
-  encode_patient(p)
-    |> with_timestamps(now)
-    |> insert(_, patients)
-end
+new_patient |> insert(patients) |> timestamped |> execute   -- both set
+patient     |> update(patients) |> timestamped |> execute   -- updated_at only
+new_import  |> insert(patients) |> execute                  -- no timestamps
 ```
 
+It's opt-in on purpose — backfills, imports, and `touch: false`-style writes
+just omit it (and can set the columns explicitly). The value is the **app
+clock** at execute time (set in Ruby, the same clock Rails uses, so
+`travel_to`/Timecop freeze it), and `created_at` == `updated_at` on an
+insert. No schema changes and no DB-side `DEFAULT` needed.
+
 ### UUIDs
 
 `Sql.Uuid` defines an opaque `Uuid` type plus generation/parse helpers.

data/docs/running.md

@@ -45,6 +45,9 @@ at the boundary.
 - `DbError(String)` — AR `StatementInvalid` message
 - `NotFound` — `fetch_one` with zero rows
 - `NotUnique` — `fetch_one` with more than one row
+- `Conflict(String)` — a write hit a unique index; the `String` is the
+  violated constraint name (e.g. `users_email_key`), so you can route it to a
+  field error instead of string-matching a `DbError` message
 
 A decode mismatch (column type doesn't match the field type) raises on
 the Ruby side rather than becoming a recoverable error — schema drift is

data/lib/jade-sql/bin/generate_schema.rb

@@ -53,7 +53,7 @@ module JadeSql
       "Clock.Instant" => "import Clock",
       "Decode.Value"  => "import Decode",
       "Uuid"          => "import Sql.Uuid exposing(Uuid)",
-      "Decimal"       => "import Sql.Decimal exposing(Decimal)",
+      "Decimal"       => "import Decimal exposing(Decimal)",
     }.freeze
 
     # Column names that collide with Jade keywords get a trailing underscore

data/lib/jade-sql/runtime.rb

@@ -12,7 +12,9 @@ module JadeSql
     task :port_execute_count do |t, pair|
       sql, params = pair._1, pair._2
       conn = ::ActiveRecord::Base.connection
-      t.ok(conn.exec_update(adapt_sql(sql, conn), "Jade", typed_params(params, conn)))
+      t.ok(conn.exec_update(adapt_sql(fill_now(sql), conn), "Jade", typed_params(params, conn)))
+    rescue ::ActiveRecord::RecordNotUnique => e
+      t.err(JadeSql::SqlErrors.conflict(constraint_name(e)))
     rescue ::ActiveRecord::StatementInvalid => e
       t.err(JadeSql::SqlErrors.db_error(e.message))
     end
@@ -20,12 +22,14 @@ module JadeSql
     task :port_execute_one do |t, pair|
       sql, params = pair._1, pair._2
       conn = ::ActiveRecord::Base.connection
-      rows = conn.exec_query(adapt_sql(sql, conn), "Jade", typed_params(params, conn)).to_a
+      rows = conn.exec_query(adapt_sql(fill_now(sql), conn), "Jade", typed_params(params, conn)).to_a
       case rows.length
       when 0 then t.err(JadeSql::SqlErrors.not_found)
       when 1 then t.ok(coerce_row(rows.first))
       else        t.err(JadeSql::SqlErrors.not_unique)
       end
+    rescue ::ActiveRecord::RecordNotUnique => e
+      t.err(JadeSql::SqlErrors.conflict(constraint_name(e)))
     rescue ::ActiveRecord::StatementInvalid => e
       t.err(JadeSql::SqlErrors.db_error(e.message))
     end
@@ -33,8 +37,10 @@ module JadeSql
     task :port_execute_many do |t, pair|
       sql, params = pair._1, pair._2
       conn = ::ActiveRecord::Base.connection
-      rows = conn.exec_query(adapt_sql(sql, conn), "Jade", typed_params(params, conn)).to_a
+      rows = conn.exec_query(adapt_sql(fill_now(sql), conn), "Jade", typed_params(params, conn)).to_a
       t.ok(rows.map { |row| coerce_row(row) })
+    rescue ::ActiveRecord::RecordNotUnique => e
+      t.err(JadeSql::SqlErrors.conflict(constraint_name(e)))
     rescue ::ActiveRecord::StatementInvalid => e
       t.err(JadeSql::SqlErrors.db_error(e.message))
     end
@@ -76,8 +82,8 @@ module JadeSql
     # other List(a) column.
     #
     # numeric/decimal columns come back as ::BigDecimal; the schema generator
-    # maps them to Sql.Decimal, whose decoder reads the exact
-    # "<mantissa>e<exponent>" wire form. Float would lose precision, so don't.
+    # maps them to jade's stdlib Decimal, whose decoder reads the exact
+    # "<coefficient>e<exponent>" wire form. Float would lose precision, so don't.
     def self.coerce_row(row)
       row.transform_values { |v| coerce_value(v) }
     end
@@ -93,19 +99,19 @@ module JadeSql
       end
     end
 
-    # ::BigDecimal -> "<mantissa>e<exponent>" with value = mantissa * 10^exp,
+    # ::BigDecimal -> "<coefficient>e<exponent>" with value = coeff * 10^exp,
     # exactly (BigDecimal#split gives sign, significant digits, and a base-10
-    # exponent). Matches the wire form Sql.Decimal's decoder parses.
+    # exponent). Matches the wire form jade's stdlib Decimal decoder parses.
     #
-    # 'NaN'/'Infinity'::numeric are legal Postgres values that Sql.Decimal
-    # can't represent; fail loudly rather than silently decode them as 0.
+    # 'NaN'/'Infinity'::numeric are legal Postgres values that Decimal can't
+    # represent; fail loudly rather than silently decode them as 0.
     def self.decimal_wire(v)
       raise ArgumentError, "non-finite numeric: #{v}" unless v.finite?
 
       sign, digits, _base, exp = v.split
-      mantissa = sign * digits.to_i
+      coefficient = sign * digits.to_i
       exponent = exp - digits.length
-      "#{mantissa}e#{exponent}"
+      "#{coefficient}e#{exponent}"
     end
 
     # PG arrays render as `{}`, `{a,b,c}`, `{"a,b","c"}`, with NULL as
@@ -160,6 +166,32 @@ module JadeSql
       raw == "NULL" ? nil : raw
     end
 
+    # The constraint/index name behind a RecordNotUnique, so callers can route
+    # by which unique index was violated. PG reports it in the error's
+    # diagnostics; other adapters (or a missing name) fall back to "".
+    def self.constraint_name(error)
+      cause = error.cause
+      return "" unless defined?(::PG::Result) && cause.respond_to?(:result) && cause.result
+
+      cause.result.error_field(::PG::Result::PG_DIAG_CONSTRAINT_NAME) || ""
+    rescue StandardError
+      ""
+    end
+
+    # Sql.Mutation.timestamped emits "$JADE_SQL_NOW$" where created_at /
+    # updated_at go. Swap it for one UTC timestamp literal per statement,
+    # computed here — the app clock, so it moves with travel_to/Timecop
+    # (unlike DB now()). The token lives in SQL we generate, never in a
+    # bound value, so it can't collide with user data.
+    NOW_TOKEN = "$JADE_SQL_NOW$"
+
+    def self.fill_now(sql)
+      return sql unless sql.include?(NOW_TOKEN)
+
+      stamp = "'#{::Time.now.utc.strftime('%Y-%m-%d %H:%M:%S.%6N+00')}'"
+      sql.gsub(NOW_TOKEN) { stamp }
+    end
+
     # Sql renders `?` placeholders uniformly. AR's exec_query/exec_update
     # path on the PG adapter expects `$1, $2, …` — there is no `?`-to-`$n`
     # rewrite at that layer. SQLite and MySQL accept `?` directly, so this

data/lib/jade-sql/sql/mutation.jd

@@ -5,13 +5,14 @@ module Sql.Mutation exposing (
   insert,
   insert_all,
   returning,
+  timestamped,
   to_sql,
   update,
   update_all,
 )
 
 import Sql exposing (
-  Assignment,
+  Assignment(..),
   Expr(..),
   Renderable,
   Selector(..),
@@ -132,6 +133,40 @@ def returning(m: Mutation(a, c), build: c -> Q(Selector(b))) -> Mutation(b, c)
 end
 
 
+# Opt-in ActiveRecord-style timestamps: fills created_at + updated_at on
+# insert and updated_at on update, with the app clock at execute time.
+# The "$JADE_SQL_NOW$" token carries no param; the runtime swaps it for a
+# single UTC timestamp literal per statement (so created_at == updated_at).
+# A plain `insert`/`update` without this stays timestamp-free.
+def timestamped(m: Mutation(ret, c)) -> Mutation(ret, c)
+  case m.kind
+  in InsertK then with_rows(m, List.map(m.rows, append_insert_stamps))
+  in UpdateK then with_rows(m, List.map(m.rows, append_update_stamps))
+  in DeleteK then m
+  end
+end
+
+
+def append_insert_stamps(row: List(Assignment)) -> List(Assignment)
+  row ++ [now_assignment("created_at"), now_assignment("updated_at")]
+end
+
+
+def append_update_stamps(row: List(Assignment)) -> List(Assignment)
+  row ++ [now_assignment("updated_at")]
+end
+
+
+def now_assignment(col: String) -> Assignment
+  Assignment(col, "$JADE_SQL_NOW$", [])
+end
+
+
+def with_rows(m: Mutation(ret, c), rows: List(List(Assignment))) -> Mutation(ret, c)
+  Mutation(m.kind, m.table, m.cols, rows, m.wheres, m.returning_selector)
+end
+
+
 def pk_predicate(cols: List(String), values: List(Value)) -> Expr(Bool)
   sql = cols
     |> List.map((col) -> { col ++ " = ?" })

data/lib/jade-sql/sql.jd

@@ -32,13 +32,18 @@ module Sql exposing (
   fetch_many_raw,
   fetch_one,
   fetch_one_raw,
+  gt,
+  gte,
   in_,
   is_not_null,
   is_null,
   jsonb_contains,
   jsonb_path_exists,
+  lt,
+  lte,
   maybe_columns,
   neg,
+  now,
   nullable,
   pk_values,
   render,
@@ -52,6 +57,7 @@ module Sql exposing (
 
 import Encode exposing (Encodable, encode)
 import Decode exposing (Decodable, Decoder, Value)
+import Clock exposing (Instant)
 
 
 struct Expr(a) = {
@@ -139,11 +145,38 @@ def to_expr(value: a) -> Expr(a)
 end
 
 
+# The DB clock (Postgres `now()`), for `where(col |> gt(now))`-style
+# comparisons. This is the transaction timestamp, not the app clock.
+def now -> Expr(Instant)
+  Expr("now()", [])
+end
+
+
 def eq(left: Expr(a), right: Expr(a)) -> Expr(Bool)
   Expr(left.sql ++ " = " ++ right.sql, left.params ++ right.params)
 end
 
 
+def gt(left: Expr(a), right: Expr(a)) -> Expr(Bool)
+  Expr(left.sql ++ " > " ++ right.sql, left.params ++ right.params)
+end
+
+
+def gte(left: Expr(a), right: Expr(a)) -> Expr(Bool)
+  Expr(left.sql ++ " >= " ++ right.sql, left.params ++ right.params)
+end
+
+
+def lt(left: Expr(a), right: Expr(a)) -> Expr(Bool)
+  Expr(left.sql ++ " < " ++ right.sql, left.params ++ right.params)
+end
+
+
+def lte(left: Expr(a), right: Expr(a)) -> Expr(Bool)
+  Expr(left.sql ++ " <= " ++ right.sql, left.params ++ right.params)
+end
+
+
 def is_null(e: Expr(a)) -> Expr(Bool)
   Expr(e.sql ++ " IS NULL", e.params)
 end
@@ -320,10 +353,14 @@ def aliased(t: Table(c, m), alias_: String) -> Table(c, m)
 end
 
 
+# `NotUnique` is a read-side failure (fetch_one saw more than one row).
+# `Conflict` is a write-side unique-index violation, carrying the violated
+# constraint name so callers route it to a field error without string-matching.
 type SqlError
   = DbError(String)
   | NotFound
   | NotUnique
+  | Conflict(String)
 
 
 implements Encodable(SqlError) with
@@ -336,6 +373,7 @@ def encode_sql_error(e: SqlError) -> Value
   in DbError(msg) then Encode.variant("DbError", [Encode.string(msg)])
   in NotFound then Encode.variant("NotFound", [])
   in NotUnique then Encode.variant("NotUnique", [])
+  in Conflict(name) then Encode.variant("Conflict", [Encode.string(name)])
   end
 end
 
@@ -350,6 +388,7 @@ def sql_error_decoder -> Decoder(SqlError)
     |> Decode.variant("DbError", db_error_decoder)
     |> Decode.variant("NotFound", Decode.succeed(NotFound))
     |> Decode.variant("NotUnique", Decode.succeed(NotUnique))
+    |> Decode.variant("Conflict", conflict_decoder)
 end
 
 
@@ -358,6 +397,11 @@ def db_error_decoder -> Decoder(SqlError)
 end
 
 
+def conflict_decoder -> Decoder(SqlError)
+  Decode.index(1, Decode.string) |> Decode.map(Conflict)
+end
+
+
 uses JadeSql::Runtime with
   port_execute_count : (String, List(Value)) -> Task(Int, SqlError),
   port_execute_one : (String, List(Value)) -> Task(a, SqlError),

data/lib/jade-sql/version.rb

@@ -1,3 +1,3 @@
 module JadeSql
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
 end

data/lib/jade-sql.rb

@@ -14,9 +14,10 @@ module JadeSql
     NOT_FOUND  = ["NotFound"].freeze
     NOT_UNIQUE = ["NotUnique"].freeze
 
-    def self.db_error(msg) = ["DbError", msg]
-    def self.not_found     = NOT_FOUND
-    def self.not_unique    = NOT_UNIQUE
+    def self.db_error(msg)  = ["DbError", msg]
+    def self.not_found      = NOT_FOUND
+    def self.not_unique     = NOT_UNIQUE
+    def self.conflict(name) = ["Conflict", name]
   end
 end
 
@@ -26,11 +27,13 @@ module Sql
     class DbError   < Error; end
     class NotFound  < Error; end
     class NotUnique < Error; end
+    class Conflict  < Error; end
 
     BY_TAG = {
       "DbError"   => DbError,
       "NotFound"  => NotFound,
       "NotUnique" => NotUnique,
+      "Conflict"  => Conflict,
     }.freeze
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-sql
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - agustin
 bindir: exe
 cert_chain: []
-date: 2026-06-15 00:00:00.000000000 Z
+date: 2026-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jade-lang
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
 description: Query and mutation builders, schema generation from db/structure.sql,
   and an ActiveRecord-backed runtime for the Jade language. Renders typed queries
   to (String, List(Value)) and decodes rows into Jade structs.
@@ -42,7 +42,6 @@ files:
 - lib/jade-sql/bin/generate_schema.rb
 - lib/jade-sql/runtime.rb
 - lib/jade-sql/sql.jd
-- lib/jade-sql/sql/decimal.jd
 - lib/jade-sql/sql/loader.jd
 - lib/jade-sql/sql/mutation.jd
 - lib/jade-sql/sql/query.jd

data/lib/jade-sql/sql/decimal.jd

@@ -1,193 +0,0 @@
-module Sql.Decimal exposing (
-  Decimal,
-  decimal,
-  div,
-  exponent,
-  mantissa,
-  parse,
-  round,
-  to_float,
-  to_i,
-)
-
-import Decode exposing (Decodable, Decoder)
-import Encode exposing (Encodable)
-
-
-# An exact base-10 decimal: value = mantissa * 10 ^ exponent. Lossless for
-# Postgres numeric/decimal — no Float rounding. The wire form is
-# "<mantissa>e<exponent>" (e.g. "175e-3"), which Postgres casts to numeric
-# exactly and which decodes back without parsing a decimal point.
-type Decimal = Decimal(Int, Int)
-
-
-def decimal(m: Int, e: Int) -> Decimal
-  Decimal(m, e)
-end
-
-
-def mantissa(d: Decimal) -> Int
-  Decimal(m, _) = d
-
-  m
-end
-
-
-def exponent(d: Decimal) -> Int
-  Decimal(_, e) = d
-
-  e
-end
-
-
-def pow10(n: Int) -> Int
-  n <= 0 ? 1 : 10 * pow10(n - 1)
-end
-
-
-def abs(x: Int) -> Int
-  x < 0 ? 0 - x : x
-end
-
-
-# Integer division, rounding ties half away from zero — i.e. Java's HALF_UP
-# and Ruby BigDecimal's default mode (2.5 -> 3, -2.5 -> -3). Rounds the
-# magnitude, then re-applies the sign. A zero `den` raises through Int `/`.
-def round_div(num: Int, den: Int) -> Int
-  negative = not ((num < 0) == (den < 0))
-  n = abs(num)
-  d = abs(den)
-  q = n / d
-  r = n - q * d
-  rounded = (2 * r) >= d ? q + 1 : q
-
-  negative ? 0 - rounded : rounded
-end
-
-
-def trunc_div(num: Int, den: Int) -> Int
-  q = abs(num) / abs(den)
-
-  num < 0 ? 0 - q : q
-end
-
-
-# `+` `-` `*` are exact. `+`/`-` line the operands up on the smaller exponent
-# first; `*` adds exponents.
-def add(a: Decimal, b: Decimal) -> Decimal
-  Decimal(ma, ea) = a
-  Decimal(mb, eb) = b
-  e = ea < eb ? ea : eb
-
-  Decimal((ma * pow10(ea - e)) + (mb * pow10(eb - e)), e)
-end
-
-
-def sub(a: Decimal, b: Decimal) -> Decimal
-  Decimal(ma, ea) = a
-  Decimal(mb, eb) = b
-  e = ea < eb ? ea : eb
-
-  Decimal((ma * pow10(ea - e)) - (mb * pow10(eb - e)), e)
-end
-
-
-def mul(a: Decimal, b: Decimal) -> Decimal
-  Decimal(ma, ea) = a
-  Decimal(mb, eb) = b
-
-  Decimal(ma * mb, ea + eb)
-end
-
-
-# a / b rounded half-up to `scale` decimal places — like Java's
-# BigDecimal.divide(divisor, scale, HALF_UP). Division by zero raises.
-def div(a: Decimal, b: Decimal, scale: Int) -> Decimal
-  Decimal(ma, ea) = a
-  Decimal(mb, eb) = b
-  k = (ea - eb) + scale
-  num = k >= 0 ? ma * pow10(k) : ma
-  den = k >= 0 ? mb : mb * pow10(0 - k)
-
-  Decimal(round_div(num, den), 0 - scale)
-end
-
-
-# The Numeric `/`: like Ruby's BigDecimal `/`, it can't be exact for a
-# repeating quotient (1/3), so it rounds half-up to a generous default scale.
-def divide(a: Decimal, b: Decimal) -> Decimal
-  div(a, b, 32)
-end
-
-
-implements Numeric(Decimal) with
-  (+): add,
-  (-): sub,
-  (*): mul,
-  (/): divide
-end
-
-
-# Round to `scale` decimal places, half-up. Fewer places than the value
-# already has are left untouched.
-def round(d: Decimal, scale: Int) -> Decimal
-  Decimal(m, e) = d
-  shift = e + scale
-
-  shift >= 0 ? d : Decimal(round_div(m, pow10(0 - shift)), 0 - scale)
-end
-
-
-# Truncates toward zero (drops the fractional part).
-def to_i(d: Decimal) -> Int
-  Decimal(m, e) = d
-
-  e >= 0 ? m * pow10(e) : trunc_div(m, pow10(0 - e))
-end
-
-
-def to_float(d: Decimal) -> Float
-  Decimal(m, e) = d
-
-  e >= 0
-    ? Basics.to_float(m * pow10(e))
-    : Basics.to_float(m) / Basics.to_float(pow10(0 - e))
-end
-
-
-def to_wire(d: Decimal) -> String
-  Decimal(m, e) = d
-
-  String.from_int(m) ++ "e" ++ String.from_int(e)
-end
-
-
-def parse(s: String) -> Maybe(Decimal)
-  case String.split(s, "e")
-  in [m, e]
-    String.to_int(m)
-      |> Maybe.and_then((mi) -> {
-        String.to_int(e) |> Maybe.map((ei) -> { Decimal(mi, ei) })
-      })
-
-  else Nothing
-  end
-end
-
-
-def decimal_decoder(s: String) -> Decoder(Decimal)
-  case parse(s)
-  in Just(d) then Decode.succeed(d)
-  in Nothing then Decode.fail("invalid decimal: " ++ s)
-  end
-end
-
-
-implements Decodable(Decimal) with
-  decoder: -> { Decode.string |> Decode.and_then(decimal_decoder) }
-end
-
-
-implements Encodable(Decimal) with
-  encoder: (d) -> { Encode.string(to_wire(d)) }
-end