jade-lang 0.1.0

data/lib/jade/stdlib/set.rb

@@ -0,0 +1,123 @@
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module Set
+      extend Intrinsics
+
+      import Basics
+      import Maybe
+      import List
+
+      union :Set, 'a'
+
+      native_type :Set, Jade::Set::Set
+
+      implementation('Eq', 'Set', '(==)' => 'set_eq')
+
+      function(:empty, {}, 'Set(a)')
+
+      function(
+        :singleton,
+        { value: 'a' },
+        'Set(a)',
+        constraints: [['Basics.Eq', 'a']],
+      )
+
+      function(:"empty?", { set: 'Set(a)' }, 'Bool')
+      function(:size, { set: 'Set(a)' }, 'Int')
+
+      function(
+        :"member?",
+        { set: 'Set(a)', value: 'a' },
+        'Bool',
+        constraints: [['Basics.Eq', 'a']],
+      )
+
+      function(
+        :insert,
+        { set: 'Set(a)', value: 'a' },
+        'Set(a)',
+        constraints: [['Basics.Eq', 'a']],
+      )
+
+      function(
+        :remove,
+        { set: 'Set(a)', value: 'a' },
+        'Set(a)',
+        constraints: [['Basics.Eq', 'a']],
+      )
+
+      function(:to_list, { set: 'Set(a)' }, 'List(a)')
+
+      function(
+        :from_list,
+        { values: 'List(a)' },
+        'Set(a)',
+        constraints: [['Basics.Eq', 'a']],
+      )
+
+      function(
+        :map,
+        { set: 'Set(a)', fn: 'a -> b' },
+        'Set(b)',
+        constraints: [['Basics.Eq', 'b']],
+      ) do |set, fn|
+        set.hash.keys
+          .each_with_object({}) { |v, h| h[fn.call(v)] = true }
+          .then { Jade::Set::Set[it] }
+      end
+
+      function(
+        :filter,
+        { set: 'Set(a)', fn: 'a -> Bool' },
+        'Set(a)',
+      ) do |set, fn|
+        set.hash
+          .select { |k, _| fn.call(k) }
+          .then { Jade::Set::Set[it] }
+      end
+
+      function(
+        :fold,
+        { set: 'Set(a)', initial: 'b', fn: 'a, b -> b' },
+        'b',
+      ) do |set, initial, fn|
+        set.hash.keys.reduce(initial) { |acc, v| fn.call(v, acc) }
+      end
+
+      function(
+        :union,
+        { left: 'Set(a)', right: 'Set(a)' },
+        'Set(a)',
+        constraints: [['Basics.Eq', 'a']],
+      )
+
+      function(
+        :intersect,
+        { left: 'Set(a)', right: 'Set(a)' },
+        'Set(a)',
+        constraints: [['Basics.Eq', 'a']],
+      ) do |left, right|
+        left.hash
+          .select { |k, _| right.hash.key?(k) }
+          .then { Jade::Set::Set[it] }
+      end
+
+      function(
+        :diff,
+        { left: 'Set(a)', right: 'Set(a)' },
+        'Set(a)',
+        constraints: [['Basics.Eq', 'a']],
+      ) do |left, right|
+        left.hash
+          .reject { |k, _| right.hash.key?(k) }
+          .then { Jade::Set::Set[it] }
+      end
+
+      default_importing('Set')
+
+      function('set_eq', { a: 'Set(a)', b: 'Set(a)' }, 'Bool')
+    end
+  end
+end

data/lib/jade/stdlib/string.rb

