kapusta 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53512e4cdebbb07a50f1bff53338574994140e5b16ddc5c1fd05e27b8cbc8a20
-  data.tar.gz: c7907d4901ecfb193c4df0c0b09bca2869babab65f6327d542c59a88a9edff51
+  metadata.gz: 693c32746a17e6f3a2aa7ac2a2d23cd6e3b3d981f1ef9355a69c5cd14ea09bbe
+  data.tar.gz: 7a500a84cbb1c8e3c1937c1fb987aa14db1b835cd63416e2f2e1d9b18309324e
 SHA512:
-  metadata.gz: c185f6d33f64071522cef35498fb7310f47d4091d3873868361294ff40edb51e836cdb2c0168dac1f599bc9ccd7c230d34d276fa6ab1a3fca479a4a4c40b9025
-  data.tar.gz: dcf0acd60680784bb38685305f5454466e4c36358d08a2994e2ca988e5fa19d32fa6eafdb48bb1054681e5699daaddc4b9ebf73477f0450d8dc78482cfad0147
+  metadata.gz: fb9f5ac51dbc88892e7d2b2527c6b94d13c972276899cdf86a76f6460e7073c0c4610cbaee2142e66638108226b9a66efe1415e42394e6c8c7abd74bd4ac0d2c
+  data.tar.gz: 53eac046879c094bd002cb6d0e9c199dfb39680d2140dde5699f62a36a26a8cc5d928ccc02315b1cad568e9b8f383cafeddf2e26cfaa4d07db3f53a29783de7e

data/README.md

@@ -41,6 +41,36 @@ account = BankAccount.new('Ada', 100)
 
 See `examples/bank-account.kap` and `examples/use_bank_account.rb`.
 
