kapusta 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52369f7a4cd658385e7ddc69f552477d94b55340cb9f796ac635550a7def6e6a
-  data.tar.gz: 6d673c9c387b52b0e4cd9e55b8ae2cf1d0a7e2c5f741dc7705f405b0ddaf25c6
+  metadata.gz: 53512e4cdebbb07a50f1bff53338574994140e5b16ddc5c1fd05e27b8cbc8a20
+  data.tar.gz: c7907d4901ecfb193c4df0c0b09bca2869babab65f6327d542c59a88a9edff51
 SHA512:
-  metadata.gz: 53510507ba41a4d67ec73184eaef665fee182220407046eb9db64cf05cae7d28a315b5b8cf4ace6071b359a83801bd85d7e45ce5e4aefd3c608fef614f116fee
-  data.tar.gz: ff1b88fc11dc10ccffc1459686b17754bd39dc6a941756d7cab304253aec3b63bc36967c9edcf50cf4c29eadee3ae2afb0467383b6428dcb74f41c452173ab4a
+  metadata.gz: c185f6d33f64071522cef35498fb7310f47d4091d3873868361294ff40edb51e836cdb2c0168dac1f599bc9ccd7c230d34d276fa6ab1a3fca479a4a4c40b9025
+  data.tar.gz: dcf0acd60680784bb38685305f5454466e4c36358d08a2994e2ca988e5fa19d32fa6eafdb48bb1054681e5699daaddc4b9ebf73477f0450d8dc78482cfad0147

data/README.md

@@ -29,6 +29,18 @@ 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`.
+
 ## Comparison with Fennel
 
 Kapusta keeps most core Fennel forms. The main differences come from Ruby's runtime and object model.
@@ -40,6 +52,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                                  |
 

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/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/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/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/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

@@ -82,12 +82,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 +104,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

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

@@ -17,7 +17,7 @@ module Kapusta
           when List then emit_list(form, env, current_scope)
           when String, Symbol, Numeric, true, false, nil then form.inspect
           else
-            raise Error, "cannot emit form: #{form.inspect}"
+            emit_error!("cannot emit form: #{form.inspect}")
           end
         end
 
@@ -36,7 +36,9 @@ module Kapusta
           if head.is_a?(Sym)
             return emit_special(head.name, args, env, current_scope) if special_form?(head.name)
             return emit_multisym_call(head, args, env, current_scope) if head.dotted?
-            return emit_bound_call(env.lookup(head.name), args, env, current_scope) if env.defined?(head.name)
+            if (binding = env.lookup_if_defined(head.name))
+              return emit_bound_call(binding, args, env, current_scope)
+            end
 
             return emit_self_call(head.name, args, env, current_scope)
           end
@@ -69,21 +71,21 @@ module Kapusta
           when '?.' then emit_safe_lookup(args, env, current_scope)
           when ':' then emit_colon(args, env, current_scope)
           when '..' then emit_concat(args, env, current_scope)
-          when 'length' then "(#{emit_expr(args[0], env, current_scope)}).length"
+          when 'length' then "#{parenthesize(emit_expr(args[0], env, current_scope))}.length"
           when 'require' then emit_require(args[0], env, current_scope)
           when 'module' then emit_module_expr(args, env)
           when 'class' then emit_class_expr(args, env)
           when 'try' then emit_try(args, env, current_scope)
           when 'raise' then emit_raise(args, env, current_scope)
-          when 'ivar' then runtime_call(:get_ivar, 'self', args[0].name.inspect)
-          when 'cvar' then runtime_call(:get_cvar, 'self', args[0].name.inspect)
+          when 'ivar' then "@#{Kapusta.kebab_to_snake(args[0].name)}"
+          when 'cvar' then "@@#{Kapusta.kebab_to_snake(args[0].name)}"
           when 'gvar' then emit_gvar(args[0])
           when 'ruby' then "Kernel.eval(#{emit_expr(args[0], env, current_scope)})"
           when 'and' then emit_and(args, env, current_scope)
           when 'or' then emit_or(args, env, current_scope)
-          when 'not' then "(!#{emit_expr(args[0], env, current_scope)})"
+          when 'not' then "!#{parenthesize(emit_expr(args[0], env, current_scope))}"
           when '=' then emit_compare(args, env, current_scope, '==')
-          when 'not=' then "(!#{emit_special('=', args, env, current_scope)})"
+          when 'not=' then emit_compare_any(args, env, current_scope, '!=')
           when '<' then emit_compare(args, env, current_scope, '<')
           when '<=' then emit_compare(args, env, current_scope, '<=')
           when '>' then emit_compare(args, env, current_scope, '>')
@@ -95,7 +97,7 @@ module Kapusta
           when '%' then args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(' % ')
           when 'print' then emit_print(args, env, current_scope)
           else
-            raise Error, "unknown special form: #{name}"
+            emit_error!("unknown special form: #{name}")
           end
         end
 
@@ -106,17 +108,15 @@ module Kapusta
         end
 
         def emit_print(args, env, current_scope)
-          return '$stdout.puts("")' if args.empty?
+          return 'p' if args.empty?
 
-          values = args.map { |arg| emit_string_part(arg, env, current_scope) }
-          output = values.length == 1 ? values.first : "[#{values.join(', ')}].join(\"\\t\")"
-          "$stdout.puts(#{output})"
+          "p(#{args.map { |arg| emit_expr(arg, env, current_scope) }.join(', ')})"
         end
 
         def emit_string_part(arg, env, current_scope)
           return arg.inspect if arg.is_a?(String)
 
-          runtime_call(:stringify, emit_expr(arg, env, current_scope))
+          "(#{emit_expr(arg, env, current_scope)}).to_s"
         end
       end
     end