jade-lang 0.1.0

data/lib/jade/stdlib/intrinsics.rb

@@ -0,0 +1,280 @@
+require 'jade/runtime'
+require 'jade/symbol'
+require 'jade/codegen/inlines'
+
+module Jade
+  module Stdlib
+    module Intrinsics
+      def generate_entry(registry)
+        @entry = entry
+          .then { load_env(it, registry) }
+      end
+
+      def variant(name, of:, args: [])
+        parent = @symbols
+          &.find { it.is_a?(Symbol::Union) && it.name == of.to_s }
+
+        union_ref = Symbol.type_ref(module_name, of.to_s)
+        parsed_args = args.map { Symbol.parse(it) }
+
+        variant_sym = Symbol::Variant.new(
+          module_name:,
+          name:        name.to_s,
+          args:        parsed_args,
+          union:       union_ref,
+          decl_span:   nil,
+        )
+
+        constructor_sym = Symbol::Constructor.new(
+          module_name:,
+          name:        name.to_s,
+          args:        parsed_args,
+          parent:      union_ref,
+          decl_span:   nil,
+        )
+
+        store(variant_sym)
+        store(constructor_sym)
+
+        if parent
+          parent
+            .with(variants: parent.variants + [variant_sym.to_ref])
+            .then { @symbols[@symbols.index(parent)] = it }
+        end
+      end
+
+      def union(name, *type_params, constructor: false)
+        union_symbol = Symbol
+          .union(name.to_s, type_params.map { Symbol.var(it, nil) }, [], nil)
+          .with(module_name:)
+          .tap { store(it) }
+
+        constructor_symbol = if constructor
+          Symbol.constructor(
+            name.to_s,
+            type_params.map { Symbol.var(it, nil) },
+            union_symbol,
+            nil,
+          )
+            .with(module_name:)
+            .then { store(it) }
+        end
+      end
+
+      def function(name, params, ret, constraints: [], body: nil, private: false, &block)
+        qualified_fn_name = "#{module_name}.#{name}"
+
+        codegen = body || "Jade::Runtime.intr('#{qualified_fn_name}')"
+        impl = runtime_impl(qualified_fn_name, params.size, block, body)
+
+        Symbol
+          .stdlib_function(
+            name.to_s,
+            params.transform_values { Symbol.parse(it) },
+            Symbol.parse(ret),
+            codegen,
+            constraints:,
+          )
+          .with(module_name:)
+          .tap { store(it) unless private }
+          .tap { Runtime.register(qualified_fn_name, &impl) }
+      end
+
+      # Approach A: the inline template is the single source of truth for a
+      # function's behaviour. A hand-written block always wins. With no block
+      # and a `body:` codegen override the function is codegen/dictionary-only
+      # (e.g. derived comparisons) and has no runtime entry. Otherwise the
+      # runtime proc is synthesised from the same template codegen emits, so the
+      # compiled and interpreted paths can't drift — and the absence of both a
+      # block and an inline is a definition error, not a lazy runtime surprise.
+      def runtime_impl(qualified_fn_name, arity, block, body)
+        case [block, body]
+        in [Proc => block, _] then block
+        in [nil, nil]
+          derive_runtime(qualified_fn_name, arity) ||
+            fail("#{qualified_fn_name}: no runtime block and no inline to derive from")
+        else nil
+        end
+      end
+
+      # Evaluated at the top level — the same constant-resolution context the
+      # template lands in when codegen splices it into compiled output — so a
+      # bare `String` means `::String`, not `Jade::Stdlib::String`. Constants
+      # resolve at call time, so there's no stdlib load-order constraint.
+      def derive_runtime(qualified_fn_name, arity)
+        Codegen::Inlines.for(qualified_fn_name).then do |template|
+          next nil unless template
+
+          args = Array.new(arity) { "a#{it}" }
+          eval("->(#{args.join(', ')}) { #{template.call(*args)} }", TOPLEVEL_BINDING)
+        end
+      end
+
+      def interface(name, type_param, functions, default: {})
+        functions
+          .map { |k, v| Symbol.parse(v).then { to_interface_function(name, k, it) }.with(module_name:) }
+          .then { Symbol.interface(name, Symbol.parse(type_param), it, default, nil) }
+          .with(module_name:)
+          .then { store(it); it.functions.each { |fn| store(fn) } }
+      end
+
+      # Declares that a Jade type is backed by one or more native Ruby classes.
+      # This auto-registers runtime dispatch for every implementation declared
+      # after this call, so there's no need for manual Runtime.register_impl calls.
+      #
+      # Future direction: literals should eventually be wrapped in Jade's own
+      # Data.define types (e.g. Int[value: 42]) and only unwrapped at interop
+      # boundaries. That would make native_type unnecessary — implementation
+      # declarations would cover both compile-time and runtime dispatch on their
+      # own. It also opens up richer type definitions like:
+      #   Int   = InternalInt | Overflow
+      #   Float = InternalFloat | NaN | Infinity | NegInfinity
+      # See Char for a preview of this direction: it's a distinct type from
+      # String even though it's still backed by a Ruby String at runtime.
+      def native_type(jade_type_name, *ruby_classes)
+        @native_types ||= {}
+        @native_types[jade_type_name.to_s] = ruby_classes
+      end
+
+      def implementation(interface_name, type, functions)
+        interface = imports
+          .map(&:symbols)
+          .then { [symbols, *it] }
+          .flatten
+          .find { it.is_a?(Symbol::Interface) && it.name == interface_name }
+
+        interface_ref = interface ? interface.to_ref : interface_to_ref(interface_name)
+        default = interface ? interface.default : {}
+        type_ref = impl_type_ref(type)
+
+        Symbol
+          .implementation(
+            interface_ref,
+            type_ref,
+            [],
+            [],
+            functions
+              .transform_values { Symbol.value_ref(module_name, it) }
+              .merge(default),
+            [],
+            nil,
+          )
+          .then { store(it) }
+
+        if (ruby_classes = @native_types&.[](type))
+          qualified_iface = "#{interface_to_ref(interface_name).module_name}.#{interface_name}"
+          qualified_fns   = functions.transform_values { "#{module_name}.#{it}" }
+          ruby_classes.each { Runtime.register_impl(qualified_iface, it, qualified_fns) }
+        end
+      end
+
+      # Accepts both bare/qualified names ('Int', 'Basics.Int') and full type
+      # expressions with vars ('Maybe(a)', 'Result(a, e)'). The impl record
+      # stores only the constructor ref (matching the forward-declaration
+      # convention at frontend/forward_declaration/implementation.rb:44).
+      def impl_type_ref(type)
+        Symbol.parse(type) => Symbol::TypeApplication(constructor:)
+        constructor
+      end
+
+      def symbols
+        @symbols || []
+      end
+
+      def entry
+        @entry || symbols
+          .reduce(Registry.entry(module_name)) do |acc, sym|
+            acc.define(sym)
+          end
+          .with(exposes:)
+          .then { resolve_imports(it) }
+      end
+
+      def import(module_name)
+        @imports = imports + [module_name]
+      end
+
+      def imports
+        @imports || []
+      end
+
+      def default_importing(imports)
+        @default_imports = if imports == :*
+          exposes
+        else
+          exposes.select { imports.include? it.name }
+        end
+      end
+
+      def default_imports
+        @default_imports || {}
+      end
+
+      def default_implementation(params:, body:)
+        Symbol::StdlibImplementation[params, body]
+      end
+
+      private
+
+      def exposes
+        @symbols
+          .reject { it.is_a?(Symbol::Implementation) }
+          .map { it.to_ref }
+      end
+
+      def resolve_imports(entry)
+        # TODO: This is the same code from stdlib that auto imports stuff.
+        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
+
+      def store(symbol)
+        @symbols ||= []
+        @symbols.concat << symbol
+      end
+
+      def module_name
+        "#{self.name.split('::').last}"
+      end
+
+      def load_env(entry, registry)
+        Frontend::TypeChecking::Loader
+          .load(entry, registry.add_module(entry))
+          .then { entry.with(env: it) }
+      end
+
+      def interface_to_ref(interface)
+        case interface
+        in 'Eq' | 'Comparable' | 'Appendable' | 'Mappable' | 'Chainable' | 'Numeric'
+          'Basics'
+
+        in 'Decodable'
+          'Decode'
+
+        in 'Encodable'
+          'Encode'
+        end
+          .then { Symbol.type_ref(it, interface.to_s) }
+      end
+
+      def to_interface_function(interface_name, fn_name, fn)
+        params, return_type =
+          case fn
+          in Symbol::FunctionType then [fn.params, fn.return_type]
+          else [[], fn]
+          end
+
+        Symbol.interface_function(
+          fn_name,
+          interface_to_ref(interface_name),
+          params,
+          return_type,
+          nil,
+        )
+      end
+    end
+  end
+end

