kapusta 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2398c1c908306ac808914717a67e74f8085ee6048deb9c9dd665f4dd8c39cc2f
-  data.tar.gz: 1022c2df415418d26f1b84b1b16830cc525829182a82e93c1a450d0dd4b5bdd2
+  metadata.gz: c136e4c7cc9c5dde0ced8c828ab80882900b278db86010986eb7271a7b45309e
+  data.tar.gz: 46ff912715738e99c454727224a5e19f6d1635fbfccb1ade3820a9a51a996d0d
 SHA512:
-  metadata.gz: 6a31f0bab47d9c5c0d40720c52422717e0d04a9c03bb03a115ac62c7f541226dc3d9b7e9aa052bf55d574e1193ecab82e97b0610d43bbe1702038024486a1953
-  data.tar.gz: f20bf20a890d1b23f3ec7d2d113a3340c6255132a367a655cddab52ded9e2276bd236439d242ca0ea46f857096a5f5885620dd9a104f8b0f337c9aba75e50366
+  metadata.gz: 9d36ad79125c72a9e804f10ce9e0e5983e852b428f1a1a3718e21ef9394c66f39e57bec366ed81257bd5e62439429cc1cd93039710404db2c8dc0f3d9c09c44a
+  data.tar.gz: 0cb236654de0a57184387087c5a7f47dc49d548c1fed0167638439c071b83cda592cd0346f68ffc086c74afccff0b1f08c90ec977238213b9672fa8244052b27

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/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,40 @@ 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_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 +70,59 @@ 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)
+          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_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 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 +136,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 +151,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)
@@ -128,9 +173,7 @@ module Kapusta
               if env.defined?(target.name)
                 env.lookup(target.name)
               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
@@ -164,7 +207,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

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

@@ -79,7 +79,7 @@ module Kapusta
           when 'raise' then emit_raise(args, env, current_scope)
           when 'ivar' then runtime_call(:get_ivar, 'self', args[0].name.inspect)
           when 'cvar' then runtime_call(:get_cvar, 'self', args[0].name.inspect)
-          when 'gvar' then runtime_call(:get_gvar, args[0].name.inspect)
+          when 'gvar' then emit_gvar(args[0])
           when 'ruby' then "Kernel.eval(#{emit_expr(args[0], env, current_scope)})"
           when 'and' then emit_and(args, env, current_scope)
           when 'or' then emit_or(args, env, current_scope)