kapusta 0.2.4 → 0.4.1

data/lib/kapusta/compiler/emitter/patterns.rb

@@ -11,174 +11,257 @@ module Kapusta
             return ['', env] if pattern.name == '_'
 
             ruby_name = define_local(env, pattern)
-            ["#{ruby_name} = #{value_code}", env]
+            return ["#{ruby_name} = #{value_code}", env]
+          end
+
+          native = try_emit_native_pattern_bind(pattern, value_code, env)
+          return native if native
+
+          emit_error!("destructure pattern this compiler cannot translate: #{pattern.inspect}")
+        end
+
+        def try_emit_native_pattern_bind(pattern, value_code, env)
+          case pattern
+          when Vec
+            try_emit_native_vec_bind(pattern, value_code, env)
+          when HashLit
+            try_emit_native_hash_bind(pattern, value_code, env)
+          end
+        rescue PatternNotTranslatable
+          nil
+        end
+
+        def try_emit_native_vec_bind(pattern, value_code, env)
+          parts = []
+          deferred = []
+          current_env = env
+          items = pattern.items
+          i = 0
+          while i < items.length
+            if items[i].is_a?(Sym) && items[i].name == '&'
+              sub = items[i + 1]
+              raise PatternNotTranslatable unless sub.is_a?(Sym)
+
+              parts << native_rest_target(sub, current_env)
+              i += 2
+            else
+              code, current_env, follow_up = native_destructure_target(items[i], current_env, allow_follow_up: true)
+              parts << code
+              deferred << follow_up if follow_up
+              i += 1
+            end
+          end
+          if deferred.empty?
+            ["#{parts.join(', ')} = #{value_code}", current_env]
           else
-            bindings_var = temp('bindings')
-            current_env = env
-            lines = [
-              "#{bindings_var} = #{runtime_call(:destructure, emit_pattern(pattern), value_code)}"
-            ]
-            pattern_names(pattern).each do |name|
-              ruby_name = define_local(current_env, name)
-              lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
+            arr_var = simple_expression?(value_code) ? value_code : temp('array')
+            lines = []
+            lines << "#{arr_var} = #{value_code}" unless arr_var == value_code
+            lines << "#{parts.join(', ')} = #{arr_var}"
+            deferred.each do |follow_up|
+              sub_code, current_env = follow_up.call(current_env)
+              lines << sub_code
             end
             [lines.join("\n"), current_env]
           end
         end
 
-        def emit_bindings_from_match(binding_names, bindings_var, env)
-          current_env = env
+        def try_emit_native_hash_bind(pattern, value_code, env)
+          pairs = pattern.pairs
+          raise PatternNotTranslatable if pairs.empty?
+
+          temp_var = simple_expression?(value_code) ? value_code : temp('hash')
           lines = []
-          binding_names.each do |name|
-            ruby_name = define_local(current_env, name)
-            lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
+          lines << "#{temp_var} = #{value_code}" unless temp_var == value_code
+          current_env = env
+          pairs.each do |key, sub|
+            access = "#{temp_var}[#{key.inspect}]"
+            if sub.is_a?(Sym)
+              raise PatternNotTranslatable if sub.name == '_'
+
+              ruby_name = define_local(current_env, sub.name)
+              lines << "#{ruby_name} = #{access}"
+            else
+              sub_code, current_env = try_emit_native_pattern_bind(sub, access, current_env) ||
+                                      raise(PatternNotTranslatable)
+              lines << sub_code
+            end
           end
           [lines.join("\n"), current_env]
         end
 
