jade-lang 0.1.0

data/lib/jade/interop/lowering/error.rb

@@ -0,0 +1,32 @@
+module Jade
+  module Interop
+    module Lowering
+      class Error
+        def message
+          raise NotImplementedError
+        end
+      end
+
+      class TypeParamError < Error
+        def initialize(type_var_name)
+          @type_var_name = type_var_name
+        end
+
+        def message
+          "Type param (#{@type_var_name}) cannot be lowered for interop"
+        end
+      end
+
+      class FunctionError < Error
+        def initialize(function_name)
+          @function_name = function_name
+        end
+
+        def message
+          "Function (#{@function_name}) cannot be lowered for interop"
+        end
+      end
+
+    end
+  end
+end

data/lib/jade/interop/lowering.rb

@@ -0,0 +1,53 @@
+require 'jade/interop/lowering/error'
+
+module Jade
+  module Interop
+    module Lowering
+      extend self
+
+      # Walks a port's return type and returns the kinds of types that
+      # can never have a Decodable instance: function types. Bare type
+      # variables are permitted at top-level arms (PortResolution turns
+      # them into late-bound Dict markers) and rejected at nested
+      # positions (PortResolution's compound-var check fires).
+      def validate(symbol, registry, entry)
+        case symbol
+        in Symbol::Variable
+          []
+
+        in Symbol::Function(name:)
+          [FunctionError.new(name)]
+
+        in Symbol::FunctionType
+          [FunctionError.new('inline function type')]
+
+        in Symbol::TypeApplication(args:)
+          args.flat_map { validate(it, registry, entry) }
+
+        in Symbol::RecordType(fields:)
+          fields.values.flat_map { validate(it, registry, entry) }
+
+        in Symbol::Struct(record_type:)
+          validate(record_type, registry, entry)
+
+        in Symbol::TypeRef
+          lookup_type(symbol, registry, entry)
+            &.then { validate(it, registry, entry) } || []
+
+        else
+          []
+        end
+      end
+
+      private
+
+      def lookup_type(ref, registry, entry)
+        if ref.module_name == entry.name
+          entry.lookup_type(ref.name)
+        else
+          registry.lookup(ref)
+        end
+      end
+    end
+  end
+end

data/lib/jade/interop/runtime.rb

@@ -0,0 +1,24 @@
+require 'jade/interop/error'
+
+module Jade
+  module Interop
+    module Runtime
+      def task_call(interop_module_name, function_name, ok_decoder, err_decoder)
+        ->(*args) do
+          interop_module_name
+            .send(function_name)
+            .then do |port|
+              port.is_a?(Jade::TaskDef) ||
+                fail(Interop::PortNotRegistered.new(interop_module_name, function_name))
+
+              Jade::Task::Decoded.new(
+                Jade::Task::Dispatch.new(port, args),
+                ok_decoder,
+                err_decoder,
+              )
+            end
+        end
+      end
+    end
+  end
+end

data/lib/jade/interop.rb

@@ -0,0 +1 @@
+require 'jade/interop/lowering'

data/lib/jade/lexer.rb

