kapusta 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a5fcd922c54b5fa491785e6087c4fc2f8e6de1a8d94deab10fca3f775518b9b
-  data.tar.gz: d95f4bce9e6673104c44fc0ff281a705e796797490285cc50ef509b6b9fe5e97
+  metadata.gz: ef91159e2623e199fc391fa483440fa9f8ca76f273fbc31caeb0b07e891ee92c
+  data.tar.gz: 5468818f0ad4b0509a31635d886f3374009e3e8499a197d82f99da22c53e3a12
 SHA512:
-  metadata.gz: cb5ba4420166be83a152c22bf56a12563efdb8cc64e54f230f6d299051761c5abc2329ae42dfc5e6127a721f66250b9804d6ec86a9b053dc36282599b2f8c986
-  data.tar.gz: 334d34e9e47bdecf6a4aa35cc6e905770efb6913fa6c2e9f90b0f3b1a95915b9044c8e3f36c81778a865f91a6d43f675318bf1ae892e19292cb4a2d2de179685
+  metadata.gz: 7bcc51b164c21357c2aa2ef52e4e544cba0116ca8d8b6b1c02ecb55dc62697508a3cbb22d4c56a0a7cf0da77f53d7500827ecd2debe0760fec34ebe4d992be07
+  data.tar.gz: 40b1b709b5e083b94584424f9fb2ad7c3ec6908786ea80051173df8edaa380b9b5b76d0c485a6377f7e77bbed5799633501204d7a39acf0b919eb74197fabcf2

data/examples/counter.kap

@@ -4,8 +4,7 @@
   (set (ivar n) start))
 
 (fn tick []
-  (set (ivar n) (+ (ivar n) 1))
-  (ivar n))
+  (set (ivar n) (+ (ivar n) 1)))
 
 (fn value []
   (ivar n))

data/examples/length-of-last-word.kap

@@ -1,6 +1,9 @@
 (fn length-of-last-word [s]
-  (let [words (s.strip.split)]
-    (: (. words -1) :length)))
+  (-> s
+      (: :strip)
+      (: :split)
+      (. -1)
+      (: :length)))
 
 (print (length-of-last-word "Hello World"))
 (print (length-of-last-word "   fly me   to   the moon  "))

data/examples/palindrome.kap

@@ -1,7 +1,6 @@
 (fn palindrome? [s]
-  (let [lower (s.downcase)
-        normalized (lower.gsub (ruby "/[^a-z]/") "")]
-    (= normalized (normalized.reverse))))
+  (let [normalized (-> s (: :downcase) (: :gsub (ruby "/[^a-z]/") ""))]
+    (= normalized (: normalized :reverse))))
 
 (print (palindrome? "racecar"))
 (print (palindrome? "A man, a plan, a canal: Panama"))

data/examples/pangram.kap

@@ -1,9 +1,10 @@
 (fn pangram? [s]
-  (let [lower (s.downcase)
-        letters (lower.gsub (ruby "/[^a-z]/") "")
-        chars (letters.chars)
-        uniq (chars.uniq)]
-    (= (uniq.length) 26)))
+  (= 26
+    (length (-> s
+                (: :downcase)
+                (: :gsub (ruby "/[^a-z]/") "")
+                (: :chars)
+                (: :uniq)))))
 
 (print (pangram? "The quick brown fox jumps over the lazy dog"))
 (print (pangram? "Hello, world"))

data/examples/pivot-index.kap

@@ -0,0 +1,13 @@
+(fn pivot-index [nums]
+  (var total 0)
+  (each [n nums] (set total (+ total n)))
+  (var left 0)
+  (var found -1)
+  (each [i n (ipairs nums)]
+    (when (and (= found -1) (= left (- total left n))) (set found i))
+    (set left (+ left n)))
+  found)
+
+(print (pivot-index [1 7 3 6 5 6]))
+(print (pivot-index [1 2 3]))
+(print (pivot-index [2 1 -1]))

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

@@ -106,22 +106,19 @@ module Kapusta
           if iter_expr.is_a?(List) && iter_expr.head.is_a?(Sym)
             case iter_expr.head.name
             when 'ipairs'
-              value_var = temp('value')
-              index_var = temp('index')
               body_env = env.child
