kapusta 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 693c32746a17e6f3a2aa7ac2a2d23cd6e3b3d981f1ef9355a69c5cd14ea09bbe
-  data.tar.gz: 7a500a84cbb1c8e3c1937c1fb987aa14db1b835cd63416e2f2e1d9b18309324e
+  metadata.gz: ef91159e2623e199fc391fa483440fa9f8ca76f273fbc31caeb0b07e891ee92c
+  data.tar.gz: 5468818f0ad4b0509a31635d886f3374009e3e8499a197d82f99da22c53e3a12
 SHA512:
-  metadata.gz: fb9f5ac51dbc88892e7d2b2527c6b94d13c972276899cdf86a76f6460e7073c0c4610cbaee2142e66638108226b9a66efe1415e42394e6c8c7abd74bd4ac0d2c
-  data.tar.gz: 53eac046879c094bd002cb6d0e9c199dfb39680d2140dde5699f62a36a26a8cc5d928ccc02315b1cad568e9b8f383cafeddf2e26cfaa4d07db3f53a29783de7e
+  metadata.gz: 7bcc51b164c21357c2aa2ef52e4e544cba0116ca8d8b6b1c02ecb55dc62697508a3cbb22d4c56a0a7cf0da77f53d7500827ecd2debe0760fec34ebe4d992be07
+  data.tar.gz: 40b1b709b5e083b94584424f9fb2ad7c3ec6908786ea80051173df8edaa380b9b5b76d0c485a6377f7e77bbed5799633501204d7a39acf0b919eb74197fabcf2

data/examples/anagram.kap

@@ -1,8 +1,8 @@
 (fn normalize-word [word]
-  (let [lower (word.downcase)
-        chars (lower.chars)
-        sorted (chars.sort)]
-    (sorted.join)))
+  (-> word
+      (: :downcase)
+      (: :chars)
+      (: :sort)))
 
 (fn anagram? [a b]
   (= (normalize-word a)

data/examples/baseball-game.kap

@@ -4,7 +4,7 @@
       (if (= op "C") (do (-?> (scores.pop) (: :abs)) nil)
           (= op "D") (scores.push (* 2 (. scores -1)))
           (= op "+") (scores.push (+ (. scores -1) (. scores -2)))
-          (scores.push (Integer op))))
+          (scores.push (: op :to-i))))
     scores.sum))
 
 (print (cal-points ["5" "2" "C" "D" "+"]))

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/exceptions.kap

