kapusta 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2398c1c908306ac808914717a67e74f8085ee6048deb9c9dd665f4dd8c39cc2f
-  data.tar.gz: 1022c2df415418d26f1b84b1b16830cc525829182a82e93c1a450d0dd4b5bdd2
+  metadata.gz: 52369f7a4cd658385e7ddc69f552477d94b55340cb9f796ac635550a7def6e6a
+  data.tar.gz: 6d673c9c387b52b0e4cd9e55b8ae2cf1d0a7e2c5f741dc7705f405b0ddaf25c6
 SHA512:
-  metadata.gz: 6a31f0bab47d9c5c0d40720c52422717e0d04a9c03bb03a115ac62c7f541226dc3d9b7e9aa052bf55d574e1193ecab82e97b0610d43bbe1702038024486a1953
-  data.tar.gz: f20bf20a890d1b23f3ec7d2d113a3340c6255132a367a655cddab52ded9e2276bd236439d242ca0ea46f857096a5f5885620dd9a104f8b0f337c9aba75e50366
+  metadata.gz: 53510507ba41a4d67ec73184eaef665fee182220407046eb9db64cf05cae7d28a315b5b8cf4ace6071b359a83801bd85d7e45ce5e4aefd3c608fef614f116fee
+  data.tar.gz: ff1b88fc11dc10ccffc1459686b17754bd39dc6a941756d7cab304253aec3b63bc36967c9edcf50cf4c29eadee3ae2afb0467383b6428dcb74f41c452173ab4a

data/README.md

@@ -41,6 +41,7 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 | `string.format`, `table.insert`, etc. | use Ruby methods and stdlib instead                   |
 | `values` uses Lua multiple returns    | `values` lowers to a Ruby array, usually destructured |
 | `with-open`, `tail!`                  | not provided                                          |
+| macros                                | not provided for now                                  |
 
 Kapusta-specific additions:
 

