kapusta 0.1.5 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52369f7a4cd658385e7ddc69f552477d94b55340cb9f796ac635550a7def6e6a
-  data.tar.gz: 6d673c9c387b52b0e4cd9e55b8ae2cf1d0a7e2c5f741dc7705f405b0ddaf25c6
+  metadata.gz: ee9b062de9860ef3b9f3cfcbac8503e69c1549f0f09af35b41e5eb13303c1ddb
+  data.tar.gz: daa87e0b3b65dfc82f21ff47e88b41652d05f087e46320ca1c3f49bac2457b71
 SHA512:
-  metadata.gz: 53510507ba41a4d67ec73184eaef665fee182220407046eb9db64cf05cae7d28a315b5b8cf4ace6071b359a83801bd85d7e45ce5e4aefd3c608fef614f116fee
-  data.tar.gz: ff1b88fc11dc10ccffc1459686b17754bd39dc6a941756d7cab304253aec3b63bc36967c9edcf50cf4c29eadee3ae2afb0467383b6428dcb74f41c452173ab4a
+  metadata.gz: 564c441ea9395cd4f28daaa631de6022e39125eede47032bf32bbc2a45f18979b7376f264b5302459b78403ef039ef8aca93e6f469cc0666b033f6e6717894a2
+  data.tar.gz: 38479cb8d38b81df15697a56c1a14e63d4dda7a0dd793db4e121e06126395339d9c7676a4bb14411a6b43398b64196f877ce3126990eb07d24f2a0c769a577e2

data/README.md

@@ -29,6 +29,48 @@ exe/kapusta --compile examples/fizzbuzz.kap > examples/fizzbuzz.rb
 ruby examples/fizzbuzz.rb
 ```
 
+## Using from Ruby
+
+Ruby can require a `.kap` file and use it directly.
+
+```
+require 'kapusta'
+Kapusta.require('./bank-account', relative_to: __FILE__)
+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.
@@ -40,6 +82,7 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 | `(. xs 1)` is the first element       | `(. xs 0)` is the first element                       |
 | `string.format`, `table.insert`, etc. | use Ruby methods and stdlib instead                   |
 | `values` uses Lua multiple returns    | `values` lowers to a Ruby array, usually destructured |
+| `(print x)` is Lua's `print` (bare)   | `(print x)` is Ruby's `p` (inspect-style)             |
 | `with-open`, `tail!`                  | not provided                                          |
 | macros                                | not provided for now                                  |
 
@@ -52,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/bank-account.kap

@@ -0,0 +1,21 @@
+(class BankAccount)
+
+(fn initialize [owner balance]
+  (set (ivar owner) owner)
+  (set (ivar balance) balance))
+
+(fn owner []
+  (ivar owner))
+
+(fn balance []
+  (ivar balance))
+
+(fn deposit [amount]
+  (set (ivar balance)
+    (+ (ivar balance) amount))
+  self)
+
+(fn withdraw [amount]
+  (set (ivar balance)
+    (- (ivar balance) amount))
+  self)

data/examples/baseball-game.kap