-        def pattern_match_plan(pattern, env, mode:, allow_pins:)
-          state = { bound_names: {}, binding_names: [] }
+        def native_destructure_target(pattern, env, allow_follow_up: false)
+          case pattern
+          when Sym
+            return ['_', env, nil] if pattern.name == '_'
+
+            ruby_name = define_local(env, pattern.name)
+            [ruby_name, env, nil]
+          when Vec
+            inner = []
+            current = env
+            deferred = []
+            items = pattern.items
+            i = 0
+            while i < items.length
+              if items[i].is_a?(Sym) && items[i].name == '&'
+                inner << native_rest_target(items[i + 1], current)
+                i += 2
+              else
+                code, current, follow_up = native_destructure_target(items[i], current)
+                inner << code
+                deferred << follow_up if follow_up
+                i += 1
+              end
+            end
+            raise PatternNotTranslatable unless deferred.empty?
+
+            ["(#{inner.join(', ')})", current, nil]
+          when HashLit
+            raise PatternNotTranslatable unless allow_follow_up
+
+            slot = temp('slot')
+            follow_up = lambda do |outer_env|
+              try_emit_native_hash_bind(pattern, slot, outer_env) || raise(PatternNotTranslatable)
+            end
+            [slot, env, follow_up]
+          else
+            raise PatternNotTranslatable
+          end
+        end
+
+        def native_rest_target(sym, env)
+          raise PatternNotTranslatable unless sym.is_a?(Sym)
+
+          return '*' if sym.name == '_'
+
+          "*#{define_local(env, sym.name)}"
+        end
+
+        class PatternNotTranslatable < StandardError; end
+
+        def native_pattern_plan(pattern, env, mode:, allow_pins:)
+          state = { bound_names: {}, binding_names: [], guards: [] }
+          ruby_pattern = compile_native_pattern(pattern, env, mode:, allow_pins:, state:)
           {
-            pattern: emit_match_pattern(pattern, env, mode:, allow_pins:, state:),
+            pattern: ruby_pattern,
+            guards: state[:guards],
             bindings: state[:binding_names]
           }
+        rescue PatternNotTranslatable
+          nil
         end
 
-        def emit_match_pattern(pattern, env, mode:, allow_pins:, state:)
+        def compile_native_pattern(pattern, env, mode:, allow_pins:, state:)
           case pattern
-          when Sym
-            emit_symbol_match_pattern(pattern, env, mode:, state:)
-          when Vec
-            emit_sequence_match_pattern(pattern.items, env, mode:, allow_pins:, state:)
-          when HashLit
-            pairs = pattern.pairs.map do |key, value|
-              "[#{key.inspect}, #{emit_match_pattern(value, env, mode:, allow_pins:, state:)}]"
-            end
-            "[:hash, [#{pairs.join(', ')}]]"
+          when Sym then compile_native_symbol(pattern, env, mode:, state:)
+          when Vec then compile_native_sequence(pattern.items, env, mode:, allow_pins:, state:)
+          when HashLit then compile_native_hash(pattern, env, mode:, allow_pins:, state:)
           when List
             if pin_pattern?(pattern)
-              emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
+              compile_native_pin(pattern, env, mode:, allow_pins:)
             elsif or_pattern?(pattern)
-              emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
-            elsif where_pattern?(pattern)
-              emit_error!('`where` is only valid as a case/match clause head')
+              compile_native_or(pattern, env, mode:, allow_pins:, state:)
             else
-              emit_sequence_match_pattern(pattern.items, env, mode:, allow_pins:, state:)
+              compile_native_sequence(pattern.items, env, mode:, allow_pins:, state:)
             end
-          when nil
-            '[:lit, nil]'
-          when Symbol, String, Numeric, true, false
-            "[:lit, #{pattern.inspect}]"
-          else
-            emit_error!("bad pattern: #{pattern.inspect}")
+          when nil then 'nil'
+          when Symbol, String, Numeric, true, false then pattern.inspect
+          else raise PatternNotTranslatable
           end
         end
 
-        def emit_symbol_match_pattern(pattern, env, mode:, state:)
+        def compile_native_symbol(pattern, env, mode:, state:)
           name = pattern.name
+          return '_' if name == '_'
 
-          if name == '_'
-            '[:wild]'
-          elsif nil_allowing_pattern_name?(name)
-            bind_name = name.start_with?('?') ? name.delete_prefix('?') : name
-            emit_named_match_pattern(bind_name, env, mode:, state:, allow_nil: true, prefer_pin: false)
-          else
-            emit_named_match_pattern(name, env, mode:, state:, allow_nil: false, prefer_pin: true)
-          end
-        end
+          if nil_allowing_pattern_name?(name)
+            raise PatternNotTranslatable if state[:bound_names].key?(name)
 
