jade-lang 0.1.0

data/lib/jade/symbol/type_application.rb

@@ -0,0 +1,8 @@
+module Jade
+  module Symbol
+    TypeApplication = Data.define(:constructor, :args, :span) do
+      include Base
+    end
+
+  end
+end

data/lib/jade/symbol/type_ref.rb

@@ -0,0 +1,11 @@
+module Jade
+  module Symbol
+    TypeRef = Data.define(:module_name, :name) do
+      include Base
+
+      def to_ref
+        self
+      end
+    end
+  end
+end

data/lib/jade/symbol/union.rb

@@ -0,0 +1,15 @@
+module Jade
+  module Symbol
+    Union = Data.define(:module_name, :name, :type_params, :variants, :decl_span) do
+      include Base
+
+      def to_ref
+        TypeRef[module_name, name]
+      end
+
+      def constructor_refs
+        variants
+      end
+    end
+  end
+end

data/lib/jade/symbol/value_ref.rb

@@ -0,0 +1,15 @@
+module Jade
+  module Symbol
+    ValueRef = Data.define(:module_name, :name) do
+      include Symbol
+
+      def to_ref
+        self
+      end
+
+      def qualified_name
+        [module_name, name].join('.')
+      end
+    end
+  end
+end

data/lib/jade/symbol/variable.rb

@@ -0,0 +1,7 @@
+module Jade
+  module Symbol
+    Variable = Data.define(:name, :decl_span) do
+      include Base
+    end
+  end
+end

data/lib/jade/symbol/variant.rb

@@ -0,0 +1,11 @@
+module Jade
+  module Symbol
+    Variant = Data.define(:module_name, :name, :args, :union, :decl_span) do
+      include Base
+
+      def to_ref
+        ValueRef[module_name, name]
+      end
+    end
+  end
+end

data/lib/jade/symbol.rb

