jade-lang 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e4552bf1ca2e4a8214da4dff385246f52151d7b827d3305171639694e4ee4a5
-  data.tar.gz: 9a1bbdcb02eafa6a62b37547a6ba8b2b73784908c0ceb5e8e7486691244f1da7
+  metadata.gz: 15e51e91117f799dec4acda81faa5fd62f8f75190570cebc69d69e0c588481cb
+  data.tar.gz: 1bd08d32f23d5b0e3f184f04d72aa1b44fd391bea3536ff2630ea93b1480f179
 SHA512:
-  metadata.gz: 6a3a989e2ddea89618c0abb919e032953b244dbc8217617d009e7f55f62ba43b01bd9c033a4e0984770bfc3f81c75fc40f2f07aa99d43b3e164e13186b196bef
-  data.tar.gz: bc7bfa312c8f42e70359ec9a9fdb6a67cfbcee12c8376195c7c4a36f626cd3840c3d6a0fdcd634147a61aa204776e9a0c99aeed587b92ab98d3d60dc4ace0f26
+  metadata.gz: fcb1ae0703cdcd8c29c618b7aaf36d90c1f5b7eb4b95a1ee5f6dd6e4fd81d172977b3786442c1f1635e0ade323ff94a82fd95ee331a23f53459581966d08a346
+  data.tar.gz: 4208a71d7852def7334d49142dc7aea3b4f6344941a9e66cbc9d544b8f877d84680c7206518d61aaeb35d6ecd8eec9261f7a1adf5d64fe6346020e775fadaaae

data/CHANGELOG.md