@@ -0,0 +1,189 @@
+require 'strscan'
+require 'set'
+
+require 'jade/source'
+
+module Jade
+  Token = Data.define(:type, :value, :range)
+
+  module Lexer
+    extend self
+
+    KEYWORDS = ::Set[
+      'def',
+      'type',
+      'module',
+      'import',
+      'exposing',
+      'if',
+      'then',
+      'else',
+      'case',
+      'in',
+      'end',
+      'as',
+      'uses',
+      'with',
+      'struct',
+      'interface',
+      'implements',
+      'extends',
+    ].freeze
+
+    SYMBOLS = {
+      '->' => :arrow,
+      '('  => :lparen,
+      ')'  => :rparen,
+      ':'  => :colon,
+      ','  => :comma,
+      '{'  => :lbrace,
+      '}'  => :rbrace,
+      '['  => :lbrack,
+      ']'  => :rbrack,
+      '..' => :dotdot,
+      '.'  => :dot,
+      '@'  => :at,
+
+      # arithmetic
+      '+'  => :plus,
+      '-'  => :minus,
+      '*'  => :star,
+      '/'  => :slash,
+      '|'  => :pipe,
+
+      # comparison
+      '==' => :eq,
+      '!=' => :not_eq,
+      '<'  => :lt,
+      '<=' => :lte,
+      '>'  => :gt,
+      '>=' => :gte,
+
+      '++' => :plusplus,
+      '='  => :assign,
+
+      '|>' => :pipe_forward,
+      '<|' => :pipe_backward,
+      '<-' => :bind,
+
+      '_' => :wildcard, # also used as placeholder
+      '::' => :coloncolon,
+      # Ternary `cond ? a : b`. Predicate-`?` attaches via the identifier
+      # regex (`\??`), so this only fires when `?` stands alone.
+      '?' => :question,
+
+      '&&' => :andand,
+      '||' => :oror,
+    }.freeze
+
+    SYMBOLS_REGEX = Regexp.union(SYMBOLS.keys.sort_by { |k| -k.length })
+
+    INVALID_OPS = %w[/=].freeze
+    INVALID_OP_REGEX = Regexp.union(INVALID_OPS.sort_by { |k| -k.length })
+
+    def tokenize(source)
+      source => Source(text:)
+
+      scanner = StringScanner.new(text)
+      tokens = []
+
+      until scanner.eos?
+        case
+        when scanner.scan(/\s+/)
+
+        when scanner.scan(INVALID_OP_REGEX)
+          tokens << tok(:invalid_op, scanner)
+
+        when scanner.scan(/\A#[^\n]*/)
+          tokens << tok(:comment, scanner)
+
+        when scanner.scan(/\A[a-z][a-z0-9_]*\??|\A_[a-z0-9_]+\??/)
+          type = KEYWORDS.include?(scanner.matched) ? scanner.matched.to_sym : :identifier
+          tokens << tok(type, scanner)
+
+        when scanner.scan(SYMBOLS_REGEX)
+          type = SYMBOLS.fetch(scanner.matched)
+          tokens << tok(type, scanner)
+
+        when scanner.scan(/\A(True|False)\b/)
+          tokens << tok(:bool, scanner)
+
+        when scanner.scan(/\A[A-Z][A-Za-z0-9_]*/)
+          tokens << tok(:constant, scanner)
+
+        when scanner.scan(/\d+\.\d+/)
+          tokens << tok(:float, scanner)
+
+        when scanner.scan(/\d+/)
+          tokens << tok(:int, scanner)
+
+        when scanner.scan(/\A"/)
+          (tokens << tok(:quote, scanner))
+            .concat(tokenize_string(scanner))
+
+        when scanner.scan(/\A'.'/)
+          tokens << Token.new(:char, scanner.matched[1], range(scanner))
+
+        when scanner.scan(/\A'[^']*'/)
+          fail "Invalid char literal #{scanner.matched.inspect}: must be a single character"
+
+        else
+          fail "FAILED TO SCAN at pos #{scanner.pos}, Next chars: #{scanner.rest[0, 20].inspect}"
+        end
+      end
+
+      tokens
+    end
+
+    private
+
+    def tokenize_string(scanner)
+      tokens = []
+      value = +''
+      chunk_start = scanner.pos
+
+      until scanner.eos?
+        case
+        when scanner.scan(/\n/)
+          tokens << Token.new(:string_chunk, value, chunk_start...(scanner.pos - 1))
+          return tokens
+
+        when scanner.scan(/\A"/)
+          tokens << Token.new(:string_chunk, value, chunk_start...(scanner.pos - 1))
+          tokens << tok(:quote, scanner)
+          return tokens
+
+        when scanner.scan(/\A\\n/)  then value << "\n"
+        when scanner.scan(/\A\\t/)  then value << "\t"
+        when scanner.scan(/\A\\r/)  then value << "\r"
+        when scanner.scan(/\A\\"/)  then value << '"'
+        when scanner.scan(/\A\\\\/) then value << '\\'
+
+        else
+          value << scanner.getch
+        end
+      end
+
+      tokens << Token.new(:string_chunk, value, chunk_start...scanner.pos)
+      tokens
+    end
+
+    def tok(type, scanner)
+      Token.new(type, scanner.matched, range(scanner))
+    end
+
+    def range(scanner) 
+      (scanner.pos - scanner.matched_size)...scanner.pos
+    end
+
+    def string_chunk_tok(scanner, chunk_start)
+      range = chunk_start...(scanner.pos - 1)
+
+      Token.new(
+        :string_chunk,
+        scanner.string[range],
+        range,
+      )
+    end
+  end
+end