@@ -0,0 +1,11 @@
+(fn cal-points [ops]
+  (let [scores []]
+    (each [op ops]
+      (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.sum))
+
+(print (cal-points ["5" "2" "C" "D" "+"]))
+(print (cal-points ["5" "-2" "4" "C" "D" "9" "+" "+"]))

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/climbing-stairs.kap

@@ -0,0 +1,13 @@
+(fn climb-stairs [n]
+  (var prev 1)
+  (var curr 1)
+  (for [_ 2 n]
+    (let [next (+ prev curr)]
+      (set prev curr)
+      (set curr next)))
+  curr)
+
+(print (climb-stairs 2))
+(print (climb-stairs 3))
+(print (climb-stairs 5))
+(print (climb-stairs 10))

data/examples/doto-hygiene.kap

@@ -0,0 +1,5 @@
+(let [__doto__ 99
+      xs []]
+  (doto xs
+        (: :push __doto__))
+  (print (xs.inspect)))

data/examples/happy-number.kap

@@ -0,0 +1,20 @@
+(fn sum-of-squares [n]
+  (var x n)
+  (var total 0)
+  (while (> x 0)
+    (let [d (% x 10)]
+      (set total (+ total (* d d)))
+      (set x (: (/ x 10) :floor))))
+  total)
+
+(fn happy? [n]
+  (let [seen {}]
+    (var x n)
+    (while (and (not= x 1) (not (seen.key? x)))
+      (tset seen x true)
+      (set x (sum-of-squares x)))
+    (= x 1)))
+
+(print (happy? 19))
+(print (happy? 2))
+(print (happy? 1))

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

@@ -0,0 +1,7 @@
+(fn length-of-last-word [s]
+  (let [words (s.strip.split)]
+    (: (. words -1) :length)))
+
+(print (length-of-last-word "Hello World"))
+(print (length-of-last-word "   fly me   to   the moon  "))
+(print (length-of-last-word "luffy is still joyboy"))

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/maximum-subarray.kap

@@ -0,0 +1,12 @@
+(fn max-subarray [nums]
+  (var best (. nums 0))
+  (var curr (. nums 0))
+  (for [i 1 (- (length nums) 1)]
+    (let [n (. nums i)]
+      (set curr (if (> (+ curr n) n) (+ curr n) n))
+      (when (> curr best) (set best curr))))
+  best)
+
+(print (max-subarray [-2 1 -3 4 -1 2 1 -5 4]))
+(print (max-subarray [1]))
+(print (max-subarray [5 4 -1 7 8]))

data/examples/move-zeroes.kap

@@ -0,0 +1,13 @@
+(fn move-zeroes [nums]
+  (var write 0)
+  (for [read 0 (- (length nums) 1)]
+    (when (not= (. nums read) 0)
+      (tset nums write (. nums read))
+      (set write (+ write 1))))
+  (for [i write (- (length nums) 1)]
+    (tset nums i 0))
+  nums)
+
+(print (move-zeroes [0 1 0 3 12]))
+(print (move-zeroes [0]))
+(print (move-zeroes [1 2 3]))

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

@@ -1,19 +1,36 @@
-(class Stack)
+(class MinStack)
 
 (fn initialize []
-  (set (ivar xs) []))
+  (set (ivar xs) [])
+  (set (ivar mins) []))
 
-(fn push! [x]
-  (let [xs (ivar xs)]
-    (xs.push x))
+(fn push [x]
+  (let [xs (ivar xs)
+        mins (ivar mins)
+        current-min (if (mins.empty?) x (< x (. mins -1)) x (. mins -1))]
+    (xs.push x)
+    (mins.push current-min))
   self)
 
-(fn pop! []
+(fn pop []
+  (let [mins (ivar mins)]
+    (mins.pop))
   (let [xs (ivar xs)]
     (xs.pop)))
 
-(fn empty? []
-  (= 0 (length (ivar xs))))
+(fn top []
+  (. (ivar xs) -1))
+
+(fn get-min []
+  (. (ivar mins) -1))
+
+(let [s (MinStack.new)]
+  (s.push -2)
+  (s.push 0)
+  (s.push -3)
+  (print (s.get-min))
+  (s.pop)
+  (print (s.top))
+  (print (s.get-min)))
 
-(fn size []
-  (length (ivar xs)))
+(print (= MinStack.superclass Object))

data/examples/two-sum-hash.kap

@@ -0,0 +1,17 @@
+(let [
+  two-sum-hash
+  (fn [nums target seen]
+    (var i 0)
+    (var answer nil)
+    (while (and (< i (length nums)) (= answer nil))
+      (let [n (. nums i)
+            complement (- target n)]
+        (if (seen.key? complement)
+            (set answer [(. seen complement) i])
+            (tset seen n i)))
+      (set i (+ i 1)))
+    answer)
+]
+  (print (two-sum-hash [2 7 11 15] 9 {}))
+  (print (two-sum-hash [3 2 4] 6 {}))
+  (print (two-sum-hash [1 2 3] 10 {})))

data/examples/use_bank_account.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'kapusta'
+
+Kapusta.require('./bank-account', relative_to: __FILE__)
+
+account = BankAccount.new('Ada', 100)
+account.deposit(50)
+account.withdraw(30)
+
+puts "Owner:   #{account.owner}"
+puts "Balance: #{account.balance}"

data/examples/valid-parentheses-1.kap

@@ -0,0 +1,19 @@
+(class ValidParenthesesSolution)
+
+(fn initialize []
+  (set (ivar pairs)
+    {")" "(" "]" "[" "}" "{"}))
+
+(fn valid? [s]
+  (let [pairs (ivar pairs)
+        stack []
+        chars (s.chars)]
+    (var i 0)
+    (var ok true)
+    (while (and ok (< i (length chars)))
+      (let [ch (. chars i)]
+        (if (pairs.key? ch)
+            (if (-?> (stack.pop) (= (. pairs ch))) nil (set ok false))
+            (stack.push ch)))
+      (set i (+ i 1)))
+    (and ok (stack.empty?))))

data/examples/valid-parentheses-2.kap

@@ -0,0 +1,8 @@
+(require "./valid-parentheses-1")
+
+(let [solution (ValidParenthesesSolution.new)]
+  (print (solution.valid? "()"))
+  (print (solution.valid? "()[]{}"))
+  (print (solution.valid? "([])"))
+  (print (solution.valid? "(]"))
+  (print (solution.valid? "([)]")))

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/ast.rb

@@ -25,12 +25,16 @@ module Kapusta
     end
 
     def ==(other)
-      other.is_a?(Sym) && other.name == @name
+      other.instance_of?(self.class) && other.name == @name
     end
     alias eql? ==
 
     def hash
-      @name.hash
+      [self.class, @name].hash
+    end
+
+    def binding_key
+      @name
     end
 
     def dotted?
@@ -42,6 +46,32 @@ module Kapusta
     end
   end
 
+  class GeneratedSym < Sym
+    attr_reader :id
+
+    def initialize(name, id)
+      super(name)
+      @id = id
+    end
+
+    def inspect
+      "#<GeneratedSym #{@name} #{@id}>"
+    end
+
+    def ==(other)
+      other.is_a?(GeneratedSym) && other.id == @id
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @id].hash
+    end
+
+    def binding_key
+      [self.class, @id]
+    end
+  end
+
   class Vec
     attr_reader :items
 
@@ -62,7 +92,7 @@ module Kapusta
     end
 
     def all_sym_keys?
-      pairs.all? { |key, _| key.is_a?(Symbol) }
+      pairs.any? && pairs.all? { |key, _| key.is_a?(Symbol) }
     end
   end
 

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

@@ -42,9 +42,7 @@ module Kapusta
         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)
+          params, body_code = build_simple_block_parts(pattern, body, env, current_scope)
           header = params.empty? ? 'proc do' : "proc do |#{params.join(', ')}|"
           [
             header,
@@ -53,6 +51,13 @@ module Kapusta
           ].join("\n")
         end
 
+        def build_simple_block_parts(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)
+          [params, body_code]
+        end
+
         def simple_parameter_pattern?(pattern)
           pattern.is_a?(Vec) && pattern.items.all? { |item| item.is_a?(Sym) && !item.dotted? && item.name != '&' }
         end
@@ -172,9 +177,7 @@ module Kapusta
         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, body_code = build_simple_block_parts(pattern, body, env, :toplevel)
           [params.empty? ? 'do' : "do |#{params.join(', ')}|", body_code]
         end
 
@@ -200,9 +203,12 @@ module Kapusta
 
         def sym_captures_outer_binding?(sym, env, local_names)
           name = sym.dotted? ? sym.segments.first : sym.name
-          return false if local_names.include?(name) || !env.defined?(name)
+          return false if local_names.include?(name)
+
+          binding = env.lookup_if_defined(name)
+          return false if binding.nil?
 
-          !method_binding?(env.lookup(name))
+          !method_binding?(binding)
         end
 
         def emit_let(args, env, current_scope)
@@ -266,10 +272,10 @@ module Kapusta
           value_code = emit_expr(form.items[2], env, current_scope)
 
           if target.is_a?(Sym) && !target.dotted?
+            binding = env.lookup_if_defined(target.name)
             ruby_name =
-              if env.defined?(target.name)
-                binding = env.lookup(target.name)
-                raise Error, "cannot set method binding: #{target.name}" if method_binding?(binding)
+              if binding
+                emit_error!("cannot set method binding: #{target.name}") if method_binding?(binding)
 
                 binding
               else
@@ -292,10 +298,17 @@ module Kapusta
           when Sym
             if target.dotted?
               base_code, segments = multisym_base(target.segments, env)
-              runtime_call(:set_method_path, base_code, segments.inspect, value_code)
+              receiver = emit_method_path(base_code, segments[0...-1])
+              last = segments.last
+              snake = Kapusta.kebab_to_snake(last)
+              if direct_method_name?(last)
+                "#{receiver}.#{snake} = #{value_code}"
+              else
+                "#{receiver}.public_send(:\"#{snake}=\", #{value_code})"
+              end
             else
               binding = env.lookup(target.name)
-              raise Error, "cannot set method binding: #{target.name}" if method_binding?(binding)
+              emit_error!("cannot set method binding: #{target.name}") if method_binding?(binding)
 
               "#{binding} = #{value_code}"
             end
@@ -303,24 +316,21 @@ module Kapusta
             head = target.head
             if head.is_a?(Sym) && head.name == '.'
               object_code = emit_expr(target.items[1], env, current_scope)
-              keys_code = "[#{target.items[2..].map { |item| emit_expr(item, env, current_scope) }.join(', ')}]"
-              runtime_call(:set_path, object_code, keys_code, value_code)
+              keys = target.items[2..].map { |item| emit_expr(item, env, current_scope) }
+              receiver = simple_expression?(object_code) ? object_code : parenthesize(object_code)
+              prefix = keys[0...-1].map { |k| "[#{k}]" }.join
+              "#{receiver}#{prefix}[#{keys.last}] = #{value_code}"
             elsif head.is_a?(Sym) && head.name == 'ivar'
-              runtime_call(:set_ivar, 'self', target.items[1].name.inspect, value_code)
+              "@#{Kapusta.kebab_to_snake(target.items[1].name)} = #{value_code}"
             elsif head.is_a?(Sym) && head.name == 'cvar'
-              runtime_call(:set_cvar, 'self', target.items[1].name.inspect, value_code)
+              "@@#{Kapusta.kebab_to_snake(target.items[1].name)} = #{value_code}"
             elsif head.is_a?(Sym) && head.name == 'gvar'
-              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
+              "$#{global_name(target.items[1].name)} = #{value_code}"
             else
-              raise Error, "bad set target: #{target.inspect}"
+              emit_error!("bad set target: #{target.inspect}")
             end
           else
-            raise Error, "bad set target: #{target.inspect}"
+            emit_error!("bad set target: #{target.inspect}")
           end
         end
       end

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
@@ -82,12 +90,12 @@ module Kapusta
           arm_env = env.child
           assign_code, arm_env = emit_bindings_from_match(plan[:bindings], bindings_var, arm_env)
           body_code = emit_expr(body, arm_env, current_scope)
+          arm_body = [assign_code, body_code].reject(&:empty?).join("\n")
           <<~RUBY.chomp
             #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
             if #{match_var}[0]
               #{bindings_var} = #{match_var}[1]
-              #{assign_code}
-              #{body_code}
+              #{arm_body}
             else
               #{indent(else_code)}
             end
@@ -104,11 +112,11 @@ module Kapusta
           assign_code, arm_env = emit_bindings_from_match(plan[:bindings], bindings_var, arm_env)
           guard_code = emit_case_guards(guards, arm_env, current_scope)
           body_code = emit_expr(body, arm_env, current_scope)
+          bindings_line = assign_code.empty? ? '' : "\n  #{assign_code}"
           <<~RUBY.chomp
             #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
             if #{match_var}[0]
-              #{bindings_var} = #{match_var}[1]
-              #{assign_code}
+              #{bindings_var} = #{match_var}[1]#{bindings_line}
               if #{guard_code}
                 #{body_code}
               else