@@ -0,0 +1,65 @@
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module String
+      extend Intrinsics
+
+      import Basics
+      import Maybe
+      import List
+      import Char
+      import Tuple
+
+      union :String
+
+      native_type :String, ::String
+
+      implementation('Eq', 'String', '(==)' => 'str_eq')
+      implementation('Appendable', 'String', '(++)' => 'str_append')
+      implementation('Comparable', 'String', 'compare' => 'str_compare')
+
+      function('str_compare', { a: 'String', b: 'String' }, 'Ordering')
+      function('str_append', { a: 'String', b: 'String' }, 'String')
+      function(:"empty?", { str: 'String' }, 'Bool')
+      function(:length, { str: 'String' }, 'Int')
+      function(:reverse, { str: 'String' }, 'String')
+      function(:uncons, { str: 'String' }, 'Maybe(Tuple2(Char, String))')
+      function(:cons, { head: 'Char', tail: 'String' }, 'String')
+      function(:from_char, { char: 'Char' }, 'String')
+      function(:map, { str: 'String', fn: 'Char -> Char' }, 'String')
+      function(:repeat, { str: 'String', times: 'Int' }, 'String')
+      function(:to_int, { str: 'String' }, 'Maybe(Int)')
+      function(:from_int, { n: 'Int' }, 'String')
+      function(:split, { str: 'String', by: 'String' }, 'List(String)')
+      function(:concat, { list: 'List(String)' }, 'String')
+      function(:join, { list: 'List(String)', with: 'String' }, 'String')
+      function(:trim, { str: 'String' }, 'String')
+      function(:trim_left, { str: 'String' }, 'String')
+      function(:trim_right, { str: 'String' }, 'String')
+      function(:to_lower, { str: 'String' }, 'String')
+      function(:to_upper, { str: 'String' }, 'String')
+      function(:"contains?", { str: 'String', sub: 'String' }, 'Bool')
+      function(:"starts_with?", { str: 'String', prefix: 'String' }, 'Bool')
+      function(:"ends_with?", { str: 'String', suffix: 'String' }, 'Bool')
+      function(:replace, { str: 'String', target: 'String', replacement: 'String' }, 'String')
+
+      # Every start position of `sub` in `str`, left to right, non-overlapping
+      # (matches Elm's String.indexes). Empty `sub` yields an empty list.
+      function(:indexes, { str: 'String', sub: 'String' }, 'List(Int)')
+
+      # Half-open slice. Negative offsets count from the end (Ruby `s[i...j]`
+      # semantics). Out-of-range returns an empty string rather than nil.
+      function(:slice, { str: 'String', start: 'Int', end_: 'Int' }, 'String')
+
+      function(:words, { str: 'String' }, 'List(String)')
+      function(:lines, { str: 'String' }, 'List(String)')
+      function(:to_list, { str: 'String' }, 'List(Char)')
+      function(:from_list, { chars: 'List(Char)' }, 'String')
+
+      default_importing('String')
+
+      function('str_eq', { one: 'String', other: 'String' }, 'Bool')
+    end
+  end
+end

data/lib/jade/stdlib/task.rb

@@ -0,0 +1,55 @@
+require 'jade/stdlib/intrinsics'
+require 'jade/task'
+
+module Jade
+  module Stdlib
+    module Task
+      extend Intrinsics
+
+      union :Task, :a, :e
+
+      function('succeed', { value: 'a' }, 'Task(a, e)') do |value|
+        Jade::Task::Literal.new(Jade::Result::Ok[value])
+      end
+
+      function('fail', { error: 'e' }, 'Task(a, e)') do |error|
+        Jade::Task::Literal.new(Jade::Result::Err[error])
+      end
+
+      function('map', { task: 'Task(a, e)', fn: 'a -> b' }, 'Task(b, e)') do |task, fn|
+        Jade::Task::Map.new(task, fn)
+      end
+
+      function('and_then', { task: 'Task(a, e)', fn: 'a -> Task(b, e)' }, 'Task(b, e)') do |task, fn|
+        Jade::Task::AndThen.new(task, fn)
+      end
+
+      function('on_error', { task: 'Task(a, e)', fn: 'e -> Task(a, f)' }, 'Task(a, f)') do |task, fn|
+        Jade::Task::OnError.new(task, fn)
+      end
+
+      function('map_error', { task: 'Task(a, e)', fn: 'e -> f' }, 'Task(a, f)') do |task, fn|
+        Jade::Task::MapError.new(task, fn)
+      end
+
+      function('from_result', { result: 'Result(a, e)' }, 'Task(a, e)') do |result|
+        Jade::Task::Literal.new(result)
+      end
+
+      function('sequence', { tasks: 'List(Task(a, e))' }, 'Task(List(a), e)') do |tasks|
+        Jade::Task::Sequence.new(tasks)
+      end
+
+      function('run', { task: 'Task(a, e)' }, 'Result(a, e)') do |task|
+        task.run
+      end
+
+      implementation('Mappable',  'Task', 'map'      => 'map')
+      implementation('Chainable', 'Task', 'and_then' => 'and_then')
+
+      def self.default_imports
+        [Symbol.type_ref('Task', 'Task')]
+      end
+    end
+  end
+end

