kapusta 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62ac0b0f6d3ce6116b82110191b5c36783ed1689e2567076dbe68fc66e6ab3f7
-  data.tar.gz: 6b705edf9d441c4f753e8420b0e8bc6a2327d91f6ab9041a603c3afe6546487b
+  metadata.gz: c136e4c7cc9c5dde0ced8c828ab80882900b278db86010986eb7271a7b45309e
+  data.tar.gz: 46ff912715738e99c454727224a5e19f6d1635fbfccb1ade3820a9a51a996d0d
 SHA512:
-  metadata.gz: 243b1e47fd6a5684f7b4d2a9bf46e27d6b96883fb3cf71bf4f90edb4d48f0e5afa006c2da0191f5fc3cb116e37b506243b0f7030b90a6c6096629173e98074de
-  data.tar.gz: 825b21b71cb0eacb24623beff28dc2fcb1b542cf50268d78ebcfba2b156bf634992975fb1f1a3a0e27f407c51e54c8eb96683d544f861de5f5cc51731fc819c3
+  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/anonymous-greeter.kap

@@ -0,0 +1,4 @@
+(let [name nil
+      greet (fn [value] (if value (.. "Hello, " value "!") "Hello, anonymous!"))]
+  (print (greet name))
+  (print (greet "Ada")))

data/examples/binary-to-decimal.kap

@@ -0,0 +1,7 @@
+(fn binary-to-decimal [bits]
+  (faccumulate [value 0 i 0 (- (length bits) 1)]
+    (+ (* value 2) (if (= (. bits i) "1") 1 0))))
+
+(print (binary-to-decimal "1011"))
+(print (binary-to-decimal "0"))
+(print (binary-to-decimal "101010"))

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/examples/or-patterns.kap

@@ -0,0 +1,8 @@
+(fn swap-kind [v]
+  (case v
+    (where (or [:pair x y] [:flipped y x])) (.. x ":" y)
+    _ "other"))
+
+(print (swap-kind [:pair 1 2]))
+(print (swap-kind [:flipped 1 2]))
+(print (swap-kind [:nope 1 2]))

data/examples/packet-router.kap

@@ -0,0 +1,26 @@
+(fn inbox-line [user event]
+  (match event
+    [:score user points] (.. "score:" points)
+    [:profile user ?city] (if city (.. "city:" city) "city:nil")
+    _ "other"))
+
+(fn score-delta [user event]
+  (case event
+    (where (or [:bonus (= user) points] [:score (= user) points])
+      (> points 0)
+      (< points 10))
+    points
+    _ 0))
+
+(fn packet-kind [packet]
+  (case packet
+    [:ping seq] (.. "ping:" seq)
+    [:pong seq] (.. "pong:" seq)
+    _ "other"))
+
+(print (inbox-line "Ada" [:score "Ada" 9]))
+(print (inbox-line "Ada" [:score "Lin" 7]))
+(print (inbox-line "Ada" [:profile "Ada" nil]))
+(print (score-delta "Ada" [:bonus "Ada" 5]))
+(print (score-delta "Ada" [:score "Lin" 5]))
+(print (packet-kind [:ping 7 :fast]))

data/examples/tic-tac-toe.kap

@@ -0,0 +1,18 @@
+(fn winner [board]
+  (case board
+    [["X" "X" "X"] _ _] "X"
+    [_ ["O" "O" "O"] _] "O"
+    [["X" _ _] [_ "X" _] [_ _ "X"]] "X"
+    [["O" _ _] ["O" _ _] ["O" _ _]] "O"
+    _ "draw"))
+
+(each
+  [
+    _
+    board
+    (ipairs [
+              [["X" "X" "X"] ["O" "" ""] ["" "O" ""]]
+              [["O" "X" "X"] ["O" "" "X"] ["O" "" ""]]
+              [["X" "O" ""] ["" "X" "O"] ["" "" "X"]]
+              [["X" "O" "X"] ["O" "X" "O"] ["O" "X" "O"]]])]
+  (print (winner board)))

data/examples/underscore-patterns.kap

@@ -0,0 +1,14 @@
+(fn loose [v]
+  (case v
+    _x _x
+    _ "fallback"))
+
+(fn strict [v]
+  (case v
+    x x
+    _ "fallback"))
+
+(print (loose 5))
+(print (loose nil))
+(print (strict 5))
+(print (strict nil))

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,100 +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')
-          bindings = args[0].items
-          ruby_name = temp(sanitize_local(bindings[0].name))
-          loop_env = env.child
-          loop_env.define(bindings[0].name, ruby_name)
-          start_code = emit_expr(bindings[1], env, current_scope)
-          finish_code = emit_expr(bindings[2], env, current_scope)
-          step_code = '1'
-          until_form = nil
-          i = 3
-          while i < bindings.length
-            if bindings[i].is_a?(Sym) && bindings[i].name == '&until'
-              until_form = bindings[i + 1]
-              i += 2
-            else
-              step_code = emit_expr(bindings[i], env, current_scope)
-              i += 1
-            end
-          end
-          body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
-          until_code = until_form ? "break if #{emit_expr(until_form, loop_env, current_scope)}" : nil
-          finish_var = temp('finish')
-          step_var = temp('step')
-          cmp_var = temp('cmp')
-          <<~RUBY.chomp
-            (-> do
-              #{result_var} = []
-              #{ruby_name} = #{start_code}
-              #{finish_var} = #{finish_code}
-              #{step_var} = #{step_code}
-              #{cmp_var} = #{step_var} >= 0 ? :<= : :>=
-              while #{ruby_name}.public_send(#{cmp_var}, #{finish_var})
-                #{until_code}
-                __kap_value = begin
-                #{indent(body_code)}
-                end
-                #{result_var} << __kap_value unless __kap_value.nil?
-                #{ruby_name} += #{step_var}
-              end
-              #{result_var}
-            end).call
-          RUBY
+          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 = emit_array_collection_step(result_var, body_code)
+          loop_code = emit_counted_loop(**parsed, current_scope:, body_code: collecting_body)
+          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
@@ -118,32 +57,26 @@ 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)
-          start_code = emit_expr(bindings[3], env, current_scope)
-          finish_code = emit_expr(bindings[4], env, current_scope)
-          step_code = bindings[5] ? emit_expr(bindings[5], env, current_scope) : '1'
+          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)
-          finish_var = temp('finish')
-          step_var = temp('step')
-          cmp_var = temp('cmp')
+          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),
+            finish_code: emit_expr(bindings[4], env, current_scope),
+            step_code: bindings[5] ? emit_expr(bindings[5], env, current_scope) : '1',
+            until_form: nil,
+            loop_env:,
+            current_scope:,
+            body_code: accumulating_body
+          )
           <<~RUBY.chomp
             (-> do
               #{acc_var} = #{emit_expr(bindings[1], env, current_scope)}
-              #{loop_var} = #{start_code}
-              #{finish_var} = #{finish_code}
-              #{step_var} = #{step_code}
-              #{cmp_var} = #{step_var} >= 0 ? :<= : :>=
-              while #{loop_var}.public_send(#{cmp_var}, #{finish_var})
-                #{acc_var} = begin
-                #{indent(body_code)}
-                end
-                #{loop_var} += #{step_var}
-              end
+              #{indent(loop_code)}
               #{acc_var}
             end).call
           RUBY
@@ -239,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