+## Examples
+
+See [`examples/`](https://github.com/evmorov/kapusta/tree/main/examples).
+
+```fennel
+(fn ack [m n]
+  (if (= m 0) (+ n 1)
+      (= n 0) (ack (- m 1) 1)
+      (ack (- m 1) (ack m (- n 1)))))
+
+(print (ack 2 3))
+(print (ack 3 3))
+```
+
+Compiles to:
+
+```ruby
+def ack(m, n)
+  if m == 0
+    n + 1
+  elsif n == 0
+    ack(m - 1, 1)
+  else
+    ack(m - 1, ack(m, n - 1))
+  end
+end
+p ack(2, 3)
+p ack(3, 3)
+```
+
 ## Comparison with Fennel
 
 Kapusta keeps most core Fennel forms. The main differences come from Ruby's runtime and object model.
@@ -65,10 +95,6 @@ Kapusta-specific additions:
 - a trailing symbol-keyed hash is emitted as Ruby keyword arguments
 - a final function literal argument is emitted as a Ruby block
 
-## Examples
-
-See `examples/`.
-
 ## Formatting
 
 ```

data/examples/best-time-to-buy-sell-stock.kap

@@ -0,0 +1,12 @@
+(fn max-profit [prices]
+  (var min-price (. prices 0))
+  (var best 0)
+  (for [i 1 (- (length prices) 1)]
+    (let [p (. prices i)]
+      (when (< p min-price) (set min-price p))
+      (when (> (- p min-price) best) (set best (- p min-price)))))
+  best)
+
+(print (max-profit [7 1 5 3 6 4]))
+(print (max-profit [7 6 4 3 1]))
+(print (max-profit [2 4 1]))

data/examples/majority-element.kap

@@ -0,0 +1,11 @@
+(fn majority [nums]
+  (var candidate nil)
+  (var count 0)
+  (each [n nums]
+    (when (= count 0) (set candidate n))
+    (if (= n candidate) (set count (+ count 1)) (set count (- count 1))))
+  candidate)
+
+(print (majority [3 2 3]))
+(print (majority [2 2 1 1 1 2 2]))
+(print (majority [1]))

data/examples/plus-one.kap

@@ -0,0 +1,14 @@
+(fn plus-one [digits]
+  (var i (- (length digits) 1))
+  (var carry 1)
+  (while (and (>= i 0) (> carry 0))
+    (let [total (+ (. digits i) carry)]
+      (tset digits i (% total 10))
+      (set carry (: (/ total 10) :floor)))
+    (set i (- i 1)))
+  (if (> carry 0) (: digits :unshift carry) digits))
+
+(print (plus-one [1 2 3]))
+(print (plus-one [4 3 2 1]))
+(print (plus-one [9]))
+(print (plus-one [9 9]))

data/examples/reverse-integer.kap

@@ -0,0 +1,13 @@
+(fn reverse-integer [x]
+  (let [sign (if (< x 0) -1 1)]
+    (var remaining (* x sign))
+    (var result 0)
+    (while (> remaining 0)
+      (set result (+ (* result 10) (% remaining 10)))
+      (set remaining (: (/ remaining 10) :floor)))
+    (* result sign)))
+
+(print (reverse-integer 123))
+(print (reverse-integer -123))
+(print (reverse-integer 120))
+(print (reverse-integer 0))

data/examples/roman-to-integer.kap

@@ -0,0 +1,17 @@
+(fn roman-to-integer [s]
+  (let [values {"I" 1 "V" 5 "X" 10 "L" 50 "C" 100 "D" 500 "M" 1000}
+        chars (s.chars)
+        n (length chars)]
+    (var total 0)
+    (var i 0)
+    (while (< i n)
+      (let [curr (. values (. chars i))
+            ahead (if (< (+ i 1) n) (. values (. chars (+ i 1))) 0)
+            subtract? (< curr ahead)]
+        (set total (+ total (if subtract? (- ahead curr) curr)))
+        (set i (+ i (if subtract? 2 1)))))
+    total))
+
+(print (roman-to-integer "III"))
+(print (roman-to-integer "LVIII"))
+(print (roman-to-integer "MCMXCIV"))

data/examples/zoo-animal-1.kap

@@ -0,0 +1,5 @@
+(class Zoo.Animal
+  (fn initialize [name] (set (ivar name) name))
+  (fn name [] (ivar name))
+  (fn kingdom [] "animalia")
+  (fn label [] (.. (self.name) " the animal")))

data/examples/zoo-animal-inheritance-2.kap

@@ -0,0 +1,8 @@
+(require "./zoo-animal-1")
+
+(class Zoo.Dog [Zoo.Animal]
+  (fn label [] (.. (self.name) " the dog"))
+  (fn bark [] "woof"))
+
+(let [dog (Zoo.Dog.new "Poppy")]
+  (print (= Zoo.Dog.superclass Zoo.Animal) (dog.kingdom) (dog.label) (dog.bark)))

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

@@ -213,11 +213,11 @@ module Kapusta
 
         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
+          [
+            '(-> do',
+            indent(join_code(binding_code, body_code)),
+            'end).call'
+          ].join("\n")
         end
 
         def emit_let_statement(args, env, current_scope)

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

@@ -113,12 +113,9 @@ module Kapusta
                 [[binding_pats[0], index_var], [binding_pats[1], value_var]], body_env
               )
               body_code = yield(body_env)
-              return <<~RUBY.chomp
-                #{emit_expr(iter_expr.items[1], env, current_scope)}.each_with_index do |#{value_var}, #{index_var}|
-                  #{bind_code}
-                  #{body_code}
-                end
-              RUBY
+              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')
@@ -126,12 +123,8 @@ module Kapusta
               bind_code, body_env = emit_iteration_bindings([[binding_pats[0], key_var], [binding_pats[1], value_var]],
                                                             body_env)
               body_code = yield(body_env)
-              return <<~RUBY.chomp
-                #{emit_expr(iter_expr.items[1], env, current_scope)}.each do |#{key_var}, #{value_var}|
-                  #{bind_code}
-                  #{body_code}
-                end
-              RUBY
+              header = "#{emit_expr(iter_expr.items[1], env, current_scope)}.each do |#{key_var}, #{value_var}|"
+              return iteration_block(header, bind_code, body_code)
             end
           end
 
@@ -141,27 +134,21 @@ module Kapusta
             body_env = env.child
             bind_code, body_env = emit_iteration_bindings([[binding_pats[0], value_var]], body_env)
             body_code = yield(body_env)
-            <<~RUBY.chomp
-              #{coll_code}.each do |#{value_var}|
-                #{bind_code}
-                #{body_code}
-              end
-            RUBY
+            iteration_block("#{coll_code}.each do |#{value_var}|", bind_code, body_code)
           else
             parts_var = temp('parts')
             body_env = env.child
             pairs = binding_pats.each_with_index.map { |pattern, i| [pattern, "#{parts_var}[#{i}]"] }
             bind_code, body_env = emit_iteration_bindings(pairs, body_env)
             body_code = yield(body_env)
-            <<~RUBY.chomp
-              #{coll_code}.each do |*#{parts_var}|
-                #{bind_code}
-                #{body_code}
-              end
-            RUBY
+            iteration_block("#{coll_code}.each do |*#{parts_var}|", bind_code, body_code)
           end
         end
 
+        def iteration_block(header, bind_code, body_code)
+          [header, indent(join_code(bind_code, body_code)), 'end'].join("\n")
+        end
+
         def emit_iteration_bindings(pairs, env)
           current_env = env
           codes = pairs.compact.map do |pattern, value_code|

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

@@ -15,7 +15,7 @@ module Kapusta
           return emit_expr(args[0], env, current_scope) if args.length == 1
 
           cond = emit_expr(args[0], env, current_scope)
-          truthy = emit_expr(args[1], env, current_scope)
+          truthy = emit_if_branch(args[1], env, current_scope)
           lines = ["if #{cond}", indent(truthy)]
           append_else_lines(lines, args[2..], env, current_scope)
           lines << 'end'
@@ -31,7 +31,7 @@ module Kapusta
             append_elsif_lines(lines, args, env, current_scope)
           else
             lines << 'else'
-            lines << indent(emit_expr(args[0], env, current_scope))
+            lines << indent(emit_if_branch(args[0], env, current_scope))
           end
         end
 
@@ -39,10 +39,18 @@ module Kapusta
           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))
+          lines << indent(emit_if_branch(args[1], env, current_scope))
           append_else_lines(lines, args[2..], env, current_scope)
         end
 
+        def emit_if_branch(form, env, current_scope)
+          return emit_expr(form, env, current_scope) unless do_form?(form)
+
+          emit_sequence(form.rest, env, current_scope,
+                        allow_method_definitions: false,
+                        result: true).first
+        end
+
         def if_form?(form)
           form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'if'
         end

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

@@ -110,13 +110,17 @@ module Kapusta
         def emit_print(args, env, current_scope)
           return 'p' if args.empty?
 
-          "p(#{args.map { |arg| emit_expr(arg, env, current_scope) }.join(', ')})"
+          rendered = args.map { |arg| emit_expr(arg, env, current_scope) }
+          return "p #{rendered[0]}" if rendered.length == 1 && simple_expression?(rendered[0])
+
+          "p(#{rendered.join(', ')})"
         end
 
         def emit_string_part(arg, env, current_scope)
           return arg.inspect if arg.is_a?(String)
 
-          "(#{emit_expr(arg, env, current_scope)}).to_s"
+          code = emit_expr(arg, env, current_scope)
+          "#{simple_expression?(code) ? code : "(#{code})"}.to_s"
         end
       end
     end

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

@@ -24,13 +24,15 @@ module Kapusta
         def emit_colon(args, env, current_scope)
           receiver = emit_expr(args[0], env, current_scope)
           method_form = args[1]
-          positional, kwargs, block = split_call_args(args[2..], env, current_scope)
+          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 && !kwargs && !block && direct_method_name?(literal_name.to_s)
-            return emit_direct_method_call(receiver, Kapusta.kebab_to_snake(literal_name.to_s), positional)
+          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)
           end
 
           method_name = emit_method_name(method_form, env, current_scope)
+          block = emit_block_proc(block_form, env, current_scope)
           parts = build_call_args([method_name, *positional], kwargs, block)
           "#{parenthesize(receiver)}.public_send(#{parts})"
         end
@@ -163,7 +165,14 @@ module Kapusta
             end
           end
 
-          lines = ['begin', indent(emit_expr(args[0], env, current_scope))]
+          body_form = args[0]
+          body_code =
+            if body_form.is_a?(List) && body_form.head.is_a?(Sym) && body_form.head.name == 'do'
+              emit_sequence(body_form.rest, env, current_scope, allow_method_definitions: false).first
+            else
+              emit_expr(body_form, env, current_scope)
+            end
+          lines = ['begin', indent(body_code)]
           catches.each do |klass_form, bind_sym, body|
             rescue_env = env.child
             rescue_name = define_local(rescue_env, bind_sym.name)
@@ -246,7 +255,8 @@ module Kapusta
         end
 
         def emit_callable_call(callee_code, args, env, current_scope)
-          positional, kwargs, block = split_call_args(args, env, current_scope)
+          positional, kwargs, block_form = split_call_args(args, env, current_scope)
+          block = emit_block_proc(block_form, env, current_scope)
           rendered = build_call_args(positional, kwargs, block)
           suffix = rendered.empty? ? '.call' : ".call(#{rendered})"
           "#{parenthesize(callee_code)}#{suffix}"
@@ -281,12 +291,14 @@ module Kapusta
             emit_callable_call(base_code, args, env, current_scope)
           else
             receiver = emit_method_path(base_code, segments[0...-1])
-            positional, kwargs, block = split_call_args(args, env, current_scope)
-            if !kwargs && !block && direct_method_name?(segments.last)
-              return emit_direct_method_call(receiver, Kapusta.kebab_to_snake(segments.last), positional)
+            positional, kwargs, block_form = split_call_args(args, env, current_scope)
+            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)
             end
 
             method_name = Kapusta.kebab_to_snake(segments.last).to_sym.inspect
+            block = emit_block_proc(block_form, env, current_scope)
             parts = build_call_args([method_name, *positional], kwargs, block)
             "#{receiver}.public_send(#{parts})"
           end
@@ -303,25 +315,30 @@ module Kapusta
           end
         end
 
-        def emit_direct_method_call(receiver, method_name, positional)
-          args = positional.join(', ')
+        def emit_direct_method_call(receiver, method_name, positional, kwargs = nil,
+                                    block_form = nil, env = nil, current_scope = nil)
+          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)
           rendered_receiver = simple_expression?(receiver) ? receiver : parenthesize(receiver)
-          suffix = args.empty? ? method_name : "#{method_name}(#{args})"
-          "#{rendered_receiver}.#{suffix}"
+          call = parts.empty? ? method_name : "#{method_name}(#{parts})"
+          call = "#{call} #{attached}" if attached
+          "#{rendered_receiver}.#{call}"
         end
 
         def emit_self_call(name, args, env, current_scope)
-          positional, kwargs, block = split_call_args(args, env, current_scope)
+          positional, kwargs, block_form = split_call_args(args, env, current_scope)
+          block = emit_block_proc(block_form, env, current_scope)
           method_name = Kapusta.kebab_to_snake(name).to_sym.inspect
           parts = build_call_args([method_name, *positional], kwargs, block)
           "send(#{parts})"
         end
 
         def split_call_args(args, env, current_scope)
-          block = nil
+          block_form = nil
           remaining = args
           if !remaining.empty? && block_form?(remaining.last)
-            block = emit_expr(remaining.last, env, current_scope)
+            block_form = remaining.last
             remaining = remaining[0...-1]
           end
 
@@ -332,7 +349,24 @@ module Kapusta
             kwargs = nil
             positional = remaining.map { |arg| emit_expr(arg, env, current_scope) }
           end
-          [positional, kwargs, block]
+          [positional, kwargs, block_form]
+        end
+
+        def emit_block_proc(block_form, env, current_scope)
+          block_form && emit_expr(block_form, env, current_scope)
+        end
+
+        def emit_attached_block(block_form, env, current_scope)
+          return unless block_form.is_a?(List) && block_form.head.is_a?(Sym)
+          return unless %w[fn lambda λ].include?(block_form.head.name)
+
+          pattern = block_form.items[1]
+          return unless pattern.is_a?(Vec) && simple_parameter_pattern?(pattern)
+
+          body = block_form.items[2..]
+          params, body_code = build_simple_block_parts(pattern, body, env, current_scope)
+          header = params.empty? ? 'do' : "do |#{params.join(', ')}|"
+          [header, indent(body_code), 'end'].join("\n")
         end
 
         def emit_method_name(form, env, current_scope)
@@ -404,13 +438,17 @@ module Kapusta
 
         def simple_expression?(code)
           code.match?(/\A[a-z_]\w*\z/) ||
+            code.match?(/\A@@?[a-z_]\w*\z/) ||
+            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[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/) ||
             code.match?(/\A"(?:[^"\\]|\\.)*"\z/) ||
             code.match?(/\A'(?:[^'\\]|\\.)*'\z/) ||
+            code.match?(/\A\[[^\[\]\n]*\]\z/) ||
             %w[nil true false self].include?(code) ||
             negation_simple?(code)
         end

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

@@ -266,8 +266,9 @@ module Kapusta
           until_code = until_form ? "break if #{emit_expr(until_form, loop_env, current_scope)}" : nil
           body = [until_code, body_code].compact.reject(&:empty?).join("\n")
           step_part = step_code == '1' ? '' : ", #{step_code}"
+          block_args = ruby_name == '_' ? '' : " |#{ruby_name}|"
           [
-            "#{parenthesize(start_code)}.step(#{finish_code}#{step_part}) do |#{ruby_name}|",
+            "#{parenthesize(start_code)}.step(#{finish_code}#{step_part}) do#{block_args}",
             indent(body),
             'end'
           ].join("\n")

data/lib/kapusta/version.rb

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

data/spec/examples_spec.rb

@@ -239,8 +239,12 @@ RSpec.describe 'examples' do
     expect(run_example('hashfn.kap')).to eq("5\n21\n")
   end
 
-  it 'inheritance.kap' do
-    expect(run_example('inheritance.kap')).to eq(<<~OUT)
+  it 'zoo-animal-1.kap' do
+    expect(run_example('zoo-animal-1.kap')).to eq('')
+  end
+
+  it 'zoo-animal-inheritance-2.kap' do
+    expect(run_example('zoo-animal-inheritance-2.kap')).to eq(<<~OUT)
       true
       "animalia"
       "Poppy the dog"
@@ -455,4 +459,29 @@ RSpec.describe 'examples' do
       "draw"
     OUT
   end
+
+  it 'reverse-integer.kap' do
+    expect(run_example('reverse-integer.kap')).to eq("321\n-321\n21\n0\n")
+  end
+
+  it 'roman-to-integer.kap' do
+    expect(run_example('roman-to-integer.kap')).to eq("3\n58\n1994\n")
+  end
+
+  it 'best-time-to-buy-sell-stock.kap' do
+    expect(run_example('best-time-to-buy-sell-stock.kap')).to eq("5\n0\n2\n")
+  end
+
+  it 'majority-element.kap' do
+    expect(run_example('majority-element.kap')).to eq("3\n2\n1\n")
+  end
+
+  it 'plus-one.kap' do
+    expect(run_example('plus-one.kap')).to eq(<<~OUT)
+      [1, 2, 4]
+      [4, 3, 2, 2]
+      [1, 0]
+      [1, 0, 0]
+    OUT
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -29,6 +29,7 @@ files:
 - examples/anonymous-greeter.kap
 - examples/bank-account.kap
 - examples/baseball-game.kap
+- examples/best-time-to-buy-sell-stock.kap
 - examples/binary-search.kap
 - examples/binary-to-decimal.kap
 - examples/block-sort.kap
@@ -52,10 +53,10 @@ files:
 - examples/greet.kap
 - examples/happy-number.kap
 - examples/hashfn.kap
-- examples/inheritance.kap
 - examples/kwargs.kap
 - examples/leap-year.kap
 - examples/length-of-last-word.kap
+- examples/majority-element.kap
 - examples/match.kap
 - examples/maximum-subarray.kap
 - examples/min-max.kap
@@ -67,11 +68,14 @@ files:
 - examples/pangram.kap
 - examples/pcall.kap
 - examples/pipeline.kap
+- examples/plus-one.kap
 - examples/points.kap
 - examples/primes.kap
 - examples/raindrops.kap
 - examples/record.kap
 - examples/regex.kap
+- examples/reverse-integer.kap
+- examples/roman-to-integer.kap
 - examples/ruby-eval.kap
 - examples/safe-lookup.kap
 - examples/scopes.kap
@@ -88,6 +92,8 @@ files:
 - examples/use_bank_account.rb
 - examples/valid-parentheses-1.kap
 - examples/valid-parentheses-2.kap
+- examples/zoo-animal-1.kap
+- examples/zoo-animal-inheritance-2.kap
 - exe/kapfmt
 - exe/kapusta
 - kapusta.gemspec

data/examples/inheritance.kap

@@ -1,13 +0,0 @@
-(let [animal-class (class Zoo.Animal
-                     (fn initialize [name] (set (ivar name) name))
-                     (fn name [] (ivar name))
-                     (fn kingdom [] "animalia")
-                     (fn label [] (.. (self.name) " the animal")))
-      dog-class (class Zoo.Dog [Zoo.Animal]
-                  (fn label [] (.. (self.name) " the dog"))
-                  (fn bark [] "woof"))
-      dog (dog-class.new "Poppy")]
-  (print (= dog-class.superclass animal-class)
-    (dog.kingdom)
-    (dog.label)
-    (dog.bark)))