data/lib/jade/stdlib/tuple.rb

@@ -0,0 +1,21 @@
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module Tuple
+      extend Intrinsics
+
+      union :Tuple2, 'a', 'b', constructor: true
+      union :Tuple3, 'a', 'b', 'c', constructor: true
+      union :Tuple4, 'a', 'b', 'c', 'd', constructor: true
+
+      function(:pair, { first: 'a', second: 'b' }, 'Tuple2(a, b)')
+      function(:first, { pair: 'Tuple2(a, b)' }, 'a')
+      function(:second, { pair: 'Tuple2(a, b)' }, 'b')
+
+      def self.constructor_by_arity(arity)
+        "Tuple.Tuple#{arity}"
+      end
+    end
+  end
+end

data/lib/jade/stdlib.rb

@@ -0,0 +1,112 @@
+require 'set'
+require 'jade/stdlib/basics'
+require 'jade/stdlib/maybe'
+require 'jade/stdlib/tuple'
+require 'jade/stdlib/list'
+require 'jade/stdlib/char'
+require 'jade/stdlib/string'
+require 'jade/stdlib/result'
+require 'jade/stdlib/task'
+require 'jade/stdlib/dict'
+require 'jade/stdlib/set'
+require 'jade/stdlib/decode'
+require 'jade/stdlib/decode/params'
+require 'jade/stdlib/encode'
+require 'jade/stdlib/bytes'
+require 'jade/stdlib/calendar'
+require 'jade/stdlib/clock'
+
+module Jade
+  module Stdlib
+    extend self
+
+    INTRINSICS = %w[
+      Basics String List Tuple Char Task
+      Decode Encode
+      Bytes
+      Dict Set
+    ].freeze
+    COMPILED = %w[Maybe Result Decode.Params Calendar Clock].freeze
+    TOPLEVELS = (INTRINSICS + COMPILED).map { it.split('.', 2).first }.to_set.freeze
+    STDLIBS = [
+      Stdlib::Basics, Stdlib::Maybe, Stdlib::Tuple, Stdlib::List, Stdlib::Char,
+      Stdlib::String, Stdlib::Result, Stdlib::Task,
+      Stdlib::Dict, Stdlib::Set,
+      Stdlib::Decode, Stdlib::Decode::Params, Stdlib::Encode,
+      Stdlib::Bytes,
+      Stdlib::Calendar, Stdlib::Clock,
+    ]
+    # 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,
+    ]
+
+    def load(registry)
+      registry
+        .then { load_stdlib(registry) }
+    end
+
+    def apply(registry)
+      # TODO: [ModuleLoaderRefactor] This should live in registry probably
+      user_entries = registry
+        .modules
+        .values
+        .reject { is_stdlib?(it) }
+
+      user_entries
+        .reduce(registry) do |acc, entry|
+          add_imports(entry)
+            .then { acc.add_module(it) }
+        end
+    end
+
+    def requires(name)
+      return [] if COMPILED.include?(name)
+
+      prefix = '../' * name.count('.')
+      COMPILED
+        .map { it.downcase.tr('.', '/') }
+        .map { "require_relative '#{prefix}#{it}'" }
+    end
+
+    PRIVATE_CONSTRUCTORS = %w[Tuple.Tuple2 Tuple.Tuple3 Tuple.Tuple4].freeze
+
+    def is_intrinsic?(entry)
+      INTRINSICS.include? entry.name
+    end
+
+    def private_constructor?(name)
+      PRIVATE_CONSTRUCTORS.include?(name)
+    end
+
+    def is_stdlib?(entry)
+      is_intrinsic?(entry) || COMPILED.include?(entry.name)
+    end
+
+    def stdlib_name?(qualified_name)
+      dot = qualified_name.index('.')
+      first = dot ? qualified_name[0, dot] : qualified_name
+      TOPLEVELS.include?(first)
+    end
+
+    private
+
+    def add_imports(entry)
+      (STDLIBS - EXTENSIONS)
+        .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 load_stdlib(registry)
+      STDLIBS
+        .reduce(registry) do |acc, stdlib|
+          stdlib.generate_entry(acc)
+          acc.add_module(stdlib.entry)
+        end
+    end
+  end
+end