@@ -1,7 +1,7 @@
 (fn require-score [s]
   (if (= s "oops")
       (raise (ArgumentError.new "not a number"))
-      (Integer s)))
+      (: s :to-i)))
 
 (fn parse-score [s]
   (try (require-score s)

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/pcall.kap

@@ -1,6 +1,9 @@
-(let [[ok value] (pcall Integer "12")
-      [bad-ok error] (pcall Integer "oops")
-      [handled-ok handled] (xpcall Integer (fn [e] (e.message)) "oops")]
+(fn parse-int [s]
+  (: Kernel :Integer s))
+
+(let [[ok value] (pcall parse-int "12")
+      [bad-ok error] (pcall parse-int "oops")
+      [handled-ok handled] (xpcall parse-int (fn [e] (e.message)) "oops")]
   (print ok)
   (print value)
   (print bad-ok)

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

@@ -7,7 +7,7 @@
   (when (div? n 5) (add-drop "Plang"))
   (when (div? n 7) (add-drop "Plong"))
   (if (empty? drops)
-      (tostring n)
+      (: n :to-s)
       (drops.join)))
 
 (print (raindrops 15))

data/examples/single-number.kap

@@ -0,0 +1,7 @@
+(fn single-number [nums]
+  (accumulate [acc 0 _ n (ipairs nums)]
+    (: acc :^ n)))
+
+(print (single-number [2 2 1]))
+(print (single-number [4 1 2 1 2]))
+(print (single-number [1]))

data/kapusta.gemspec

@@ -7,13 +7,13 @@ Gem::Specification.new do |spec|
   spec.version = Kapusta::VERSION
   spec.authors = ['Evgenii Morozov']
   spec.homepage = 'https://github.com/evmorov/kapusta'
+  spec.license = 'MIT'
 
   spec.summary = 'A Lisp for the Ruby runtime'
   spec.description = 'Kapusta is a Lisp for the Ruby runtime.'
   spec.required_ruby_version = '>= 3.1'
 
   spec.metadata['rubygems_mfa_required'] = 'true'
-  spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage
   spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
 

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

@@ -242,7 +242,7 @@ module Kapusta
           body_code, = emit_sequence(body, child_env, current_scope,
                                      allow_method_definitions: false,
                                      result:)
-          [binding_codes.join("\n"), body_code]
+          [binding_codes.reject(&:empty?).join("\n"), body_code]
         end
 
         def join_code(*chunks)
@@ -258,7 +258,7 @@ module Kapusta
             ["#{ruby_name} = #{value_code}\nnil", env]
           else
             bind_code, env = emit_pattern_bind(target, value_code, env)
-            ["#{bind_code}\nnil", env]
+            [join_code(bind_code, 'nil'), env]
           end
         end
 

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
@@ -156,7 +163,7 @@ module Kapusta
 
             code, current_env = emit_pattern_bind(pattern, value_code, current_env)
             code
-          end.compact
+          end.compact.reject(&:empty?)
           [codes.join("\n"), current_env]
         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

@@ -21,11 +21,17 @@ module Kapusta
           runtime_call(:qget_path, object_code, "[#{keys}]")
         end
 
+        BINARY_OPERATOR_METHODS = %w[<=> ** << >> & | ^ === =~].freeze
+        private_constant :BINARY_OPERATOR_METHODS
+
         def emit_colon(args, env, current_scope)
           receiver = emit_expr(args[0], env, current_scope)
           method_form = args[1]
           positional, kwargs, block_form = split_call_args(args[2..], env, current_scope)
           literal_name = method_form if method_form.is_a?(Symbol) || method_form.is_a?(String)
+          if literal_name && binary_operator_call?(literal_name.to_s, positional, kwargs, block_form)
+            return emit_binary_operator_call(receiver, literal_name.to_s, positional[0])
+          end
           if literal_name && direct_method_name?(literal_name.to_s)
             return emit_direct_method_call(receiver, Kapusta.kebab_to_snake(literal_name.to_s),
                                            positional, kwargs, block_form, env, current_scope)
@@ -37,6 +43,15 @@ module Kapusta
           "#{parenthesize(receiver)}.public_send(#{parts})"
         end
 
+        def binary_operator_call?(name, positional, kwargs, block_form)
+          BINARY_OPERATOR_METHODS.include?(name) &&
+            positional.length == 1 && !kwargs && !block_form
+        end
+
+        def emit_binary_operator_call(receiver, operator, arg_code)
+          "#{parenthesize(receiver)} #{operator} #{parenthesize(arg_code)}"
+        end
+
         def emit_require(arg, env, current_scope)
           path_code =
             case arg
@@ -218,6 +233,9 @@ module Kapusta
         def emit_compare(args, env, current_scope, operator)
           values = args.map { |arg| emit_expr(arg, env, current_scope) }
           return 'true' if values.length <= 1
+          if (nil_pred = nil_predicate(args, values, operator, negate: false))
+            return nil_pred
+          end
 
           (0...(values.length - 1)).map do |i|
             "#{parenthesize(values[i])} #{operator} #{parenthesize(values[i + 1])}"
@@ -227,12 +245,27 @@ module Kapusta
         def emit_compare_any(args, env, current_scope, operator)
           values = args.map { |arg| emit_expr(arg, env, current_scope) }
           return 'false' if values.length <= 1
+          if (nil_pred = nil_predicate(args, values, operator, negate: true))
+            return nil_pred
+          end
 
           (0...(values.length - 1)).map do |i|
             "#{parenthesize(values[i])} #{operator} #{parenthesize(values[i + 1])}"
           end.join(' || ')
         end
 
+        def nil_predicate(args, values, operator, negate:)
+          return unless args.length == 2
+          return unless (operator == '==' && !negate) || (operator == '!=' && negate)
+
+          nil_idx = args.find_index(&:nil?)
+          return unless nil_idx
+
+          other = values[1 - nil_idx]
+          receiver = simple_expression?(other) ? other : parenthesize(other)
+          "#{'!' if negate}#{receiver}.nil?"
+        end
+
         def emit_reduce(args, env, current_scope, empty_value, operator)
           return empty_value if args.empty?
 
@@ -292,6 +325,9 @@ module Kapusta
           else
             receiver = emit_method_path(base_code, segments[0...-1])
             positional, kwargs, block_form = split_call_args(args, env, current_scope)
+            if binary_operator_call?(segments.last, positional, kwargs, block_form)
+              return emit_binary_operator_call(receiver, segments.last, positional[0])
+            end
             if direct_method_name?(segments.last)
               return emit_direct_method_call(receiver, Kapusta.kebab_to_snake(segments.last),
                                              positional, kwargs, block_form, env, current_scope)
@@ -328,10 +364,23 @@ module Kapusta
 
         def emit_self_call(name, args, env, current_scope)
           positional, kwargs, block_form = split_call_args(args, env, current_scope)
+          snake = Kapusta.kebab_to_snake(name)
+          if direct_method_name?(snake)
+            return emit_direct_self_call(snake, positional, kwargs, block_form, env, current_scope)
+          end
+
           block = emit_block_proc(block_form, env, current_scope)
-          method_name = Kapusta.kebab_to_snake(name).to_sym.inspect
+          method_name = snake.to_sym.inspect
           parts = build_call_args([method_name, *positional], kwargs, block)
-          "send(#{parts})"
+          "public_send(#{parts})"
+        end
+
+        def emit_direct_self_call(method_name, positional, kwargs, block_form, env, current_scope)
+          attached = block_form && emit_attached_block(block_form, env, current_scope)
+          block = block_form && !attached ? emit_block_proc(block_form, env, current_scope) : nil
+          parts = build_call_args(positional, kwargs, block)
+          call = parts.empty? ? "#{method_name}()" : "#{method_name}(#{parts})"
+          attached ? "#{call} #{attached}" : call
         end
 
         def split_call_args(args, env, current_scope)
@@ -442,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/compiler/emitter/patterns.rb

@@ -8,7 +8,7 @@ module Kapusta
 
         def emit_pattern_bind(pattern, value_code, env)
           if pattern.is_a?(Sym)
-            return ['nil', env] if pattern.name == '_'
+            return ['', env] if pattern.name == '_'
 
             ruby_name = define_local(env, pattern)
             ["#{ruby_name} = #{value_code}", env]

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.2.2'
+  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"
@@ -399,6 +403,10 @@ RSpec.describe 'examples' do
     expect(run_example('shapes.kap')).to eq("78.5\n9\n8\n0\n")
   end
 
+  it 'single-number.kap' do
+    expect(run_example('single-number.kap')).to eq("1\n4\n1\n")
+  end
+
   it 'squares.kap' do
     expect(run_example('squares.kap')).to eq("1\n4\n9\n16\n25\n")
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  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
@@ -80,6 +81,7 @@ files:
 - examples/safe-lookup.kap
 - examples/scopes.kap
 - examples/shapes.kap
+- examples/single-number.kap
 - examples/squares.kap
 - examples/stack.kap
 - examples/sum.kap
@@ -123,10 +125,10 @@ files:
 - spec/reader_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/evmorov/kapusta
-licenses: []
+licenses:
+- MIT
 metadata:
   rubygems_mfa_required: 'true'
-  homepage_uri: https://github.com/evmorov/kapusta
   source_code_uri: https://github.com/evmorov/kapusta
   bug_tracker_uri: https://github.com/evmorov/kapusta/issues
 rdoc_options: []