-        def emit_named_match_pattern(name, env, mode:, state:, allow_nil:, prefer_pin:)
-          binding = prefer_pin && mode == :match ? env.lookup_if_defined(name) : nil
-          if state[:bound_names].key?(name)
-            "[:ref, #{name.inspect}]"
-          elsif binding
-            "[:pin, #{binding_value_code(binding)}]"
-          else
             state[:bound_names][name] = true
             state[:binding_names] << name
-            "[:bind, #{name.inspect}, #{allow_nil}]"
+            sanitize_local(name)
+          else
+            binding = mode == :match ? env.lookup_if_defined(name) : nil
+            if state[:bound_names].key?(name)
+              raise PatternNotTranslatable
+            elsif binding
+              "^(#{binding_value_code(binding)})"
+            else
+              state[:bound_names][name] = true
+              state[:binding_names] << name
+              ruby = sanitize_local(name)
+              state[:guards] << "!#{ruby}.nil?"
+              ruby
+            end
           end
         end
 
-        def emit_sequence_match_pattern(items, env, mode:, allow_pins:, state:)
+        def compile_native_sequence(items, env, mode:, allow_pins:, state:)
           parts = []
+          has_rest = false
           i = 0
           while i < items.length
             if rest_pattern_marker?(items, i)
-              parts << "[:rest, #{emit_match_pattern(items[i + 1], env, mode:, allow_pins:, state:)}]"
+              has_rest = true
+              sub = items[i + 1]
+              raise PatternNotTranslatable unless sub.is_a?(Sym)
+
+              if sub.name == '_'
+                parts << '*'
+              else
+                state[:bound_names][sub.name] = true
+                state[:binding_names] << sub.name
+                parts << "*#{sanitize_local(sub.name)}"
+              end
               i += 2
             else
-              parts << emit_match_pattern(items[i], env, mode:, allow_pins:, state:)
+              parts << compile_native_pattern(items[i], env, mode:, allow_pins:, state:)
               i += 1
             end
           end
-          "[:vec, [#{parts.join(', ')}]]"
+          parts << '*' unless has_rest
+          "[#{parts.join(', ')}]"
+        end
+
+        def compile_native_hash(pattern, env, mode:, allow_pins:, state:)
+          pairs = pattern.pairs.map do |key, value|
+            raise PatternNotTranslatable unless key.is_a?(Symbol)
+
+            "#{key}: #{compile_native_pattern(value, env, mode:, allow_pins:, state:)}"
+          end
+          "{#{pairs.join(', ')}}"
         end
 
-        def emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
-          emit_error!('pin patterns are only supported inside `case` guards') unless allow_pins && mode == :case
+        def compile_native_pin(pattern, env, mode:, allow_pins:)
+          raise PatternNotTranslatable unless allow_pins && mode == :case
 
           name_sym = pattern.items[1]
-          emit_error!("bad pin pattern: #{pattern.inspect}") unless name_sym.is_a?(Sym)
+          raise PatternNotTranslatable unless name_sym.is_a?(Sym)
 
           binding = env.lookup_if_defined(name_sym.name)
-          emit_error!("cannot pin undefined name: #{name_sym.name}") unless binding
+          raise PatternNotTranslatable unless binding
 
-          "[:pin, #{binding_value_code(binding)}]"
+          "^(#{binding_value_code(binding)})"
         end
 
-        def emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
-          initial_names = state[:binding_names].length
+        def compile_native_or(pattern, env, mode:, allow_pins:, state:)
           initial_bound = state[:bound_names].dup
-          canonical_names = nil
+          initial_names = state[:binding_names].length
+          initial_guards = state[:guards].length
           variants = pattern.items[1..].map do |subpattern|
             alt_state = {
               bound_names: initial_bound.dup,
-              binding_names: state[:binding_names].dup
+              binding_names: state[:binding_names].dup,
+              guards: state[:guards].dup
             }
-            compiled = emit_match_pattern(subpattern, env, mode:, allow_pins:, state: alt_state)
-            alt_names = alt_state[:binding_names][initial_names..]
-            canonical_names ||= alt_names
-            emit_error!('all `or` patterns must bind the same names') if canonical_names.sort != alt_names.sort
+            compiled = compile_native_pattern(subpattern, env, mode:, allow_pins:, state: alt_state)
+            raise PatternNotTranslatable if alt_state[:binding_names].length > initial_names
+            raise PatternNotTranslatable if alt_state[:guards].length > initial_guards
 
             compiled
           end