data/lib/jade/symbol/anonymous_record.rb

@@ -0,0 +1,7 @@
+module Jade
+  module Symbol
+    AnonymousRecord = Data.define(:fields, :row_var) do
+      include Base
+    end
+  end
+end

data/lib/jade/symbol/base.rb

@@ -0,0 +1,15 @@
+module Jade
+  module Symbol
+    module Base
+      def qualified_name
+        [module_name, name].join('.')
+      end
+
+      alias_method :qname, :qualified_name
+
+      def constructor_refs
+        []
+      end
+    end
+  end
+end

data/lib/jade/symbol/constructor.rb

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

data/lib/jade/symbol/derived_function.rb

@@ -0,0 +1,5 @@
+module Jade
+  module Symbol
+    DerivedFunction = Data.define(:params, :body)
+  end
+end

data/lib/jade/symbol/function.rb

@@ -0,0 +1,15 @@
+module Jade
+  module Symbol
+    Function = Data.define(:module_name, :name, :params, :return_type, :decl_span) do
+      include Base
+
+      def to_ref
+        ValueRef[module_name, name]
+      end
+
+      def constant?
+        params.empty?
+      end
+    end
+  end
+end

data/lib/jade/symbol/function_type.rb

@@ -0,0 +1,7 @@
+module Jade
+  module Symbol
+    FunctionType = Data.define(:params, :return_type) do
+      include Base
+    end
+  end
+end

data/lib/jade/symbol/implementation.rb

@@ -0,0 +1,17 @@
+module Jade
+  module Symbol
+    Implementation = Data.define(
+      :module_name,
+      :interface,
+      :type,
+      :type_params,
+      :constraints,
+      :functions,
+      :deps,
+      :extends,
+      :decl_span
+    ) do
+      include Base
+    end
+  end
+end

data/lib/jade/symbol/implementation_template.rb

@@ -0,0 +1,13 @@
+module Jade
+  module Symbol
+    ImplementationTemplate = Data.define(
+      :interface,
+      :type,
+      :type_params,
+      :constraints,
+      :functions,
+    ) do
+      include Base
+    end
+  end
+end

data/lib/jade/symbol/interface.rb

@@ -0,0 +1,11 @@
+module Jade
+  module Symbol
+    Interface = Data.define(:module_name, :name, :type_param, :functions, :default, :decl_span) do
+      include Base
+
+      def to_ref
+        TypeRef[module_name, name]
+      end
+    end
+  end
+end

data/lib/jade/symbol/interface_function.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Symbol
+    InterfaceFunction = Data.define(
+      :module_name,
+      :name,
+      :interface,
+      :params,
+      :return_type,
+      :decl_span
+    ) do
+      include Base
+
+      def to_ref
+        ValueRef[module_name, name]
+      end
+    end
+  end
+end

data/lib/jade/symbol/interop_function.rb