-              bind_code, body_env = emit_iteration_bindings(
-                [[binding_pats[0], index_var], [binding_pats[1], value_var]], body_env
-              )
+              value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+              index_var, index_bind = bind_iteration_param(binding_pats[0], 'index', body_env)
+              bind_code = [index_bind, value_bind].compact.join("\n")
               body_code = yield(body_env)
               header = "#{emit_expr(iter_expr.items[1], env, current_scope)}" \
                        ".each_with_index do |#{value_var}, #{index_var}|"
               return iteration_block(header, bind_code, body_code)
             when 'pairs'
-              key_var = temp('key')
-              value_var = temp('value')
               body_env = env.child
-              bind_code, body_env = emit_iteration_bindings([[binding_pats[0], key_var], [binding_pats[1], value_var]],
-                                                            body_env)
+              key_var, key_bind = bind_iteration_param(binding_pats[0], 'key', body_env)
+              value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+              bind_code = [key_bind, value_bind].compact.join("\n")
               body_code = yield(body_env)
               header = "#{emit_expr(iter_expr.items[1], env, current_scope)}.each do |#{key_var}, #{value_var}|"
               return iteration_block(header, bind_code, body_code)
@@ -130,11 +127,10 @@ module Kapusta
 
           coll_code = emit_expr(iter_expr, env, current_scope)
           if binding_pats.length == 1
-            value_var = temp('value')
             body_env = env.child
-            bind_code, body_env = emit_iteration_bindings([[binding_pats[0], value_var]], body_env)
+            value_var, bind_code = bind_iteration_param(binding_pats[0], 'value', body_env)
             body_code = yield(body_env)
-            iteration_block("#{coll_code}.each do |#{value_var}|", bind_code, body_code)
+            iteration_block("#{coll_code}.each do |#{value_var}|", bind_code || '', body_code)
           else
             parts_var = temp('parts')
             body_env = env.child
@@ -145,6 +141,17 @@ module Kapusta
           end
         end
 
+        def bind_iteration_param(pattern, fallback_name, env)
+          if pattern.is_a?(Sym) && !pattern.dotted?
+            ruby_name = pattern.name == '_' ? '_' : define_local(env, pattern.name)
+            [ruby_name, nil]
+          else
+            tmp = temp(fallback_name)
+            bind_code, _new_env = emit_iteration_bindings([[pattern, tmp]], env)
+            [tmp, bind_code.empty? ? nil : bind_code]
+          end
+        end
+
         def iteration_block(header, bind_code, body_code)
           [header, indent(join_code(bind_code, body_code)), 'end'].join("\n")
         end
@@ -189,11 +196,9 @@ module Kapusta
         end
 
         def emit_sequence_value_assignment(target_var, body_code)
-          <<~RUBY.chomp
-            #{target_var} = begin
-            #{indent(body_code)}
-            end
-          RUBY
+          return "#{target_var} = #{body_code}" unless body_code.include?("\n")
+
+          ["#{target_var} = begin", indent(body_code), 'end'].join("\n")
         end
       end
     end

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

@@ -491,7 +491,7 @@ module Kapusta
             code.match?(/\A\$[a-zA-Z_]\w*\z/) ||
             code.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/) ||
             code.match?(/\A[a-z_]\w*[!?=]?\([^()\n]*\)\z/) ||
-            code.match?(/\A\d+(?:\.\d+)?\z/) ||
+            code.match?(/\A-?\d+(?:\.\d+)?\z/) ||
             code.match?(/\A[a-z_]\w*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/) ||
             code.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/) ||
             code.match?(/\A:[a-zA-Z_]\w*[!?=]?\z/) ||

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.2.3'
+  VERSION = '0.2.4'
 end

data/spec/examples_spec.rb

@@ -280,6 +280,10 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'pivot-index.kap' do
+    expect(run_example('pivot-index.kap')).to eq("3\n-1\n0\n")
+  end
+
   it 'points.kap' do
     expect(run_example('points.kap')).to eq(<<~OUT)
       "origin"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -68,6 +68,7 @@ files:
 - examples/pangram.kap
 - examples/pcall.kap
 - examples/pipeline.kap
+- examples/pivot-index.kap
 - examples/plus-one.kap
 - examples/points.kap
 - examples/primes.kap