jade-lang 0.1.0

data/lib/jade/stdlib/clock.rb

@@ -0,0 +1,342 @@
+require 'jade/stdlib/compiled'
+
+module Jade
+  module Stdlib
+    module Clock
+      extend self
+      extend Compiled
+
+      def uri
+        'clock.jd'
+      end
+
+      def imports
+        [Basics, Maybe, Result, Task, String, Tuple, Decode, Encode, Calendar]
+      end
+
+      def default_imports
+        []
+      end
+
+      def code
+        <<~JADE
+          module Clock exposing (
+            Duration,
+            Instant,
+            add,
+            at_time,
+            days,
+            diff,
+            epoch,
+            from_iso,
+            hours,
+            in_days,
+            in_hours,
+            in_millis,
+            in_minutes,
+            in_seconds,
+            millis,
+            minutes,
+            now,
+            on_date,
+            parts,
+            seconds,
+            to_iso,
+          )
+
+          import Decode exposing (Decodable, Decoder, Value)
+          import Encode exposing (Encodable)
+
+
+          type Instant = Instant(Int)
+
+
+          type Duration = Duration(Int)
+
+
+          uses Jade::Clock::Runtime with
+            now_raw : Task({ millis: Int }, Never)
+          end
+
+
+          def now -> Task(Instant, Never)
+            raw <- now_raw()
+            Task.succeed(Instant(raw.millis))
+          end
+
+
+          def epoch -> Instant
+            Instant(0)
+          end
+
+
+          def millis(n: Int) -> Duration
+            Duration(n)
+          end
+
+
+          def in_millis(d: Duration) -> Int
+            Duration(n) = d
+            n
+          end
+
+
+          def seconds(n: Int) -> Duration
+            Duration(n * 1000)
+          end
+
+
+          def in_seconds(d: Duration) -> Int
+            in_millis(d) / 1000
+          end
+
+
+          def minutes(n: Int) -> Duration
+            Duration(n * 60000)
+          end
+
+
+          def in_minutes(d: Duration) -> Int
+            in_millis(d) / 60000
+          end
+
+
+          def hours(n: Int) -> Duration
+            Duration(n * 3600000)
+          end
+
+
+          def in_hours(d: Duration) -> Int
+            in_millis(d) / 3600000
+          end
+
+
+          def days(n: Int) -> Duration
+            Duration(n * 86400000)
+          end
+
+
+          def in_days(d: Duration) -> Int
+            in_millis(d) / 86400000
+          end
+
+
+          def parts(d: Duration) -> {
+            days: Int,
+            hours: Int,
+            minutes: Int,
+            seconds: Int,
+            millis: Int,
+          }
+            ms = in_millis(d)
+            {
+              days: ms / 86400000,
+              hours: mod(ms, 86400000) / 3600000,
+              minutes: mod(ms, 3600000) / 60000,
+              seconds: mod(ms, 60000) / 1000,
+              millis: mod(ms, 1000),
+            }
+          end
+
+
+          def add(i: Instant, d: Duration) -> Instant
+            Instant(ms) = i
+            Instant(ms + in_millis(d))
+          end
+
+
+          def diff(a: Instant, b: Instant) -> Duration
+            Instant(ams) = a
+            Instant(bms) = b
+            Duration(bms - ams)
+          end
+
+
+          def on_date(i: Instant) -> Calendar.Date
+            Instant(ms) = i
+            Calendar.from_rata_die(floor_div(ms, 86400000) + 719163)
+          end
+
+
+          def at_time(i: Instant) -> {
+            hour: Int,
+            minute: Int,
+            second: Int,
+            millisecond: Int,
+          }
+            Instant(ms) = i
+            day_ms = mod(ms, 86400000)
+            {
+              hour: day_ms / 3600000,
+              minute: mod(day_ms, 3600000) / 60000,
+              second: mod(day_ms, 60000) / 1000,
+              millisecond: mod(day_ms, 1000),
+            }
+          end
+
+
+          def floor_div(a: Int, b: Int) -> Int
+            q = a / b
+            a < 0 && mod(a, b) != 0 ? q - 1 : q
+          end
+
+
+          def to_iso(i: Instant) -> String
+            d = on_date(i)
+            tod = at_time(i)
+            Calendar.to_iso_string(d)
+              ++ "T"
+              ++ pad2(tod.hour)
+              ++ ":"
+              ++ pad2(tod.minute)
+              ++ ":"
+              ++ pad2(tod.second)
+              ++ "Z"
+          end
+
+
+          def pad2(n: Int) -> String
+            s = String.from_int(n)
+            String.length(s) < 2 ? "0" ++ s : s
+          end
+
+
+          def from_iso(s: String) -> Result(Instant, String)
+            case split_dt(s)
+            in Just((date_part, time_part))
+              case (Calendar.from_iso_string(date_part), parse_time(time_part))
+              in (Ok(d), Ok((h, m, sec, sub))) then Ok(combine(d, h, m, sec, sub))
+              else Err("invalid timestamp: " ++ s)
+              end
+            in Nothing then Err("invalid timestamp: " ++ s)
+            end
+          end
+
+
+          def split_dt(s: String) -> Maybe((String, String))
+            case String.split(s, "T")
+            in [d, t] then Just((d, t))
+            else
+              case String.split(s, " ")
+              in [d, t] then Just((d, t))
+              else Nothing
+              end
+            end
+          end
+
+
+          def parse_time(s: String) -> Result((Int, Int, Int, Int), String)
+            case String.split(strip_z(s), ":")
+            in [h, m, sec_part]
+              case (String.to_int(h), String.to_int(m), parse_seconds(sec_part))
+              in (Just(hi), Just(mi), Just((si, ms))) then Ok((hi, mi, si, ms))
+              else Err("bad time: " ++ s)
+              end
+            else Err("bad time: " ++ s)
+            end
+          end
+
+
+          def strip_z(s: String) -> String
+            case String.split(s, "Z")
+            in [head, _] then head
+            in [head] then head
+            else s
+            end
+          end
+
+
+          def parse_seconds(s: String) -> Maybe((Int, Int))
+            case String.split(s, ".")
+            in [secs]
+              case String.to_int(secs)
+              in Just(si) then Just((si, 0))
+              in Nothing then Nothing
+              end
+            in [secs, frac]
+              case (String.to_int(secs), String.to_int(frac))
+              in (Just(si), Just(fi))
+                Just((si, frac_to_millis(fi, String.length(frac))))
+              else Nothing
+              end
+            else Nothing
+            end
+          end
+
+
+          def frac_to_millis(n: Int, digits: Int) -> Int
+            digits == 3 ? n : digits < 3 ? n * pow10(3 - digits) : n / pow10(digits - 3)
+          end
+
+
+          def pow10(n: Int) -> Int
+            n <= 0 ? 1 : 10 * pow10(n - 1)
+          end
+
+
+          def combine(
+            d: Calendar.Date,
+            hour: Int,
+            minute: Int,
+            second: Int,
+            sub_ms: Int,
+          ) -> Instant
+            day_count = Calendar.to_rata_die(d) - 719163
+            Instant(
+              day_count * 86400000 + hour * 3600000 + minute * 60000 + second * 1000 + sub_ms,
+            )
+          end
+
+
+          def compare_instant(a: Instant, b: Instant) -> Ordering
+            Instant(ams) = a
+            Instant(bms) = b
+            compare(ams, bms)
+          end
+
+
+          def instant_eq(a: Instant, b: Instant) -> Bool
+            Instant(ams) = a
+            Instant(bms) = b
+            ams == bms
+          end
+
+
+          implements Comparable(Instant) with
+            compare: compare_instant
+          end
+
+
+          implements Eq(Instant) with
+            (==): instant_eq
+          end
+
+
+          def parse_instant(s: String) -> Decoder(Instant)
+            Decode.from_result(from_iso(s))
+          end
+
+
+          implements Decodable(Instant) with
+            decoder: -> { Decode.string |> Decode.and_then(parse_instant) }
+          end
+
+
+          implements Encodable(Instant) with
+            encoder: (i) -> { Encode.string(to_iso(i)) }
+          end
+
+
+          implements Decodable(Duration) with
+            decoder: -> { Decode.map(Decode.int, Duration) }
+          end
+
+
+          implements Encodable(Duration) with
+            encoder: (d) -> { Encode.int(in_millis(d)) }
+          end
+          JADE
+      end
+    end
+  end
+end