@@ -0,0 +1,162 @@
+require 'jade/symbol/base'
+require 'jade/symbol/parser'
+
+require 'jade/symbol/anonymous_record'
+require 'jade/symbol/constructor'
+require 'jade/symbol/derived_function'
+require 'jade/symbol/function'
+require 'jade/symbol/function_type'
+require 'jade/symbol/implementation'
+require 'jade/symbol/implementation_template'
+require 'jade/symbol/interface'
+require 'jade/symbol/interface_function'
+require 'jade/symbol/interop_function'
+require 'jade/symbol/lambda'
+require 'jade/symbol/record_type'
+require 'jade/symbol/stdlib_function'
+require 'jade/symbol/stdlib_implementation'
+require 'jade/symbol/struct'
+require 'jade/symbol/type_application'
+require 'jade/symbol/partial_application'
+require 'jade/symbol/type_ref'
+require 'jade/symbol/union'
+require 'jade/symbol/variant'
+require 'jade/symbol/value_ref'
+require 'jade/symbol/variable'
+
+module Jade
+  module Symbol
+    extend self
+
+    def module_name(qualified_name)
+      *module_parts, _ = qualified_name
+      module_parts.join('.')
+    end
+
+    def unqualified_name(qualified_name)
+      qualified_name.split('.').last
+    end
+
+    def anonymous_record(fields, row_var = nil)
+      fail('fields is expected to be an array') unless fields.is_a?(Array)
+
+      AnonymousRecord[fields, row_var]
+    end
+
+    def record_type(fields, row_var)
+      fail('fields is expected to be a hash') unless fields.is_a?(Hash)
+
+      RecordType[fields, row_var]
+    end
+
+    def union(name, type_params, variants, span)
+      Union[nil, name, type_params, variants.map(&:to_ref), span]
+    end
+
+    def variant(name, args, union, span)
+      Variant[nil, name, args, union, span]
+    end
+
+    def constructor(name, args, parent, span)
+      Constructor[nil, name, args, parent, span]
+    end
+
+    def predeclared_constructor(name, span)
+      Constructor[nil, name, [], nil, span]
+    end
+
+    def lambda(arity)
+      Lambda[arity]
+    end
+
+    def type_ref(module_name, name)
+      TypeRef[module_name, name]
+    end
+
+    def type_ref_from_qualified_name(q_name)
+      *qualified_parts, name = q_name.split('.')
+      TypeRef[qualified_parts.join('.'), name]
+    end
+
+    def value_ref(module_name, name)
+      ValueRef[module_name, name]
+    end
+
+    def var(name, span)
+      Variable[name, span]
+    end
+
+    def predeclared_function(name, decl_span = nil)
+      Function[nil, name, nil, nil, decl_span]
+    end
+
+    def function(name, params, return_type, decl_span = nil)
+      Function[nil, name, params, return_type, decl_span]
+    end
+
+    def function_type(params, return_type)
+      FunctionType[params, return_type]
+    end
+
+    def stdlib_function(name, params, return_type, codegen, constraints: [])
+      StdlibFunction[nil, name, params, return_type, codegen, constraints]
+    end
+
+    def predeclared_interop_function(name)
+      InteropFunction[nil, name, [], nil, nil, [], nil]
+    end
+
+    def interop_function(name, params, return_type, interop_module_name, constraints: [])
+      InteropFunction[nil, name, params, return_type, interop_module_name, constraints, nil]
+    end
+
+    def type_application(constructor, args, span)
+      TypeApplication[constructor, args, span]
+    end
+
+    def partial_application(constructor, args, span)
+      PartialApplication[constructor, args, span]
+    end
+
+    def predeclared_struct(name, type_params, span)
+      Struct[nil, name, type_params, nil, span]
+    end
+
+    def interface(name, type_var, functions, default, span)
+      Interface[nil, name, type_var, functions, default, span]
+    end
+
+    def interface_function(name, inteface, params, return_type, span)
+      InterfaceFunction[nil, name, inteface, params, return_type, span]
+    end
+
+    def implementation(
+      interface,
+      type,
+      type_params,
+      constraints,
+      functions,
+      deps,
+      span,
+      extends: []
+    )
+      Implementation[
+        nil,
+        interface,
+        type,
+        type_params,
+        constraints,
+        functions,
+        deps,
+        extends,
+        span,
+      ]
+    end
+
+    def parse(annotation)
+      Lexer
+        .tokenize(Source.new(uri: nil, text: annotation))
+        .then { Parser.parse(it) }
+    end
+  end
+end

data/lib/jade/task.rb

@@ -0,0 +1,103 @@
+require 'jade/tasks'
+
+module Jade
+  module Task
+    Literal = Data.define(:result) do
+      include Task
+
+      def run
+        result
+      end
+    end
+
+    Dispatch = Data.define(:task_def, :args) do
+      include Task
+
+      def run
+        Jade::Tasks.dispatch(task_def, *args)
+      end
+    end
+
+    Map = Data.define(:task, :fn) do
+      include Task
+
+      def run
+        case task.run
+        in Jade::Result::Ok[value]  then Jade::Result::Ok[fn.call(value)]
+        in Jade::Result::Err => err then err
+        end
+      end
+    end
+
+    AndThen = Data.define(:task, :fn) do
+      include Task
+
+      def run
+        case task.run
+        in Jade::Result::Ok[value]  then fn.call(value).run
+        in Jade::Result::Err => err then err
+        end
+      end
+    end
+
+    OnError = Data.define(:task, :fn) do
+      include Task
+
+      def run
+        case task.run
+        in Jade::Result::Ok => ok    then ok
+        in Jade::Result::Err[error]  then fn.call(error).run
+        end
+      end
+    end
+
+    MapError = Data.define(:task, :fn) do
+      include Task
+
+      def run
+        case task.run
+        in Jade::Result::Ok => ok    then ok
+        in Jade::Result::Err[error]  then Jade::Result::Err[fn.call(error)]
+        end
+      end
+    end
+
+    Sequence = Data.define(:tasks) do
+      include Task
+
+      def run
+        values = []
+        tasks.each do |task|
+          case task.run
+          in Jade::Result::Ok[value] then values << value
+          in Jade::Result::Err => err then return err
+          end
+        end
+        Jade::Result::Ok[values]
+      end
+    end
+
+    Decoded = Data.define(:task, :ok_decoder, :err_decoder) do
+      include Task
+
+      def run
+        case task.run
+        in Jade::Result::Ok[value]
+          Jade::Result::Ok[decode(ok_decoder, value)]
+        in Jade::Result::Err[error]
+          Jade::Result::Err[decode(err_decoder, error)]
+        end
+      end
+
+      private
+
+      def decode(decoder, value)
+        case Jade::Decode::Runner.run(decoder, value)
+        in Jade::Result::Ok[v]  then v
+        in Jade::Result::Err[e] then fail Jade::Interop::DecodeError.new(e, value)
+        end
+      end
+    end
+
+  end
+end

