jade-lang 0.1.0

data/lib/jade/registry.rb

@@ -0,0 +1,79 @@
+require 'jade/module_loader'
+require 'jade/entry'
+
+module Jade
+  Registry = Data.define(:modules, :implementations, :source_root, :dependency_graph, :overlays) do
+    def initialize(modules: {}, implementations: {}, source_root: nil, dependency_graph: nil, overlays: {})
+      super(
+        modules:,
+        implementations:,
+        source_root:,
+        dependency_graph: dependency_graph || ModuleLoader::DependencyGraph.new,
+        overlays:,
+      )
+    end
+
+    def self.entry(name)
+      Entry.empty(name)
+    end
+
+    def modules_in_topo_order
+      ModuleLoader::TopologicalSort
+        .sort(dependency_graph)
+        .map { get(it) }
+    end
+
+    def get(module_name)
+      modules.dig(module_name)
+    end
+
+    def update_module(entry)
+      fail 'cannot update entry that does not exist' unless modules[entry.name]
+
+      with(
+        modules: modules.merge(entry.name => entry),
+        implementations: implementations.merge(entry.implementations),
+      )
+    end
+
+    def add_module(entry)
+      next_registry = with(
+        modules: modules.merge(entry.name => entry),
+        implementations: implementations.merge(entry.implementations),
+      )
+
+      if entry.ast
+        ModuleLoader::DependencyResolver.resolve(entry, next_registry)
+      else
+        next_registry
+      end
+    end
+
+    def add_dependencies(entry, imports)
+      with(dependency_graph: dependency_graph.add(entry.name, imports))
+    end
+
+    def find_node_at(uri, offset)
+      modules
+        .each_value
+        .find { it.source&.uri == uri }
+        &.ast
+        &.find_at(offset)
+    end
+
+    def lookup(symbol)
+      *module_parts, name = symbol.qualified_name.split('.')
+      module_entry = module_parts.join('.').then { modules[it] }
+
+      case symbol
+      in Symbol::ValueRef
+        module_entry.values[name]
+
+      in Symbol::TypeRef
+        module_entry.types[name]
+      end
+    end
+  end
+
+  ImportEntry = Data.define(:module_name, :alias, :unqualified_symbols, :qualified_symbols)
+end

data/lib/jade/result.rb

@@ -0,0 +1,121 @@
+module Jade
+  Ok = Data.define(:ok) do
+    private :ok
+
+    def initialize(ok: nil)
+      super
+    end
+
+    def map
+      Ok.new(yield(ok))
+    end
+    alias_method :map_both, :map
+
+    def and_then
+      yield(ok)
+    end
+
+    def and_tap
+      result = yield(ok)
+      case result
+      in Ok then self
+      in Err then result
+      end
+    end
+
+    def map_error
+      self
+    end
+
+    def map2(result)
+      case result
+      in Ok(ok2) then Ok.new(yield(ok, ok2))
+      in Err(_) then result
+      end
+    end
+
+    def and_then_combine
+      result = yield(ok)
+      case result
+      in Ok(ok2) then Ok.new([*ok, ok2])
+      in Err(_) then result
+      end
+    end
+
+    def on_err(_error_type = nil)
+      self
+    end
+
+    def with_default(_default)
+      ok
+    end
+
+    def ok?
+      true
+    end
+
+    def error?
+      false
+    end
+  end
+
+  module Results
+    def self.sequence(results)
+      results.reduce(Ok[[]]) do |acc, r|
+        acc.and_then { |list| r.map { list + [it] } }
+      end
+    end
+  end
+
+  Err = Data.define(:err) do
+    private :err
+
+    def map
+      self
+    end
+
+    def and_then
+      self
+    end
+
+    def map_error
+      Err.new(yield(err))
+    end
+    alias_method :map_both, :map_error
+
+    def map2(_)
+      self
+    end
+
+    def and_tap
+      self
+    end
+
+    def and_then_combine
+      self
+    end
+
+    def on_err(error_type = nil)
+      return yield(err) unless error_type
+
+      case err
+      when error_type
+        yield(err)
+      else
+        self
+      end
+    end
+
+    def with_default(default)
+      default
+    end
+
+    def ok?
+      false
+    end
+
+    def error?
+      true
+    end
+  end
+end