data/lib/jade/stdlib/compiled.rb

@@ -0,0 +1,48 @@
+module Jade
+  module Stdlib
+    module Compiled
+      def generate_entry(registry)
+        return @entry if @entry
+
+        source = Source[uri, code]
+
+        source
+          .then { Lexer.tokenize(it) }
+          .then { Parsing.parse(it, source:) } => Ok([ast, _comments])
+
+        Registry
+          .entry(source.to_module_name)
+          .with(ast:)
+          .with(source:)
+          .then { resolve_imports(it) }
+          .then do
+            Frontend
+              .run_entry(it, registry.add_module(it))
+              .map { Codegen.generate_entry(it, registry.add_module(it)) }
+          end => Ok(entry)
+
+          @entry = entry
+      end
+
+      def entry
+        @entry ||= fail("entry not generated yet.")
+      end
+
+      # Compiled modules declare interfaces and impls in their Jade source,
+      # not via the Intrinsics DSL. The lookup that scans `imports` for
+      # Interface symbols (intrinsics.rb#implementation) never finds anything
+      # here, but exposing an empty list keeps the call site uniform.
+      def symbols
+        []
+      end
+
+      def resolve_imports(entry)
+        imports
+          .reduce(entry) do |acc, stdlib|
+            ImportEntry[stdlib.entry.name, stdlib.entry.name, stdlib.default_imports, stdlib.entry.exposes]
+              .then { acc.import(it) }
+          end
+      end
+    end
+  end
+end

