jade-lang 0.1.1 → 0.3.0

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/decode.rb

@@ -182,6 +182,24 @@ module Jade
         Jade::Decode::Decoder[Jade::Decode::Desc::Fail[msg]]
       }
 
+      # Backs derived Decodable for unions whose variants take no
+      # arguments. `names` and `values` are positionally paired.
+      function(
+        'string_enum',
+        { names: 'List(String)', values: 'List(a)' },
+        'Decoder(a)',
+      ) { |names, values|
+        table = names.zip(values).to_h
+
+        ->(s) {
+          table.key?(s) \
+            ? Jade::Decode::Decoder[Jade::Decode::Desc::Succeed[table[s]]]
+            : Jade::Decode::Decoder[Jade::Decode::Desc::Fail["expected one of #{names.join(', ')}, got #{s.inspect}"]]
+        }
+          .then { Jade::Decode::Desc::AndThen[it, Jade::Decode::Desc::Str[]] }
+          .then { Jade::Decode::Decoder[it] }
+      }
+
       function(
         'from_result',
         { r: 'Result(a, String)' },

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/type.rb

@@ -168,12 +168,15 @@ module Jade
           end
 
         interface = registry.lookup(symbol.interface)
+
+        # Keep the map the type param lands in: the return type has to see
+        # the same variable, or the constraint ends up on a variable that
+        # appears in no type and nothing can ever bind it.
+        param_type, _, local_map =
+          from_symbol_r(interface.type_param, registry, var_gen, local_map)
+
         constraint = Type
-          .constraint(
-            symbol.interface.qualified_name,
-            from_symbol_r(interface.type_param, registry, var_gen, local_map).first,
-            nil,
-          )
+          .constraint(symbol.interface.qualified_name, param_type, nil)
 
         from_symbol_r(symbol.return_type, registry, var_gen, local_map)
           .then { |(t, c, _)| [args.empty? ? t : Type.function(args, t), c + arg_cs + [constraint]] }

data/lib/jade/version.rb

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

data/lib/jade.rb

@@ -1,4 +1,5 @@
 require 'jade/version'
+require 'jade/project'
 require 'jade/did_you_mean'
 require 'jade/symbol'
 require 'jade/registry'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-06-17 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -157,6 +157,7 @@ files:
 - lib/jade/frontend/semantic_analysis/error/nested_task_port.rb
 - lib/jade/frontend/semantic_analysis/error/non_task_port.rb
 - lib/jade/frontend/semantic_analysis/error/orphan_implementation.rb
+- lib/jade/frontend/semantic_analysis/error/placeholder_not_allowed.rb
 - lib/jade/frontend/semantic_analysis/error/predicate_must_return_bool.rb
 - lib/jade/frontend/semantic_analysis/error/predicate_name_not_allowed.rb
 - lib/jade/frontend/semantic_analysis/error/shadowing_error.rb
@@ -210,6 +211,7 @@ files:
 - lib/jade/frontend/type_checking/constraints/deriving/encodable.rb
 - lib/jade/frontend/type_checking/constraints/deriving/eq.rb
 - lib/jade/frontend/type_checking/constraints/deriving/helpers.rb
+- lib/jade/frontend/type_checking/constraints/deriving/sql_mapper.rb
 - lib/jade/frontend/type_checking/definition.rb
 - lib/jade/frontend/type_checking/env.rb
 - lib/jade/frontend/type_checking/error.rb
@@ -297,6 +299,7 @@ files:
 - lib/jade/parsing/token.rb
 - lib/jade/parsing/type.rb
 - lib/jade/port.rb
+- lib/jade/project.rb
 - lib/jade/registry.rb
 - lib/jade/result.rb
 - lib/jade/runtime.rb
@@ -308,6 +311,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