data/lib/jade/tasks/rspec.rb

@@ -0,0 +1,266 @@
+require 'rspec/expectations'
+
+require 'jade/tasks'
+
+module Jade
+  module Tasks
+    Block = Data.define(:block)
+
+    class TestRegistry
+      attr_accessor :strict
+
+      def initialize
+        @persistent = {}
+        @queues     = Hash.new { |h, k| h[k] = [] }
+        @calls      = Hash.new { |h, k| h[k] = [] }
+        @strict     = false
+      end
+
+      def queue_next(task_def, answer)
+        @queues[task_def] << answer
+      end
+
+      def set_persistent(task_def, answer)
+        @persistent[task_def] = answer
+      end
+
+      def dispatch(task_def, args)
+        @calls[task_def] << args
+
+        pick_answer(task_def)
+          .then { it || fail(Unbound.new(task_def, args, @strict)) }
+          .then { resolve(it, args) }
+          .tap { |value| fail ReturnedTask.new(task_def) if value.is_a?(Jade::Task) }
+      end
+
+      def calls_to(task_def)
+        @calls[task_def]
+      end
+
+      private
+
+      def pick_answer(task_def)
+        @queues[task_def].shift ||
+          @persistent[task_def] ||
+          (@strict ? nil : REGISTRATIONS[task_def]&.then { Block.new(it) })
+      end
+
+      def resolve(answer, args)
+        case answer
+        in Block(block) then block.call(Outcome, *args)
+        else Jade::Result::Ok[answer]
+        end
+      end
+    end
+
+    # Override production dispatch to route through the per-thread test registry.
+    def self.dispatch(task_def, *args)
+      test_registry.dispatch(task_def, args)
+    end
+
+    def self.test_registry
+      Thread.current[:jade_tasks_test_registry] ||= TestRegistry.new
+    end
+
+    def self.reset!(strict: false)
+      Thread.current[:jade_tasks_test_registry] = TestRegistry
+        .new
+        .tap { it.strict = strict }
+    end
+
+    # Test-mode Unbound carries an extra `strict` field for a more helpful
+    # message when a test forgot to stub.
+    remove_const(:Unbound)
+
+    class Unbound < StandardError
+      def initialize(task_def, args, strict)
+        kind = strict ? 'stub' : 'stub or registration'
+        super("No #{kind} for #{task_def}; called with #{args.inspect}")
+      end
+    end
+
+    module RSpec
+      def next_call_to(task_def, value = OMITTED, &block)
+        Jade::Tasks
+          .test_registry
+          .queue_next(task_def, answer_for(value, block))
+      end
+
+      def all_calls_to(task_def, value = OMITTED, &block)
+        Jade::Tasks
+          .test_registry
+          .set_persistent(task_def, answer_for(value, block))
+      end
+
+      OMITTED = Object.new.freeze
+      private_constant :OMITTED
+
+      private
+
+      def answer_for(value, block)
+        if block
+          Jade::Tasks::Block.new(block)
+        elsif value.equal?(OMITTED)
+          fail ArgumentError, "needs a value or a block"
+        else
+          value
+        end
+      end
+
+      def self.included(base)
+        base.before(:each) { Jade::Tasks.reset!(strict: true) }
+      end
+
+      module Loose
+        def self.included(base)
+          base.include(Jade::Tasks::RSpec)
+          base.before(:each) { Jade::Tasks.reset!(strict: false) }
+        end
+      end
+    end
+
+    module Matcher
+      extend self
+
+      def resolve(name)
+        case name
+        when ::Class, ::Module
+          name
+        when ::String
+          Object.const_get(name)
+        when ::Symbol
+          full_names = lookup_short_name(name.to_s).map(&:name).uniq
+          case full_names.length
+          when 1 then Object.const_get(full_names.first)
+          when 0
+            fail "No constant named #{name.inspect}; " \
+              "pass the class itself or a 'Module::Name' string"
+          else
+            fail "Ambiguous #{name.inspect}: #{full_names.join(', ')}; " \
+              "use the qualified 'Module::Name' string"
+          end
+        end
+      end
+
+      def match?(actual, name, positional, named)
+        klass = resolve(name)
+        return false unless actual.is_a?(klass)
+
+        if named.any?
+          return false if positional.any?
+
+          actual_kw = actual.deconstruct_keys(named.keys)
+          named.all? { |k, expected| arg_match?(actual_kw[k], expected) }
+        else
+          actual_args = actual.respond_to?(:deconstruct) ? actual.deconstruct : []
+          return false unless actual_args.length == positional.length
+
+          actual_args.zip(positional).all? { |a, e| arg_match?(a, e) }
+        end
+      end
+
+      def arg_match?(actual, expected)
+        return expected === actual || expected == actual unless expected.is_a?(::Array)
+
+        case expected
+        in [::Symbol | ::String | ::Module => name, *positional, ::Hash => named]
+          match?(actual, name, positional, named)
+
+        in [::Symbol | ::String | ::Module => name, *positional]
+          match?(actual, name, positional, {})
+
+        else
+          expected == actual
+        end
+      end
+
+      private
+
+      def lookup_short_name(short)
+        matches = ->(m) {
+          Module
+            .instance_method(:name)
+            .bind(m).call
+            .then { it && it.split('::').last == short }
+        }
+
+        ObjectSpace.each_object(Class).select(&matches) +
+          ObjectSpace.each_object(Module).select { |m| !m.is_a?(Class) && matches.call(m) }
+      end
+    end
+  end
+end
+
+::RSpec::Matchers.define :have_been_called do
+  def matching_calls(task_def)
+    actual = Jade::Tasks.test_registry.calls_to(task_def)
+    @args ? actual.select { |a| a == @args } : actual
+  end
+
+  match do |task_def|
+    @task_def = task_def
+    @actual   = Jade::Tasks.test_registry.calls_to(task_def)
+    matches   = matching_calls(task_def)
+    @count ? matches.length == @count : matches.any?
+  end
+
+  match_when_negated do |task_def|
+    @task_def = task_def
+    @actual   = Jade::Tasks.test_registry.calls_to(task_def)
+    matching_calls(task_def).empty?
+  end
+
+  chain(:with)   { |*args| @args = args }
+  chain(:times)  { |count| @count = count }
+  chain(:once)   { @count = 1 }
+
+  failure_message do
+    suffix = @args ? " with #{@args.inspect}" : ""
+    suffix += " #{@count} time(s)" if @count
+    "expected #{@task_def} to have been called#{suffix}, but calls were #{@actual.inspect}"
+  end
+
+  failure_message_when_negated do
+    suffix = @args ? " with #{@args.inspect}" : ""
+    "expected #{@task_def} not to have been called#{suffix}, but calls were #{@actual.inspect}"
+  end
+end
+
+::RSpec::Matchers.define :look_like do |name, *positional, **named|
+  match do |actual|
+    @actual = actual
+    Jade::Tasks::Matcher.match?(actual, name, positional, named)
+  end
+
+  failure_message do
+    args = (positional.map(&:inspect) + named.map { |k, v| "#{k}: #{v.inspect}" }).join(', ')
+    "expected #{@actual.inspect} to look like #{name}(#{args})"
+  end
+end
+
+{
+  ok:      'Jade::Result::Ok',
+  err:     'Jade::Result::Err',
+  just:    'Jade::Maybe::Just',
+  nothing: 'Jade::Maybe::Nothing',
+}.each do |kind, full_name|
+  ::RSpec::Matchers.define :"be_#{kind}" do |*args, **named|
+    match do |actual|
+      @actual = actual
+      if args.empty? && named.empty?
+        actual.respond_to?(:"#{kind}?") && actual.public_send(:"#{kind}?")
+      else
+        Jade::Tasks::Matcher.match?(actual, full_name, args, named)
+      end
+    end
+
+    failure_message do
+      if args.empty? && named.empty?
+        "expected #{@actual.inspect} to respond truthy to .#{kind}?"
+      else
+        inner = (args.map(&:inspect) + named.map { |k, v| "#{k}: #{v.inspect}" }).join(', ')
+        "expected #{@actual.inspect} to be #{kind.to_s.capitalize}(#{inner})"
+      end
+    end
+  end
+end