@@ -0,0 +1,22 @@
+module Jade
+  module Symbol
+    InteropFunction = Data.define(
+      :module_name,
+      :name,
+      :params,
+      :return_type,
+      :interop_module_name,
+      :constraints, # [[iface_qname, var_name]] — implicit Decodable on var arms
+      :decoders, # { ok: impl_or_pass_or_dict, err: ... } | nil
+    ) do
+      include Base
+
+      def to_ref
+        ValueRef[module_name, name]
+      end
+    end
+
+    InteropFunction::PASS = :pass
+    InteropFunction::Dict = Data.define(:constraint_index)
+  end
+end

data/lib/jade/symbol/lambda.rb

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

data/lib/jade/symbol/parser.rb

@@ -0,0 +1,79 @@
+require 'jade/parsing'
+
+module Jade
+  module Symbol
+    module Parser
+      extend self
+      include Parsing::Combinators
+      include Parsing::Token
+      include Parsing::Type
+
+      def parse(tokens)
+        type_expression
+          .call(State.new(tokens:, entry: 'symbol'))
+          .map(&:first) => Ok(node)
+
+        to_symbol(node)
+      end
+
+      private
+
+      def to_symbol(node)
+        case node
+        in AST::TypeApplication(constructor: AST::TypeVar(type: name), args:)
+          Symbol.partial_application(Symbol.var(name, nil), args.map(&method(:to_symbol)), nil)
+
+        in AST::TypeApplication(constructor: AST::QualifiedTypeName(path:), args:)
+          *mod_parts, type_name = path
+          Symbol.type_application(Symbol.type_ref(mod_parts.join('.'), type_name), args.map(&method(:to_symbol)), nil)
+
+        in AST::TypeApplication(constructor:, args:)
+          Symbol.type_application(Symbol.type_ref(*qualify(constructor.type)), args.map(&method(:to_symbol)), nil)
+
+        in AST::TypeVar(type:)
+          Symbol.var(type, nil)
+
+        in AST::TypeFunction(params:, return_type:)
+          Symbol
+            .function_type(
+              params.map { to_symbol(it) },
+              to_symbol(return_type)
+            )
+        end
+      end
+
+      def qualify(type)
+        case type
+        in 'Int' | 'Float' | 'Bool' | 'Ordering' | 'Never'
+          'Basics'
+
+        in 'String' | 'Maybe' | 'List' | 'Result' | 'Task' | 'Char'
+          type
+
+        in 'Tuple2' | 'Tuple3' | 'Tuple4'
+          'Tuple'
+
+        in 'Decoder' | 'Decodable' | 'DecodeError' | 'Value'
+          'Decode'
+
+        in 'Encodable'
+          'Encode'
+
+        in 'Params'
+          'Decode.Params'
+
+        in 'Bytes'
+          'Bytes'
+
+        in 'Dict'
+          'Dict'
+
+        in 'Set'
+          'Set'
+
+        end
+          .then { [it, type] }
+      end
+    end
+  end
+end

data/lib/jade/symbol/partial_application.rb

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

data/lib/jade/symbol/record_type.rb

@@ -0,0 +1,8 @@
+module Jade
+  module Symbol
+    RecordType = Data.define(:fields, :row_var) do
+      include Base
+    end
+
+  end
+end

data/lib/jade/symbol/stdlib_function.rb

@@ -0,0 +1,15 @@
+module Jade
+  module Symbol
+    StdlibFunction = Data.define(:module_name, :name, :params, :return_type, :codegen, :constraints) do
+      include Base
+
+      def to_ref
+        ValueRef[module_name, name]
+      end
+
+      def constant?
+        params.empty? && constraints.empty?
+      end
+    end
+  end
+end

data/lib/jade/symbol/stdlib_implementation.rb

@@ -0,0 +1,7 @@
+module Jade
+  module Symbol
+    StdlibImplementation = Data.define(:params, :body) do
+      include Base
+    end
+  end
+end

data/lib/jade/symbol/struct.rb

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