@@ -6,6 +6,17 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.2.0]
+
+### Added
+
+- `Decimal` stdlib module: exact base-10 decimals (`coefficient * 10 ^
+  exponent`) for money and rates without `Float` rounding. Opaque type built
+  with `of(coeff, exp)`, `scaled(unscaled, scale)`, or `parse("0.0825")`;
+  arithmetic via `Numeric` (`+` `-` `*` `/`) plus `div` (scaled, half-up),
+  `round`, `to_i`, `to_float`, `coefficient`, `exponent`. Decodes/encodes to a
+  `<mantissa>e<exponent>` JSON string. (Supersedes jade-sql's `Sql.Decimal`.)
+
 ## [0.1.1]
 
 ### Fixed
@@ -31,6 +42,7 @@ 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.1.1...HEAD
+[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/agustinrhcp/jade/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/agustinrhcp/jade/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/agustinrhcp/jade/releases/tag/v0.1.0

data/README.md

@@ -357,7 +357,7 @@ pre-commit hook.
 ## Standard library
 
 `Basics`, `String`, `Char`, `List`, `Dict`, `Set`, `Tuple`, `Maybe`, `Result`,
-`Task`, `Decode`, `Encode`, `Bytes`, `Calendar`, `Clock`. Stdlib operations
+`Task`, `Decode`, `Encode`, `Bytes`, `Calendar`, `Clock`, `Decimal`. Stdlib operations
 compile inline rather than through a runtime dispatch layer.
 
 ## Docs

data/lib/jade/stdlib/decimal.rb

@@ -0,0 +1,236 @@
+require 'jade/stdlib/compiled'
+
+module Jade
+  module Stdlib
+    module Decimal
+      extend self
+      extend Compiled
+
+      def uri
+        'decimal.jd'
+      end
+
+      def imports
+        [Basics, Maybe, String, Tuple, Decode, Encode]
+      end
+
+      def default_imports
+        []
+      end
+
+      def code
+        <<~JADE
+          module Decimal exposing (
+            Decimal,
+            coefficient,
+            div,
+            exponent,
+            of,
+            parse,
+            round,
+            scaled,
+            to_float,
+            to_i,
+          )
+
+          import Maybe
+          import Decode exposing (Decodable, Decoder)
+          import Encode exposing (Encodable)
+
+
+          # An exact base-10 decimal: value = coefficient * 10 ^ exponent.
+          # Lossless for money and rates — no Float rounding. Opaque: build one
+          # with `of`, `scaled`, or `parse`.
+          type Decimal = Decimal(Int, Int)
+
+
+          # value = coefficient * 10 ^ exponent. of(825, -6) = 0.000825.
+          def of(coeff: Int, exp: Int) -> Decimal
+            Decimal(coeff, exp)
+          end
+
+
+          # `scale` digits after the decimal point. scaled(825, 4) = 0.0825.
+          def scaled(unscaled: Int, scale: Int) -> Decimal
+            of(unscaled, 0 - scale)
+          end
+
+
+          def coefficient(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 (Java HALF_UP /
+          # Ruby BigDecimal default: 2.5 -> 3, -2.5 -> -3). 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 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. Values with fewer places
+          # than `scale` 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
+
+
+          # Parse a decimal string: "0.0825", "-12.5", "42". Returns Nothing on
+          # anything that isn't a plain base-10 numeral.
+          def parse(s: String) -> Maybe(Decimal)
+            case String.split(s, ".")
+            in [whole] then
+              String.to_int(whole) |> Maybe.map((m) -> { of(m, 0) })
+
+            in [whole, frac] then
+              String.to_int(whole ++ frac)
+                |> Maybe.map((m) -> { of(m, 0 - String.length(frac)) })
+
+            else Nothing
+            end
+          end
+
+
+          def to_wire(d: Decimal) -> String
+            Decimal(m, e) = d
+
+            String.from_int(m) ++ "e" ++ String.from_int(e)
+          end
+
+
+          def from_wire(s: String) -> Decoder(Decimal)
+            case String.split(s, "e")
+            in [m, e]
+              case (String.to_int(m), String.to_int(e))
+              in (Just(mi), Just(ei)) then Decode.succeed(of(mi, ei))
+              else Decode.fail("invalid decimal: " ++ s)
+              end
+
+            else Decode.fail("invalid decimal: " ++ s)
+            end
+          end
+
+
+          implements Decodable(Decimal) with
+            decoder: -> { Decode.string |> Decode.and_then(from_wire) }
+          end
+
+
+          implements Encodable(Decimal) with
+            encoder: (d) -> { Encode.string(to_wire(d)) }
+          end
+        JADE
+      end
+    end
+  end
+end

data/lib/jade/stdlib.rb

@@ -15,6 +15,7 @@ require 'jade/stdlib/encode'
 require 'jade/stdlib/bytes'
 require 'jade/stdlib/calendar'
 require 'jade/stdlib/clock'
+require 'jade/stdlib/decimal'
 
 module Jade
   module Stdlib
@@ -26,7 +27,7 @@ module Jade
       Bytes
       Dict Set
     ].freeze
-    COMPILED = %w[Maybe Result Decode.Params Calendar Clock].freeze
+    COMPILED = %w[Maybe Result Decode.Params Calendar Clock Decimal].freeze
     TOPLEVELS = (INTRINSICS + COMPILED).map { it.split('.', 2).first }.to_set.freeze
     STDLIBS = [
       Stdlib::Basics, Stdlib::Maybe, Stdlib::Tuple, Stdlib::List, Stdlib::Char,
@@ -34,13 +35,13 @@ module Jade
       Stdlib::Dict, Stdlib::Set,
       Stdlib::Decode, Stdlib::Decode::Params, Stdlib::Encode,
       Stdlib::Bytes,
-      Stdlib::Calendar, Stdlib::Clock,
+      Stdlib::Calendar, Stdlib::Clock, Stdlib::Decimal,
     ]
     # Loaded into the registry but not auto-imported into user modules.
     EXTENSIONS = [
       Stdlib::Dict, Stdlib::Set,
       Stdlib::Decode, Stdlib::Decode::Params, Stdlib::Encode,
-      Stdlib::Calendar, Stdlib::Clock,
+      Stdlib::Calendar, Stdlib::Clock, Stdlib::Decimal,
     ]
 
     def load(registry)

data/lib/jade/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Agustin Cornu
@@ -308,6 +308,7 @@ files:
 - lib/jade/stdlib/char.rb
 - lib/jade/stdlib/clock.rb
 - lib/jade/stdlib/compiled.rb
+- lib/jade/stdlib/decimal.rb
 - lib/jade/stdlib/decode.rb
 - lib/jade/stdlib/decode/params.rb
 - lib/jade/stdlib/dict.rb