data/lib/jade/stdlib/decode/params.rb

@@ -0,0 +1,154 @@
+require 'jade/stdlib/compiled'
+
+module Jade
+  module Stdlib
+    module Decode
+      module Params
+        extend self
+        extend Compiled
+
+        def uri
+          'decode/params.jd'
+        end
+
+        def imports
+          [Basics, Maybe, List, Tuple, Stdlib::String, Stdlib::Decode]
+        end
+
+        def default_imports
+          []
+        end
+
+        def code
+          <<~JADE
+            module Decode.Params exposing (
+              Params(..),
+              accept,
+              bool,
+              collect,
+              default,
+              empty,
+              float,
+              int,
+              nested,
+              string,
+            )
+
+            import Decode exposing (Decoder)
+
+
+            type Params(a) = Params(List((String, Decoder(a))), List((String, a)))
+
+
+            def empty -> Params(a)
+              Params([], [])
+            end
+
+
+            def accept(p: Params(a), key: String, decoder: Decoder(a)) -> Params(a)
+              case p
+              in Params(accs, defs) then Params(accs ++ [(key, decoder)], defs)
+              end
+            end
+
+
+            def default(p: Params(a), key: String, value: a) -> Params(a)
+              case p
+              in Params(accs, defs) then Params(accs, defs ++ [(key, value)])
+              end
+            end
+
+
+            def string(p: Params(a), key: String, ctor: String -> a) -> Params(a)
+              accept(p, key, Decode.map(Decode.string, ctor))
+            end
+
+
+            def int(p: Params(a), key: String, ctor: Int -> a) -> Params(a)
+              accept(p, key, Decode.map(Decode.int, ctor))
+            end
+
+
+            def float(p: Params(a), key: String, ctor: Float -> a) -> Params(a)
+              accept(p, key, Decode.map(Decode.float, ctor))
+            end
+
+
+            def bool(p: Params(a), key: String, ctor: Bool -> a) -> Params(a)
+              accept(p, key, Decode.map(Decode.bool, ctor))
+            end
+
+
+            def nested(
+              p: Params(a),
+              key: String,
+              ctor: List(b) -> a,
+              sub: Params(b),
+            ) -> Params(a)
+              accept(p, key, Decode.map(collect(sub), ctor))
+            end
+
+
+            def collect(p: Params(a)) -> Decoder(List(a))
+              case p
+              in Params(accs, defs)
+                accs
+                  |> List.map((acc) -> { accept_to_decoder(defs, acc) })
+                  |> Decode.sequence
+                  |> Decode.map(filter_justs)
+              end
+            end
+
+
+            def accept_to_decoder(
+              defs: List((String, a)),
+              acc: (String, Decoder(a)),
+            ) -> Decoder(Maybe(a))
+              key = Tuple.first(acc)
+              decoder = Tuple.second(acc)
+              raw = Decode.optional_field(key, decoder)
+              case lookup_default(defs, key)
+              in Just(v) then with_default(raw, v)
+              in Nothing then raw
+              end
+            end
+
+
+            def with_default(decoder: Decoder(Maybe(a)), v: a) -> Decoder(Maybe(a))
+              Decode.map(decoder, (m) -> { maybe_or_just(m, v) })
+            end
+
+
+            def maybe_or_just(m: Maybe(a), v: a) -> Maybe(a)
+              case m
+              in Just(_) then m
+              in Nothing then Just(v)
+              end
+            end
+
+
+            def filter_justs(maybes: List(Maybe(a))) -> List(a)
+              List.and_then(maybes, maybe_to_list)
+            end
+
+
+            def maybe_to_list(m: Maybe(a)) -> List(a)
+              case m
+              in Just(x) then [x]
+              in Nothing then []
+              end
+            end
+
+
+            def lookup_default(defs: List((String, a)), key: String) -> Maybe(a)
+              case defs
+              in [] then Nothing
+              in [(k, v) | rest] then k == key ? Just(v) : lookup_default(rest, key)
+              end
+            end
+          JADE
+        end
+      end
+    end
+  end
+end