data/bin/compile-examples

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SOURCE_DIR="$ROOT_DIR/examples"
+TARGET_DIR="$ROOT_DIR/examples-compiled"
+
+mkdir -p "$TARGET_DIR"
+
+shopt -s nullglob
+kap_files=("$SOURCE_DIR"/*.kap)
+
+if ((${#kap_files[@]} == 0)); then
+  printf 'No .kap files found in %s\n' "$SOURCE_DIR" >&2
+  exit 0
+fi
+
+for kap_file in "${kap_files[@]}"; do
+  name="$(basename "$kap_file" .kap)"
+  ruby_file="$TARGET_DIR/$name.rb"
+
+  "$ROOT_DIR/exe/kapusta" --compile "$kap_file" > "$ruby_file"
+  printf 'Compiled %s -> %s\n' "$kap_file" "$ruby_file"
+done

data/examples/contains-duplicate.kap

@@ -0,0 +1,7 @@
+(fn contains-duplicate? [nums]
+  (let [seen (collect [n nums] (values n true))]
+    (< (length seen) (length nums))))
+
+(print (contains-duplicate? [1 2 3 1]))
+(print (contains-duplicate? [1 2 3 4]))
+(print (contains-duplicate? [1 1 1 3 3 4 3 2 4 2]))

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

@@ -13,9 +13,8 @@ module Kapusta
             name_sym = args[0]
             pattern = args[1]
             body = args[2..]
-            ruby_name = temp(sanitize_local(name_sym.name))
             fn_env = env.child
-            fn_env.define(name_sym.name, ruby_name)
+            ruby_name = define_local(fn_env, name_sym.name)
             <<~RUBY.chomp
               (-> do
                 #{ruby_name} = nil
@@ -27,22 +26,65 @@ module Kapusta
         end
 
         def emit_lambda(pattern, body, env, current_scope)
+          return emit_simple_lambda(pattern, body, env, current_scope) if simple_parameter_pattern?(pattern)
+
           args_var = temp('args')
           body_env = env.child
           bindings_code, body_env = emit_pattern_bind(pattern, args_var, body_env)
           body_code, = emit_sequence(body, body_env, current_scope, allow_method_definitions: false)
-          <<~RUBY.chomp
-            ->(*#{args_var}) do
-              #{bindings_code}
-              #{body_code}
-            end
-          RUBY
+          block_locals = pattern_names(pattern).map { |name| body_env.lookup(name) }.uniq
+          block_locals_clause = block_locals.empty? ? '' : "; #{block_locals.join(', ')}"
+          [
+            "->(*#{args_var}#{block_locals_clause}) do",
+            indent(join_code(bindings_code, body_code)),
+            'end'
+          ].join("\n")
+        end
+
+        def emit_simple_lambda(pattern, body, env, current_scope)
+          body_env = env.child
+          params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
+          body_code, = emit_sequence(body, body_env, current_scope, allow_method_definitions: false)
+          header = params.empty? ? 'proc do' : "proc do |#{params.join(', ')}|"
+          [
+            header,
+            indent(body_code),
+            'end'
+          ].join("\n")
+        end
+
+        def simple_parameter_pattern?(pattern)
+          pattern.is_a?(Vec) && pattern.items.all? { |item| item.is_a?(Sym) && !item.dotted? && item.name != '&' }
+        end
+
+        def emit_definition_form(form, env, current_scope)
+          return [emit_method_definition(form, env), env] unless current_scope == :toplevel
+
+          emit_toplevel_method_definition(form, env)
+        end
+
+        def emit_toplevel_method_definition(form, env)
+          name_sym = form.items[1]
+          pattern = form.items[2]
+          body = form.items[3..]
+          return [nil, env] if name_sym.dotted?
+          return [nil, env] unless simple_parameter_pattern?(pattern)
+
+          ruby_name = direct_method_definition_name(name_sym)
+          return [nil, env] unless ruby_name
+          return [nil, env] if captures_outer_binding?(body, env, pattern_names(pattern))
+
+          env.define(name_sym.name, Env::MethodBinding.new(ruby_name))
+          definition = emit_direct_method_definition(name_sym, pattern, body, env)
+          if needs_toplevel_method_bridge?(ruby_name)
+            definition = join_code(definition, emit_toplevel_method_bridge(ruby_name))
+          end
+          [definition, env]
         end
 
         def emit_named_fn_assignment(form, env, current_scope)
           name_sym = form.items[1]
-          ruby_name = temp(sanitize_local(name_sym.name))
-          env.define(name_sym.name, ruby_name)
+          ruby_name = define_local(env, name_sym.name)
           fn_env = env.child
           fn_env.define(name_sym.name, ruby_name)
           lambda_code = emit_lambda(form.items[2], form.items[3..], fn_env, current_scope)
@@ -53,31 +95,131 @@ module Kapusta
           name_sym = form.items[1]
           pattern = form.items[2]
           body = form.items[3..]
-          method_env = env.child
-          args_var = temp('args')
-          bindings_code, body_env = emit_pattern_bind(pattern, args_var, method_env)
-          body_code, = emit_sequence(body, body_env, :toplevel, allow_method_definitions: false)
+          direct_definition = emit_direct_method_definition(name_sym, pattern, body, env)
+          return direct_definition if direct_definition
+
+          block_header, body_code = emit_method_body(pattern, body, env)
 
           if name_sym.name.start_with?('self.')
             ruby_name = Kapusta.kebab_to_snake(name_sym.name.delete_prefix('self.')).to_sym.inspect
-            <<~RUBY.chomp
-              define_singleton_method(#{ruby_name}) do |*#{args_var}|
-                #{bindings_code}
-                #{body_code}
-              end
-            RUBY
+            [
+              "define_singleton_method(#{ruby_name}) #{block_header}",
+              indent(body_code),
+              'end'
+            ].join("\n")
           else
             ruby_name = Kapusta.kebab_to_snake(name_sym.name).to_sym.inspect
-            <<~RUBY.chomp
-              define_method(#{ruby_name}) do |*#{args_var}|
-                #{bindings_code}
-                #{body_code}
-              end
-            RUBY
+            [
+              "define_method(#{ruby_name}) #{block_header}",
+              indent(body_code),
+              'end'
+            ].join("\n")
+          end
+        end
+
+        def emit_direct_method_definition(name_sym, pattern, body, env)
+          return unless simple_parameter_pattern?(pattern)
+
+          ruby_name = direct_method_definition_name(name_sym)
+          return unless ruby_name
+          return if captures_outer_binding?(body, env, pattern_names(pattern))
+
+          body_env = env.child
+          params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
+          body_code, = emit_sequence(body, body_env, :toplevel, allow_method_definitions: false)
+          header = params.empty? ? "def #{ruby_name}" : "def #{ruby_name}(#{params.join(', ')})"
+          [
+            header,
+            indent(body_code),
+            'end'
+          ].join("\n")
+        end
+
+        def direct_method_definition_name(name_sym)
+          source_name = name_sym.name
+          if source_name.start_with?('self.')
+            method_name = Kapusta.kebab_to_snake(source_name.delete_prefix('self.'))
+            return unless direct_method_name?(method_name)
+
+            "self.#{method_name}"
+          else
+            method_name = Kapusta.kebab_to_snake(source_name)
+            return unless direct_method_name?(method_name)
+
+            method_name
           end
         end
 
+        def needs_toplevel_method_bridge?(ruby_name)
+          %w[context describe example it specify].include?(ruby_name)
+        end
+
+        def emit_toplevel_method_bridge(ruby_name)
+          method_name = ruby_name.to_sym.inspect
+          "define_singleton_method(#{method_name}, Object.instance_method(#{method_name}).bind(self))"
+        end
+
+        def emit_method_body(pattern, body, env)
+          return emit_simple_method_body(pattern, body, env) if simple_parameter_pattern?(pattern)
+
+          args_var = temp('args')
+          method_env = env.child
+          bindings_code, body_env = emit_pattern_bind(pattern, args_var, method_env)
+          body_code, = emit_sequence(body, body_env, :toplevel, allow_method_definitions: false)
+          block_locals = pattern_names(pattern).map { |name| body_env.lookup(name) }.uniq
+          block_locals_clause = block_locals.empty? ? '' : "; #{block_locals.join(', ')}"
+          ["do |*#{args_var}#{block_locals_clause}|", join_code(bindings_code, body_code)]
+        end
+
+        def emit_simple_method_body(pattern, body, env)
+          body_env = env.child
+          params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
+          body_code, = emit_sequence(body, body_env, :toplevel, allow_method_definitions: false)
+          [params.empty? ? 'do' : "do |#{params.join(', ')}|", body_code]
+        end
+
+        def captures_outer_binding?(forms, env, local_names)
+          forms.any? { |form| form_captures_outer_binding?(form, env, local_names) }
+        end
+
+        def form_captures_outer_binding?(form, env, local_names)
+          case form
+          when Sym
+            sym_captures_outer_binding?(form, env, local_names)
+          when Vec, List
+            form.items.any? { |item| form_captures_outer_binding?(item, env, local_names) }
+          when HashLit
+            form.pairs.any? do |key, value|
+              form_captures_outer_binding?(key, env, local_names) ||
+                form_captures_outer_binding?(value, env, local_names)
+            end
+          else
+            false
+          end
+        end
+
+        def sym_captures_outer_binding?(sym, env, local_names)
+          name = sym.dotted? ? sym.segments.first : sym.name
+          return false if local_names.include?(name) || !env.defined?(name)
+
+          !method_binding?(env.lookup(name))
+        end
+
         def emit_let(args, env, current_scope)
+          binding_code, body_code = emit_let_parts(args, env, current_scope, result: true)
+          <<~RUBY.chomp
+            (-> do
+              #{indent(join_code(binding_code, body_code))}
+            end).call
+          RUBY
+        end
+
+        def emit_let_statement(args, env, current_scope)
+          binding_code, body_code = emit_let_parts(args, env, current_scope, result: false)
+          join_code(binding_code, body_code)
+        end
+
+        def emit_let_parts(args, env, current_scope, result:)
           bindings = args[0]
           body = args[1..]
           child_env = env.child
@@ -91,13 +233,14 @@ module Kapusta
             binding_codes << bind_code
             i += 2
           end
-          body_code, = emit_sequence(body, child_env, current_scope, allow_method_definitions: false)
-          <<~RUBY.chomp
-            (-> do
-              #{binding_codes.join("\n")}
-              #{body_code}
-            end).call
-          RUBY
+          body_code, = emit_sequence(body, child_env, current_scope,
+                                     allow_method_definitions: false,
+                                     result:)
+          [binding_codes.join("\n"), body_code]
+        end
+
+        def join_code(*chunks)
+          chunks.reject(&:empty?).join("\n")
         end
 
         def emit_local_form(form, env, current_scope)
@@ -105,8 +248,7 @@ module Kapusta
           value_code = emit_expr(form.items[2], env, current_scope)
 
           if target.is_a?(Sym)
-            ruby_name = temp(sanitize_local(target.name))
-            env.define(target.name, ruby_name)
+            ruby_name = define_local(env, target.name)
             ["#{ruby_name} = #{value_code}\nnil", env]
           else
             bind_code, env = emit_pattern_bind(target, value_code, env)
@@ -126,11 +268,12 @@ module Kapusta
           if target.is_a?(Sym) && !target.dotted?
             ruby_name =
               if env.defined?(target.name)
-                env.lookup(target.name)
+                binding = env.lookup(target.name)
+                raise Error, "cannot set method binding: #{target.name}" if method_binding?(binding)
+
+                binding
               else
-                fresh = temp(sanitize_local(target.name))
-                env.define(target.name, fresh)
-                fresh
+                define_local(env, target.name)
               end
             ["#{ruby_name} = #{value_code}", env]
           else
@@ -151,7 +294,10 @@ module Kapusta
               base_code, segments = multisym_base(target.segments, env)
               runtime_call(:set_method_path, base_code, segments.inspect, value_code)
             else
-              "#{env.lookup(target.name)} = #{value_code}"
+              binding = env.lookup(target.name)
+              raise Error, "cannot set method binding: #{target.name}" if method_binding?(binding)
+
+              "#{binding} = #{value_code}"
             end
           when List
             head = target.head
@@ -164,7 +310,12 @@ module Kapusta
             elsif head.is_a?(Sym) && head.name == 'cvar'
               runtime_call(:set_cvar, 'self', target.items[1].name.inspect, value_code)
             elsif head.is_a?(Sym) && head.name == 'gvar'
-              runtime_call(:set_gvar, target.items[1].name.inspect, value_code)
+              ruby_name = global_name(target.items[1].name)
+              if direct_global_name?(ruby_name)
+                "$#{ruby_name} = #{value_code}"
+              else
+                runtime_call(:set_gvar, target.items[1].name.inspect, value_code)
+              end
             else
               raise Error, "bad set target: #{target.inspect}"
             end

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

@@ -10,75 +10,39 @@ module Kapusta
           result_var = temp('result')
           iter_code = emit_iteration(args[0], env, current_scope) do |iter_env|
             body = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
-            <<~RUBY.chomp
-              __kap_value = begin
-              #{indent(body)}
-              end
-              #{result_var} << __kap_value unless __kap_value.nil?
-            RUBY
+            emit_array_collection_step(result_var, body)
           end
-          <<~RUBY.chomp
-            (-> do
-              #{result_var} = []
-              #{iter_code}
-              #{result_var}
-            end).call
-          RUBY
+          emit_collection_result(result_var, '[]', iter_code)
         end
 
         def emit_collect(args, env, current_scope)
           result_var = temp('result')
           iter_code = emit_iteration(args[0], env, current_scope) do |iter_env|
             body = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
-            <<~RUBY.chomp
-              __kap_pair = begin
-              #{indent(body)}
-              end
-              if __kap_pair.is_a?(Array) && __kap_pair.length == 2 && !__kap_pair[0].nil? && !__kap_pair[1].nil?
-                #{result_var}[__kap_pair[0]] = __kap_pair[1]
-              end
-            RUBY
+            emit_hash_collection_step(result_var, body)
           end
-          <<~RUBY.chomp
-            (-> do
-              #{result_var} = {}
-              #{iter_code}
-              #{result_var}
-            end).call
-          RUBY
+          emit_collection_result(result_var, '{}', iter_code)
         end
 
         def emit_fcollect(args, env, current_scope)
           result_var = temp('result')
           parsed = parse_counted_for_bindings(args[0].items, env, current_scope)
           body_code, = emit_sequence(args[1..], parsed[:loop_env], current_scope, allow_method_definitions: false)
-          collecting_body = <<~RUBY.chomp
-            __kap_value = begin
-            #{indent(body_code)}
-            end
-            #{result_var} << __kap_value unless __kap_value.nil?
-          RUBY
+          collecting_body = emit_array_collection_step(result_var, body_code)
           loop_code = emit_counted_loop(**parsed, current_scope:, body_code: collecting_body)
-          <<~RUBY.chomp
-            (-> do
-              #{result_var} = []
-              #{indent(loop_code)}
-              #{result_var}
-            end).call
-          RUBY
+          emit_collection_result(result_var, '[]', loop_code)
         end
 
         def emit_accumulate(args, env, current_scope)
           bindings = args[0].items
           acc_name = bindings[0]
-          acc_var = temp(sanitize_local(acc_name.name))
           iter_bindings = Vec.new(bindings[2..])
           loop_env = env.child
-          loop_env.define(acc_name.name, acc_var)
+          acc_var = define_local(loop_env, acc_name.name)
           iter_code = emit_iteration(iter_bindings, loop_env, current_scope) do |iter_env|
             iter_env.define(acc_name.name, acc_var)
             emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first.then do |body|
-              "#{acc_var} = begin\n#{indent(body)}\nend"
+              emit_sequence_value_assignment(acc_var, body)
             end
           end
           <<~RUBY.chomp
@@ -93,14 +57,12 @@ module Kapusta
         def emit_faccumulate(args, env, current_scope)
           bindings = args[0].items
           acc_name = bindings[0]
-          acc_var = temp(sanitize_local(acc_name.name))
           loop_name = bindings[2]
-          loop_var = temp(sanitize_local(loop_name.name))
           loop_env = env.child
-          loop_env.define(acc_name.name, acc_var)
-          loop_env.define(loop_name.name, loop_var)
+          acc_var = define_local(loop_env, acc_name.name)
+          loop_var = define_local(loop_env, loop_name.name)
           body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
-          accumulating_body = "#{acc_var} = begin\n#{indent(body_code)}\nend"
+          accumulating_body = emit_sequence_value_assignment(acc_var, body_code)
           loop_code = emit_counted_loop(
             ruby_name: loop_var,
             start_code: emit_expr(bindings[3], env, current_scope),
@@ -210,6 +172,42 @@ module Kapusta
           end.compact
           [codes.join("\n"), current_env]
         end
+
+        def emit_collection_result(result_var, initial_code, iter_code)
+          <<~RUBY.chomp
+            (-> do
+              #{result_var} = #{initial_code}
+              #{indent(iter_code)}
+              #{result_var}
+            end).call
+          RUBY
+        end
+
+        def emit_array_collection_step(result_var, body_code)
+          value_var = temp('value')
+          <<~RUBY.chomp
+            #{emit_sequence_value_assignment(value_var, body_code)}
+            #{result_var} << #{value_var} unless #{value_var}.nil?
+          RUBY
+        end
+
+        def emit_hash_collection_step(result_var, body_code)
+          pair_var = temp('pair')
+          <<~RUBY.chomp
+            #{emit_sequence_value_assignment(pair_var, body_code)}
+            if #{pair_var}.is_a?(Array) && #{pair_var}.length == 2 && !#{pair_var}[0].nil? && !#{pair_var}[1].nil?
+              #{result_var}[#{pair_var}[0]] = #{pair_var}[1]
+            end
+          RUBY
+        end
+
+        def emit_sequence_value_assignment(target_var, body_code)
+          <<~RUBY.chomp
+            #{target_var} = begin
+            #{indent(body_code)}
+            end
+          RUBY
+        end
       end
     end
   end

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

@@ -16,14 +16,35 @@ module Kapusta
 
           cond = emit_expr(args[0], env, current_scope)
           truthy = emit_expr(args[1], env, current_scope)
-          falsy = build_if(args[2..], env, current_scope)
-          <<~RUBY.chomp
-            if #{cond}
-              #{truthy}
-            else
-              #{indent(falsy)}
-            end
-          RUBY
+          lines = ["if #{cond}", indent(truthy)]
+          append_else_lines(lines, args[2..], env, current_scope)
+          lines << 'end'
+          lines.join("\n")
+        end
+
+        def append_else_lines(lines, args, env, current_scope)
+          return if args.empty?
+
+          if args.length == 1 && if_form?(args[0])
+            append_elsif_lines(lines, args[0].rest, env, current_scope)
+          elsif args.length >= 2
+            append_elsif_lines(lines, args, env, current_scope)
+          else
+            lines << 'else'
+            lines << indent(emit_expr(args[0], env, current_scope))
+          end
+        end
+
+        def append_elsif_lines(lines, args, env, current_scope)
+          return append_else_lines(lines, args, env, current_scope) if args.length < 2
+
+          lines << "elsif #{emit_expr(args[0], env, current_scope)}"
+          lines << indent(emit_expr(args[1], env, current_scope))
+          append_else_lines(lines, args[2..], env, current_scope)
+        end
+
+        def if_form?(form)
+          form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'if'
         end
 
         def emit_case(args, env, current_scope, mode)
@@ -106,21 +127,16 @@ module Kapusta
         end
 
         def emit_while(args, env, current_scope)
-          body_code, = emit_sequence(args[1..], env, current_scope, allow_method_definitions: false)
           <<~RUBY.chomp
             (-> do
-              while #{emit_expr(args[0], env, current_scope)}
-                #{indent(body_code)}
-              end
+              #{indent(emit_while_statement(args, env, current_scope))}
               nil
             end).call
           RUBY
         end
 
         def emit_for(args, env, current_scope)
-          parsed = parse_counted_for_bindings(args[0].items, env, current_scope)
-          body_code, = emit_sequence(args[1..], parsed[:loop_env], current_scope, allow_method_definitions: false)
-          loop_code = emit_counted_loop(**parsed, current_scope:, body_code:)
+          loop_code = emit_for_statement(args, env, current_scope)
           <<~RUBY.chomp
             (-> do
               #{indent(loop_code)}
@@ -130,9 +146,7 @@ module Kapusta
         end
 
         def emit_each(args, env, current_scope)
-          iter_code = emit_iteration(args[0], env, current_scope) do |iter_env|
-            emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
-          end
+          iter_code = emit_each_statement(args, env, current_scope)
           <<~RUBY.chomp
             (-> do
               #{iter_code}
@@ -140,6 +154,33 @@ module Kapusta
             end).call
           RUBY
         end
+
+        def emit_while_statement(args, env, current_scope)
+          body_code, = emit_sequence(args[1..], env, current_scope,
+                                     allow_method_definitions: false,
+                                     result: false)
+          [
+            "while #{emit_expr(args[0], env, current_scope)}",
+            indent(body_code),
+            'end'
+          ].join("\n")
+        end
+
+        def emit_for_statement(args, env, current_scope)
+          parsed = parse_counted_for_bindings(args[0].items, env, current_scope)
+          body_code, = emit_sequence(args[1..], parsed[:loop_env], current_scope,
+                                     allow_method_definitions: false,
+                                     result: false)
+          emit_counted_loop(**parsed, current_scope:, body_code:)
+        end
+
+        def emit_each_statement(args, env, current_scope)
+          emit_iteration(args[0], env, current_scope) do |iter_env|
+            emit_sequence(args[1..], iter_env, current_scope,
+                          allow_method_definitions: false,
+                          result: false).first
+          end
+        end
       end
     end
   end