data/lib/jade/stdlib/list.rb

@@ -0,0 +1,214 @@
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module List
+      extend Intrinsics
+
+      import Maybe
+      import Tuple
+
+      union :List, 'a'
+
+      function(:singleton, { element: 'a' }, 'List(a)')
+      function(:repeat, { element: 'a', times: 'Int' }, 'List(a)')
+      function(:range, { begin_: 'Int', end_: 'Int' }, 'List(a)')
+      function(:"empty?", { list: 'List(a)' }, 'Bool')
+      function(:head, { list: 'List(a)' }, 'Maybe(a)')
+      function(:tail, { list: 'List(a)' }, 'List(a)')
+      function(:length, { list: 'List(a)' }, 'Int')
+      function(:reverse, { list: 'List(a)' }, 'List(a)')
+
+      # Transform
+
+      function(:map, { list: 'List(a)', fn: 'a -> b' }, 'List(b)')
+      function(:and_then, { list: 'List(a)', fn: 'a -> List(b)' }, 'List(b)')
+      function(:indexed_map, { list: 'List(a)', fn: 'Int, a -> b' }, 'List(b)')
+      function(:fold, { list: 'List(a)', initial: 'b', fn: 'b, a -> b' }, 'b')
+      function(:filter, { list: 'List(a)', fn: 'a -> Bool' }, 'List(a)')
+
+      function(
+        :sort,
+        { list: 'List(a)' },
+        'List(a)',
+        constraints: [['Basics.Comparable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['list'],
+          body: [:call,
+            [:stdlib_fn, 'List.sort_with'],
+            [[:var, 'list'], [:impl_arg, 0, 'compare']],
+          ],
+        ),
+      )
+
+      function(
+        :sort_by,
+        { list: 'List(a)', key: 'a -> b' },
+        'List(a)',
+        constraints: [['Basics.Comparable', 'b']],
+        body: Symbol::DerivedFunction.new(
+          params: ['list', 'key'],
+          body: [:call,
+            [:stdlib_fn, 'List.sort_by_with'],
+            [[:var, 'list'], [:var, 'key'], [:impl_arg, 0, 'compare']],
+          ],
+        ),
+      )
+
+      function(
+        'sort_with',
+        { list: 'List(a)', cmp: 'a, a -> Ordering' },
+        'List(a)',
+        private: true,
+      ) do |list, cmp|
+        list.sort do |x, y|
+          case cmp.call(x, y)
+          in Jade::Basics::LT then -1
+          in Jade::Basics::GT then 1
+          else 0
+          end
+        end
+      end
+
+      function(
+        'sort_by_with',
+        { list: 'List(a)', key: 'a -> b', cmp: 'b, b -> Ordering' },
+        'List(a)',
+        private: true,
+      ) do |list, key, cmp|
+        list
+          .map { |x| [x, key.call(x)] }
+          .sort do |(_, ka), (_, kb)|
+            case cmp.call(ka, kb)
+            in Jade::Basics::LT then -1
+            in Jade::Basics::GT then 1
+            else 0
+            end
+          end
+          .map(&:first)
+      end
+
+      function(:"any?", { list: 'List(a)', fn: 'a -> Bool' }, 'Bool')
+      function(:"all?", { list: 'List(a)', fn: 'a -> Bool' }, 'Bool')
+      function(:find, { list: 'List(a)', fn: 'a -> Bool' }, 'Maybe(a)')
+
+      function(
+        :filter_map,
+        { list: 'List(a)', fn: 'a -> Maybe(b)' },
+        'List(b)',
+      ) do |list, fn|
+        list.flat_map do |x|
+          case fn.call(x)
+          in Jade::Maybe::Just[v] then [v]
+          else []
+          end
+        end
+      end
+
+      function(:take, { list: 'List(a)', n: 'Int' }, 'List(a)')
+      function(:drop, { list: 'List(a)', n: 'Int' }, 'List(a)')
+      function(:partition, { list: 'List(a)', fn: 'a -> Bool' }, 'Tuple2(List(a), List(a))')
+      function(:concat, { lists: 'List(List(a))' }, 'List(a)')
+
+      function(
+        :zip,
+        { left: 'List(a)', right: 'List(b)' },
+        'List(Tuple2(a, b))',
+      ) do |left, right|
+        len = [left.length, right.length].min
+        left.first(len).zip(right.first(len)).map { |(x, y)| Jade::Tuple::Tuple2[x, y] }
+      end
+
+      function(:unzip, { list: 'List(Tuple2(a, b))' }, 'Tuple2(List(a), List(b))')
+
+      function(
+        :"member?",
+        { list: 'List(a)', element: 'a' },
+        'Bool',
+        constraints: [['Basics.Eq', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['list', 'element'],
+          body: [:call,
+            [:stdlib_fn, 'List.member_with'],
+            [[:var, 'list'], [:var, 'element'], [:impl_arg, 0, '(==)']],
+          ],
+        ),
+      )
+
+      function(
+        'member_with',
+        { list: 'List(a)', element: 'a', eq: 'a, a -> Bool' },
+        'Bool',
+        private: true,
+      ) { |list, element, eq| list.any? { |x| eq.call(x, element) } }
+
+      function(
+        :maximum,
+        { list: 'List(a)' },
+        'Maybe(a)',
+        constraints: [['Basics.Comparable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['list'],
+          body: [:call,
+            [:stdlib_fn, 'List.maximum_with'],
+            [[:var, 'list'], [:impl_arg, 0, 'compare']],
+          ],
+        ),
+      )
+
+      function(
+        :minimum,
+        { list: 'List(a)' },
+        'Maybe(a)',
+        constraints: [['Basics.Comparable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['list'],
+          body: [:call,
+            [:stdlib_fn, 'List.minimum_with'],
+            [[:var, 'list'], [:impl_arg, 0, 'compare']],
+          ],
+        ),
+      )
+
+      function(
+        'maximum_with',
+        { list: 'List(a)', cmp: 'a, a -> Ordering' },
+        'Maybe(a)',
+        private: true,
+      ) do |list, cmp|
+        if list.empty?
+          Jade::Maybe::Nothing[]
+        else
+          best = list.reduce do |acc, x|
+            cmp.call(x, acc).is_a?(Jade::Basics::GT) ? x : acc
+          end
+          Jade::Maybe::Just[best]
+        end
+      end
+
+      function(
+        'minimum_with',
+        { list: 'List(a)', cmp: 'a, a -> Ordering' },
+        'Maybe(a)',
+        private: true,
+      ) do |list, cmp|
+        if list.empty?
+          Jade::Maybe::Nothing[]
+        else
+          best = list.reduce do |acc, x|
+            cmp.call(x, acc).is_a?(Jade::Basics::LT) ? x : acc
+          end
+          Jade::Maybe::Just[best]
+        end
+      end
+
+      implementation('Appendable', 'List', '(++)' => 'list_append')
+      implementation('Mappable', 'List', 'map' => 'map')
+      implementation('Chainable', 'List', 'and_then' => 'and_then')
+
+      function('list_append', { a: 'List(a)', b: 'List(a)' }, 'List(a)')
+
+      default_importing('List')
+    end
+  end
+end

data/lib/jade/stdlib/maybe.rb

@@ -0,0 +1,73 @@
+require 'jade/stdlib/compiled'
+
+module Jade
+  module Stdlib
+    module Maybe
+      extend self
+      extend Compiled
+
+      def uri
+        'maybe.jd'
+      end
+
+      def imports
+        [Basics]
+      end
+
+      def default_imports
+        [
+          Symbol.type_ref('Maybe', 'Maybe'),
+          Symbol.value_ref('Maybe', 'Just'),
+          Symbol.value_ref('Maybe', 'Nothing'),
+        ]
+      end
+
+      def code
+        <<~JADE
+          module Maybe exposing (Maybe(..), and_then, map, with_default)
+
+          type Maybe(a)
+            = Just(a)
+            | Nothing
+
+
+          def with_default(maybe: Maybe(a), default: a) -> a
+            case maybe
+            in Just(something) then something
+            in Nothing then default
+            end
+          end
+
+
+          def map(maybe: Maybe(a), fn: a -> b) -> Maybe(b)
+            case maybe
+            in Just(something)
+              something
+                |> fn
+                |> Just
+            in Nothing then Nothing
+            end
+          end
+
+
+          def and_then(maybe: Maybe(a), fn: a -> Maybe(b)) -> Maybe(b)
+            case maybe
+            in Just(something) then something |> fn
+            in Nothing then Nothing
+            end
+          end
+
+
+          implements Mappable(Maybe(a)) with
+            map: map
+          end
+
+
+          implements Chainable(Maybe(a)) with
+            and_then: and_then
+          end
+        JADE
+      end
+    end
+  end
+end

data/lib/jade/stdlib/result.rb

@@ -0,0 +1,131 @@
+require 'jade/stdlib/compiled'
+
+module Jade
+  module Stdlib
+    module Result
+      extend self
+      extend Compiled
+
+      def uri
+        'result.jd'
+      end
+
+      def imports
+        [Basics, Maybe, List]
+      end
+
+      def default_imports
+        [
+          Symbol.type_ref('Result', 'Result'),
+          Symbol.value_ref('Result', 'Ok'),
+          Symbol.value_ref('Result', 'Err'),
+        ]
+      end
+
+      def code
+        <<~JADE
+          module Result exposing (
+            Result(..),
+            and_then,
+            from_maybe,
+            map,
+            map_error,
+            on_error,
+            sequence,
+            to_maybe,
+            with_default,
+          )
+
+          type Result(value, error)
+            = Ok(value)
+            | Err(error)
+
+
+          def map(result: Result(a, e), fn: a -> b) -> Result(b, e)
+            case result
+            in Ok(something)
+              something
+                |> fn
+                |> Ok
+            in Err(error) then Err(error)
+            end
+          end
+
+
+          def and_then(result: Result(a, e), fn: a -> Result(b, e)) -> Result(b, e)
+            case result
+            in Ok(something) then something |> fn
+            in Err(error) then Err(error)
+            end
+          end
+
+
+          def with_default(result: Result(a, e), default: a) -> a
+            case result
+            in Ok(something) then something
+            else default
+            end
+          end
+
+
+          def to_maybe(result: Result(a, e)) -> Maybe(a)
+            case result
+            in Ok(something) then Just(something)
+            else Nothing
+            end
+          end
+
+
+          def from_maybe(maybe: Maybe(a), error: e) -> Result(a, e)
+            case maybe
+            in Just(something) then Ok(something)
+            in Nothing then Err(error)
+            end
+          end
+
+
+          def map_error(result: Result(a, e), fn: e -> x) -> Result(a, x)
+            case result
+            in Err(error)
+              error
+                |> fn
+                |> Err
+            in Ok(something) then Ok(something)
+            end
+          end
+
+
+          def sequence(results: List(Result(a, e))) -> Result(List(a), e)
+            List.fold(
+              results,
+              Ok([]),
+              (acc, result) -> {
+                list <- acc
+                value <- result
+                Ok(list ++ [value])
+              },
+            )
+          end
+
+
+          def on_error(result: Result(a, e), fn: e -> Result(a, f)) -> Result(a, f)
+            case result
+            in Err(error) then error |> fn
+            in Ok(_) then result
+            end
+          end
+
+
+          implements Mappable(Result(a, e)) with
+            map: map
+          end
+
+
+          implements Chainable(Result(a, e)) with
+            and_then: and_then
+          end
+        JADE
+      end
+    end
+  end
+end