-
-          canonical_names.each do |name|
-            state[:bound_names][name] = true
-            state[:binding_names] << name
-          end
-          "[:or, [#{variants.join(', ')}]]"
-        end
-
-        def emit_pattern(pattern)
-          case pattern
-          when Sym
-            pattern.name == '_' ? '[:sym, "_"]' : "[:sym, #{pattern.name.inspect}]"
-          when Vec
-            parts = []
-            items = pattern.items
-            i = 0
-            while i < items.length
-              if items[i].is_a?(Sym) && items[i].name == '&'
-                parts << "[:rest, #{emit_pattern(items[i + 1])}]"
-                i += 2
-              else
-                parts << emit_pattern(items[i])
-                i += 1
-              end
-            end
-            "[:vec, [#{parts.join(', ')}]]"
-          when HashLit
-            pairs = pattern.pairs.map { |key, value| "[#{key.inspect}, #{emit_pattern(value)}]" }
-            "[:hash, [#{pairs.join(', ')}]]"
-          when nil
-            '[:nil]'
-          when Symbol, String, Numeric, true, false
-            "[:lit, #{pattern.inspect}]"
-          else
-            emit_error!("bad pattern: #{pattern.inspect}")
-          end
+          "(#{variants.join(' | ')})"
         end
 
         def pattern_names(pattern)

data/lib/kapusta/compiler/emitter/support.rb

@@ -62,7 +62,7 @@ module Kapusta
           else
             name_sym, supers, = split_class_args(form.items[1..])
             body = emit_forms_with_headers(remaining_forms, env, :class, result: false)
-            emit_direct_class_header(name_sym, supers, body) || emit_class_wrapper(name_sym, supers, env, body)
+            emit_direct_class_header(name_sym, supers, body, env) || emit_class_wrapper(name_sym, supers, env, body)
           end
         end
 
@@ -128,7 +128,7 @@ module Kapusta
             return [emit_for_statement(form.rest, env, current_scope), env]
           when 'each'
             code = emit_each_statement(form.rest, env, current_scope)
-            return ["#{code}\nnil", env] if result_needed
+            return ["#{code}\nnil", env] if result_needed && current_scope != :toplevel
 
             return [code, env]
           end
@@ -219,19 +219,6 @@ module Kapusta
           source_name.is_a?(GeneratedSym)
         end
 
-        def runtime_helper(name)
-          helper = name.to_sym
-          @runtime_helpers << helper unless @runtime_helpers.include?(helper)
-          Runtime.helper_name(helper)
-        end
-
-        def runtime_call(name, *args)
-          rendered_args = args.map do |arg|
-            arg.is_a?(Array) ? "[#{arg.join(', ')}]" : arg || 'nil'
-          end
-          "#{runtime_helper(name)}(#{rendered_args.join(', ')})"
-        end
-
         def method_binding?(binding)
           binding.is_a?(Env::MethodBinding)
         end
@@ -276,7 +263,8 @@ module Kapusta
 
         def sanitize_local(name)
           base = Kapusta.kebab_to_snake(name.respond_to?(:name) ? name.name : name)
-          base = base.gsub('?', '_q').gsub('!', '_bang')
+          base = base.sub(/\A\?/, 'q_').gsub('?', '_q')
+          base = base.sub(/\A!/, 'bang_').gsub('!', '_bang')
           base = base.gsub(/[^a-zA-Z0-9_]/, '_')
           if base.empty? || base.match?(/\A\d/) || base.match?(/\A[A-Z]/) || self.class::RUBY_KEYWORDS.include?(base)
             base = "_#{base}"

data/lib/kapusta/compiler/emitter.rb

@@ -27,14 +27,12 @@ module Kapusta
       def initialize(path:)
         @path = path
         @temp_index = 0
-        @runtime_helpers = []
       end
 
       def emit_file(forms)
         env = Env.new
         body = emit_forms_with_headers(forms, env, :toplevel)