data/lib/jade/runtime.rb

@@ -0,0 +1,127 @@
+require 'base64'
+
+require 'jade/interop/runtime'
+require 'jade/decode'
+require 'jade/interop/boundary'
+
+module Jade
+  module Tuple
+    Tuple2 = Data.define(:_1, :_2) do
+      def to_s = "(#{[_1, _2].map(&:to_s).join(', ')})"
+    end
+
+    Tuple3 = Data.define(:_1, :_2, :_3) do
+      def to_s = "(#{[_1, _2, _3].map(&:to_s).join(', ')})"
+    end
+
+    Tuple4 = Data.define(:_1, :_2, :_3, :_4) do
+      def to_s = "(#{[_1, _2, _3, _4].map(&:to_s).join(', ')})"
+    end
+  end
+
+  module Basics
+    GT = Data.define()
+    EQ = Data.define()
+    LT = Data.define()
+  end
+
+  # Compiled code calls `a.compare(b)`; natives ship `<=>` not `compare`.
+  # Guarded so a future Ruby or third-party `compare` wins — clobbering
+  # would silently swap semantics.
+  [Integer, Float, ::String].each do |klass|
+    next if klass.method_defined?(:compare)
+
+    klass.class_eval do
+      define_method(:compare) do |other|
+        case self <=> other
+        when -1 then Basics::LT[]
+        when 0  then Basics::EQ[]
+        when 1  then Basics::GT[]
+        end
+      end
+    end
+  end
+
+  module Bytes
+    Bytes = Data.define(:bin) do
+      def to_s = "Bytes(#{bin.bytesize})"
+      def +(other) = Bytes.new(bin + other.bin)
+    end
+  end
+
+  module Dict
+    Dict = Data.define(:hash) do
+      def to_s
+        pairs = hash.map { |k, v| "#{k}: #{v}" }.join(', ')
+        "Dict(#{pairs})"
+      end
+    end
+  end
+
+  module Set
+    Set = Data.define(:hash) do
+      def to_s = "Set(#{hash.keys.join(', ')})"
+    end
+  end
+
+  module Runtime
+    extend self
+    extend Interop::Runtime
+
+    INTRINSICS = {}
+    IMPLEMENTATIONS = {}
+    IMPL_CACHE = {}
+    RECORD_CLASSES = {}
+    @booted = false
+
+    def boot!
+      return if @booted
+      @booted = true
+
+      require "jade/stdlib/basics"
+      require "jade/stdlib/string"
+      require "jade/stdlib/list"
+      require "jade/stdlib/tuple"
+      require "jade/stdlib/task"
+      require "jade/stdlib/decode"
+      require "jade/stdlib/encode"
+      require "jade/stdlib/bytes"
+      require "jade/stdlib/dict"
+      require "jade/stdlib/set"
+    end
+
+    def intr(name)
+      boot!
+      INTRINSICS[name] || fail("Intrinsic #{name} does not exist")
+    end
+
+    def register(name, &block)
+      INTRINSICS[name] = block
+    end
+
+    # Memoized class for anonymous record literals. Without this, every
+    # `{a: 1, b: 2}` expression evaluated in a hot loop would call
+    # `Data.define(:a, :b)` and allocate a fresh anonymous class, defeating
+    # YJIT's inline cache on every subsequent property access.
+    def record(*keys)
+      RECORD_CLASSES[keys] ||= Data.define(*keys)
+    end
+
+    def register_impl(interface_name, ruby_class, functions)
+      IMPLEMENTATIONS[[interface_name, ruby_class]] = functions
+      IMPL_CACHE.clear
+    end
+
+    # Cached per [interface_name, value.class]; `register_impl` invalidates.
+    def impl_for(interface_name, value)
+      boot!
+      key = [interface_name, value.class]
+      IMPL_CACHE[key] ||= begin
+        raw = IMPLEMENTATIONS[key] || fail("No implementation of #{interface_name} for #{value.class}")
+        raw.any? { |_, v| v.is_a?(::String) } \
+          ? raw.transform_values { |v| v.is_a?(::String) ? intr(v) : v }
+          : raw
+      end
+    end
+  end
+end