data/lib/jade/tasks.rb

@@ -0,0 +1,70 @@
+module Jade
+  module Task; end
+
+  TaskDef = Data.define(:module_name, :name) do
+    def to_s
+      "#{module_name}.#{name}"
+    end
+
+    def inspect
+      "#<TaskDef #{self}>"
+    end
+  end
+
+  module Port
+    def task(name, &block)
+      Jade::TaskDef
+        .new(self.name, name.to_s)
+        .tap { Jade::Tasks.register(it, &block) }
+        .tap { |task_def| define_singleton_method(name) { task_def } }
+    end
+  end
+
+  module Tasks
+    extend self
+
+    REGISTRATIONS = {}
+
+    class Unbound < StandardError
+      def initialize(task_def, args)
+        super("No port registered for #{task_def}; called with #{args.inspect}")
+      end
+    end
+
+    class ReturnedTask < StandardError
+      def initialize(task_def)
+        super(
+          "Body of #{task_def} returned a Jade::Task — tasks must not return tasks; " \
+            "compose with map/and_then/sequence in Jade instead"
+        )
+      end
+    end
+
+    def register(task_def, &block)
+      REGISTRATIONS[task_def] = block
+    end
+
+    def dispatch(task_def, *args)
+      block = REGISTRATIONS[task_def]
+      fail Unbound.new(task_def, args) unless block
+
+      block.call(Outcome, *args).tap do |value|
+        fail ReturnedTask.new(task_def) if value.is_a?(Jade::Task)
+      end
+    end
+
+    module Outcome
+      extend self
+
+      def ok(value)
+        Jade::Result::Ok[value]
+      end
+
+      def err(error)
+        Jade::Result::Err[error]
+      end
+    end
+  end
+end
+
+require 'jade/task'

data/lib/jade/type/anonymous_record.rb

@@ -0,0 +1,33 @@
+module Jade
+  module Type
+    AnonymousRecord = Data.define(:fields, :row_var) do
+      include Base
+
+      def to_s
+        row = row_var ? "#{row_var} | " : ""
+
+        fields
+          .map { |name, type| "#{name} : #{type}" }
+          .join(", ")
+          .then { "{ #{row}#{it} }" }
+      end
+
+      def unbound_vars
+        (row_var ? row_var.unbound_vars : []) +
+          fields.values.flat_map(&:unbound_vars).uniq
+      end
+
+      def open?
+        !closed?
+      end
+
+      def closed?
+        row_var.nil?
+      end
+
+      def field_names
+        fields.keys
+      end
+    end
+  end
+end