-        helpers = Runtime.helper_source(@runtime_helpers)
-        [helpers, body].reject(&:empty?).join("\n\n") << "\n"
+        "#{body}\n"
       end
     end
   end

data/lib/kapusta/compiler/macro_expander.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    class MacroExpander
+      class Error < Kapusta::Error; end
+
+      @gensym_counter = 0
+
+      class << self
+        def fresh_gensym(prefix)
+          @gensym_counter += 1
+          GeneratedSym.new("#{prefix}_g#{@gensym_counter}", @gensym_counter)
+        end
+
+        def fresh_local_gensym(prefix)
+          @gensym_counter += 1
+          GeneratedSym.new("#{prefix}_local_#{@gensym_counter}", @gensym_counter)
+        end
+      end
+
+      def initialize
+        @macros = {}
+      end
+
+      def expand_all(forms)
+        forms.flat_map { |form| expand_top(form) }
+      end
+
+      private
+
+      def expand_top(form)
+        if form.is_a?(List) && form.head.is_a?(Sym)
+          case form.head.name
+          when 'macro'
+            register_macro_form(form.rest)
+            return []
+          when 'macros'
+            register_macros_form(form.rest)
+            return []
+          when 'import-macros'
+            raise Error, 'import-macros is not yet supported'
+          end
+        end
+        [expand(form)]
+      end
+
+      def expand(form)
+        case form
+        when List then expand_list(form)
+        when Vec then Vec.new(form.items.map { |item| expand(item) })
+        when HashLit
+          HashLit.new(form.entries.map do |entry|
+            entry.is_a?(Array) ? [expand(entry[0]), expand(entry[1])] : entry
+          end)
+        else
+          form
+        end
+      end
+
+      def expand_list(list)
+        return list if list.empty?
+
+        head = list.head
+        if head.is_a?(Sym) && !head.is_a?(AutoGensym)
+          name = head.name
+          case name
+          when 'macro'
+            register_macro_form(list.rest)
+            return List.new([Sym.new('do')])
+          when 'macros'
+            register_macros_form(list.rest)
+            return List.new([Sym.new('do')])
+          end
+
+          key = lookup_key(name)
+          if @macros.key?(key)
+            args = list.rest
+            result = invoke_macro(key, args)
+            return expand(result)
+          end
+        end
+
+        List.new(list.items.map { |item| expand(item) })
+      end
+
+      def lookup_key(name)
+        Kapusta.kebab_to_snake(name).to_sym
+      end
+
+      def register_macro_form(args)
+        name_sym, params, *body = args
+        raise Error, 'macro name must be a symbol' unless name_sym.is_a?(Sym)
+        raise Error, 'macro params must be a vector' unless params.is_a?(Vec)
+
+        register(name_sym.name, params, body)
+      end
+
+      def register_macros_form(args)
+        hash_lit = args[0]
+        raise Error, 'macros expects a hash literal' unless hash_lit.is_a?(HashLit)
+
+        hash_lit.pairs.each do |key, value|
+          raise Error, "macros entry value must be a fn form, got #{value.inspect}" unless fn_form?(value)
+
+          name = key.to_s
+          params = value.items[1]
+          body = value.items[2..]
+          raise Error, 'macros entry params must be a vector' unless params.is_a?(Vec)
+
+          register(name, params, body)
+        end
+      end
+
+      def fn_form?(value)
+        value.is_a?(List) && value.head.is_a?(Sym) && %w[fn lambda λ].include?(value.head.name)
+      end
+
+      def register(source_name, params, body)
+        proc_obj = compile_macro(source_name, params, body)
+        @macros[lookup_key(source_name)] = proc_obj
+      end
+
+      def compile_macro(name, params, body)
+        lowering = Lowering.new
+        lowered_body = body.map { |form| lowering.lower(form) }
+        gensym_locals = lowering.collected_gensyms
+
+        wrapped =
+          if gensym_locals.empty?
+            List.new([Sym.new('fn'), params, *lowered_body])
+          else
+            let_bindings = gensym_locals.flat_map do |gensym_sym, prefix|
+              [gensym_sym, List.new([Sym.new('quasi-gensym'), prefix])]
+            end
+            inner = lowered_body.length == 1 ? lowered_body.first : List.new([Sym.new('do'), *lowered_body])
+            List.new([Sym.new('fn'), params, List.new([Sym.new('let'), Vec.new(let_bindings), inner])])
+          end
+
+        ruby = Compiler.compile_forms([wrapped], path: "(macro #{name})")
+        TOPLEVEL_BINDING.eval(ruby, "(macro #{name})", 1)
+      end
+
+      def invoke_macro(key, args)
+        proc_obj = @macros[key]
+        proc_obj.call(*args)
+      end
+
+      class Lowering
+        def initialize
+          @gensyms = {}
+        end
+
+        def collected_gensyms
+          @gensyms.map { |prefix, sym| [sym, prefix] }
+        end
+
+        def lower(form)
+          case form
+          when Quasiquote then lower_quasi(form.form)
+          when Unquote, UnquoteSplice
+            raise Error, 'unquote outside quasiquote'
+          when AutoGensym
+            raise Error, "auto-gensym #{form.name}# outside quasiquote"
+          when List then List.new(form.items.map { |item| lower(item) })
+          when Vec then Vec.new(form.items.map { |item| lower(item) })
+          when HashLit
+            HashLit.new(form.entries.map do |entry|
+              entry.is_a?(Array) ? [lower(entry[0]), lower(entry[1])] : entry
+            end)
+          else
+            form
+          end
+        end
+
+        def lower_quasi(form)
+          case form
+          when AutoGensym then gensym_local_for(form.name)
+          when Sym then List.new([Sym.new('quasi-sym'), form.name])
+          when List then lower_quasi_list(form)
+          when Vec then lower_quasi_vec(form)
+          when HashLit then lower_quasi_hash(form)
+          when Unquote then lower(form.form)
+          when UnquoteSplice
+            raise Error, 'unquote-splice must appear inside a quoted list/vec'
+          when Quasiquote
+            raise Error, 'nested quasiquote is not supported'
+          else
+            form
+          end
+        end
+
+        def lower_quasi_list(list)
+          items = list.items
+          return List.new([Sym.new('quasi-list')]) if items.empty?
+
+          if (tail_expr = splice_tail(items))
+            head_items = items[0...-1].map { |item| lower_quasi(item) }
+            return List.new([Sym.new('quasi-list-tail'), Vec.new(head_items), tail_expr])
+          end
+
+          lowered_items = items.map { |item| lower_quasi_item(item) }
+          List.new([Sym.new('quasi-list'), *lowered_items])
+        end
+
+        def lower_quasi_vec(vec)
+          items = vec.items
+          if (tail_expr = splice_tail(items))
+            head_items = items[0...-1].map { |item| lower_quasi(item) }
+            return List.new([Sym.new('quasi-vec-tail'), Vec.new(head_items), tail_expr])
+          end
+
+          lowered_items = items.map { |item| lower_quasi_item(item) }
+          List.new([Sym.new('quasi-vec'), *lowered_items])
+        end
+
+        def lower_quasi_hash(hash)
+          parts = []
+          hash.entries.each do |entry|
+            next unless entry.is_a?(Array)
+
+            key, value = entry
+            parts << lower_quasi(key) << lower_quasi(value)
+          end
+          List.new([Sym.new('quasi-hash'), *parts])
+        end
+
+        def lower_quasi_item(item)
+          if item.is_a?(Unquote) && unpack_call?(item.form)
+            inner = lower(item.form.items[1])
+            List.new([Sym.new('.'), inner, 0])
+          else
+            lower_quasi(item)
+          end
+        end
+
+        def splice_tail(items)
+          last = items.last
+          return unless last
+          return lower(last.form) if last.is_a?(UnquoteSplice)
+          return lower(last.form.items[1]) if last.is_a?(Unquote) && unpack_call?(last.form)
+
+          nil
+        end
+
+        def unpack_call?(form)
+          form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'unpack'
+        end
+
+        def gensym_local_for(prefix)
+          @gensyms[prefix] ||= MacroExpander.fresh_local_gensym(prefix)
+        end
+      end
+    end
+  end
+end