data/lib/jade/source.rb

@@ -0,0 +1,62 @@
+module Jade
+  Source = Data.define(:uri, :text, :line_starts) do
+    def self.load(source_root, uri, overlays: {})
+      text = overlays[uri] || File.read(File.join(source_root, uri))
+      new(uri, text)
+    end
+
+    def self.load_from_module_name(source_root, name, overlays: {})
+      name.split('.')
+        .compact
+        .map { snake_case(it) }
+        .then { |(*rest, last)| rest + [last + '.jd'] }
+        .then { File.join(*it) }
+        .then { load(resolve_root(source_root, it, name), it, overlays:) }
+    end
+
+    def self.resolve_root(source_root, uri, name)
+      return source_root if File.exist?(File.join(source_root, uri))
+
+      candidates = Jade.extensions.select { |r| File.exist?(File.join(r, uri)) }
+
+      case candidates.size
+      when 0 then source_root
+      when 1 then candidates.first
+      else raise "Module #{name} is provided by multiple extensions: #{candidates.join(', ')}"
+      end
+    end
+
+    def initialize(uri:, text:, line_starts: calculate_line_starts(text))
+      super
+    end
+
+    def to_module_name
+      uri
+        .delete_suffix('.jd')
+        .split('/')
+        .map { Source.camelize(it) }
+        .join('.')
+    end
+
+    private
+
+    # Byte offsets — must match StringScanner's byte-positioned `pos`,
+    # which is what every AST `:range` carries. Using char positions
+    # here drifts spans by the multi-byte-char count beyond the first
+    # non-ASCII glyph in the file.
+    def calculate_line_starts(text)
+      [0] + text.b.enum_for(:scan, /\n/).map { Regexp.last_match.end(0) }
+    end
+
+    def self.camelize(str)
+      str.split('_').map { |part| part.capitalize }.join
+    end
+
+    def self.snake_case(str)
+      str
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')  # ABCXyz -> ABC_Xyz
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')      # abcXyz -> abc_Xyz
+        .downcase
+    end
+  end
+end

data/lib/jade/stdlib/basics.rb

@@ -0,0 +1,214 @@
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module Basics
+      extend Intrinsics
+
+      union :Never
+      union :Int
+      union :Float
+      union :Bool
+
+      native_type :Int,   Integer
+      native_type :Float, ::Float
+      native_type :Bool,  TrueClass, FalseClass
+
+      union :Ordering
+      variant :GT, of: :Ordering
+      variant :EQ, of: :Ordering
+      variant :LT, of: :Ordering
+
+      interface(
+        'Eq',
+        'a',
+        { '(==)' => 'a, a -> Bool' },
+      )
+
+      implementation('Eq', 'Int',   '(==)' => 'int_eq')
+      implementation('Eq', 'Float', '(==)' => 'float_eq')
+      implementation('Eq', 'Bool',  '(==)' => 'bool_eq')
+
+      interface(
+        'Comparable',
+        'a',
+        { 'compare' => 'a, a -> Ordering' },
+      )
+
+      implementation('Comparable', 'Int',   'compare' => 'int_compare')
+      implementation('Comparable', 'Float', 'compare' => 'float_compare')
+
+      interface(
+        'Numeric',
+        'a',
+        { '(+)' => 'a, a -> a', '(-)' => 'a, a -> a', '(*)' => 'a, a -> a', '(/)' => 'a, a -> a' }
+      )
+
+      implementation('Numeric', 'Int',   '(+)' => 'int_add', '(-)' => 'int_sub', '(*)' => 'int_mul', '(/)' => 'int_div')
+      implementation('Numeric', 'Float', '(+)' => 'float_add', '(-)' => 'float_sub', '(*)' => 'float_mul', '(/)' => 'float_div')
+
+      interface(
+        'Appendable',
+        'a',
+        { '(++)' => 'a, a -> a' },
+      )
+
+      interface(
+        'Mappable',
+        'f',
+        { 'map' => 'f(a), (a -> b) -> f(b)' },
+      )
+
+      interface(
+        'Chainable',
+        'f',
+        { 'and_then' => 'f(a), (a -> f(b)) -> f(b)' },
+      )
+
+      function(
+        '(!=)',
+        { one: 'a', other: 'a' },
+        'Bool',
+        constraints: [['Basics.Eq', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['one', 'other'],
+          body: [:!, [:call, [:impl_arg, 0, '(==)'], [[:var, 'one'], [:var, 'other']]]],
+        ),
+      )
+
+      function('int_add', { a: 'Int', b: 'Int' }, 'Int')
+      function('int_sub', { a: 'Int', b: 'Int' }, 'Int')
+      function('int_mul', { a: 'Int', b: 'Int' }, 'Int')
+      function('int_div', { a: 'Int', b: 'Int' }, 'Int')
+      function('mod', { a: 'Int', b: 'Int' }, 'Int')
+
+      function('float_add', { a: 'Float', b: 'Float' }, 'Float')
+      function('float_sub', { a: 'Float', b: 'Float' }, 'Float')
+      function('float_mul', { a: 'Float', b: 'Float' }, 'Float')
+      function('float_div', { a: 'Float', b: 'Float' }, 'Float')
+
+      function(:to_float, { n: 'Int' }, 'Float')
+      function(:floor, { n: 'Float' }, 'Int')
+      function(:ceiling, { n: 'Float' }, 'Int')
+      function(:round, { n: 'Float' }, 'Int')
+      function(:truncate, { n: 'Float' }, 'Int')
+
+      function('identity', { a: 'a' }, 'a')
+      function('always', { x: 'a' }, 'b -> a')
+      function('not', { a: 'Bool' }, 'Bool')
+
+      function(
+        '(<)',
+        { a: 'a', b: 'a' },
+        'Bool',
+        constraints: [['Basics.Comparable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['a', 'b'],
+          body: [:case,
+            [:call, [:impl_arg, 0, 'compare'], [[:var, 'a'], [:var, 'b']]],
+            [
+              [[:constructor, 'Basics.LT', []], [true]],
+              [[:_], [false]],
+            ],
+          ],
+        ),
+      )
+
+      function(
+        '(>)',
+        { a: 'a', b: 'a' },
+        'Bool',
+        constraints: [['Basics.Comparable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['a', 'b'],
+          body: [:case,
+            [:call, [:impl_arg, 0, 'compare'], [[:var, 'a'], [:var, 'b']]],
+            [
+              [[:constructor, 'Basics.GT', []], [true]],
+              [[:_], [false]],
+            ],
+          ],
+        ),
+      )
+
+      function(
+        '(<=)',
+        { a: 'a', b: 'a' },
+        'Bool',
+        constraints: [['Basics.Comparable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['a', 'b'],
+          body: [:case,
+            [:call, [:impl_arg, 0, 'compare'], [[:var, 'a'], [:var, 'b']]],
+            [
+              [[:constructor, 'Basics.GT', []], [false]],
+              [[:_], [true]],
+            ],
+          ],
+        ),
+      )
+
+      function(
+        '(>=)',
+        { a: 'a', b: 'a' },
+        'Bool',
+        constraints: [['Basics.Comparable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['a', 'b'],
+          body: [:case,
+            [:call, [:impl_arg, 0, 'compare'], [[:var, 'a'], [:var, 'b']]],
+            [
+              [[:constructor, 'Basics.LT', []], [false]],
+              [[:_], [true]],
+            ],
+          ],
+        ),
+      )
+
+      function(
+        'min',
+        { a: 'a', b: 'a' },
+        'a',
+        constraints: [['Basics.Comparable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['a', 'b'],
+          body: [:case,
+            [:call, [:impl_arg, 0, 'compare'], [[:var, 'a'], [:var, 'b']]],
+            [
+              [[:constructor, 'Basics.GT', []], [[:var, 'b']]],
+              [[:_], [[:var, 'a']]],
+            ],
+          ],
+        ),
+      )
+
+      function(
+        'max',
+        { a: 'a', b: 'a' },
+        'a',
+        constraints: [['Basics.Comparable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['a', 'b'],
+          body: [:case,
+            [:call, [:impl_arg, 0, 'compare'], [[:var, 'a'], [:var, 'b']]],
+            [
+              [[:constructor, 'Basics.LT', []], [[:var, 'b']]],
+              [[:_], [[:var, 'a']]],
+            ],
+          ],
+        ),
+      )
+
+      function('(&&)', { a: 'Bool', b: 'Bool' }, 'Bool')
+      function('(||)', { a: 'Bool', b: 'Bool' }, 'Bool')
+
+      default_importing :*
+
+      function('int_eq', { one: 'Int', other: 'Int' }, 'Bool')
+      function('float_eq', { one: 'Float', other: 'Float' }, 'Bool')
+      function('bool_eq', { one: 'Bool', other: 'Bool' }, 'Bool')
+      function('int_compare', { a: 'Int', b: 'Int' }, 'Ordering')
+      function('float_compare', { a: 'Float', b: 'Float' }, 'Ordering')
+    end
+  end
+end

data/lib/jade/stdlib/bytes.rb

@@ -0,0 +1,70 @@
+require 'base64'
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module Bytes
+      extend Intrinsics
+
+      import Basics
+      import Maybe
+      import List
+
+      union :Bytes
+
+      native_type :Bytes, Jade::Bytes::Bytes
+
+      implementation('Eq',         'Bytes', '(==)' => 'bytes_eq')
+      implementation('Appendable', 'Bytes', '(++)' => 'bytes_append')
+
+      function(:empty, {}, 'Bytes')
+      function(:width, { bytes: 'Bytes' }, 'Int')
+
+      function(
+        :from_list,
+        { ints: 'List(Int)' },
+        'Maybe(Bytes)',
+      ) do |ints|
+        if ints.all? { it.is_a?(Integer) && it.between?(0, 255) }
+          Jade::Maybe::Just[Jade::Bytes::Bytes[ints.pack('C*')]]
+        else
+          Jade::Maybe::Nothing[]
+        end
+      end
+
+      function(:to_list, { bytes: 'Bytes' }, 'List(Int)')
+      function(:from_string, { s: 'String' }, 'Bytes')
+      function(:to_string, { bytes: 'Bytes' }, 'Maybe(String)')
+
+      function(
+        :from_hex,
+        { s: 'String' },
+        'Maybe(Bytes)',
+      ) do |s|
+        if s.length.even? && s.match?(/\A[0-9a-fA-F]*\z/)
+          Jade::Maybe::Just[Jade::Bytes::Bytes[[s].pack('H*')]]
+        else
+          Jade::Maybe::Nothing[]
+        end
+      end
+
+      function(:to_hex, { bytes: 'Bytes' }, 'String')
+      function(:to_base64_url, { bytes: 'Bytes' }, 'String')
+
+      function(
+        :from_base64_url,
+        { s: 'String' },
+        'Maybe(Bytes)',
+      ) do |s|
+        Jade::Maybe::Just[Jade::Bytes::Bytes[::Base64.urlsafe_decode64(s)]]
+      rescue ::ArgumentError
+        Jade::Maybe::Nothing[]
+      end
+
+      default_importing('Bytes')
+
+      function('bytes_eq', { a: 'Bytes', b: 'Bytes' }, 'Bool')
+      function('bytes_append', { a: 'Bytes', b: 'Bytes' }, 'Bytes')
+    end
+  end
+end