kapusta 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c136e4c7cc9c5dde0ced8c828ab80882900b278db86010986eb7271a7b45309e
-  data.tar.gz: 46ff912715738e99c454727224a5e19f6d1635fbfccb1ade3820a9a51a996d0d
+  metadata.gz: 53512e4cdebbb07a50f1bff53338574994140e5b16ddc5c1fd05e27b8cbc8a20
+  data.tar.gz: c7907d4901ecfb193c4df0c0b09bca2869babab65f6327d542c59a88a9edff51
 SHA512:
-  metadata.gz: 9d36ad79125c72a9e804f10ce9e0e5983e852b428f1a1a3718e21ef9394c66f39e57bec366ed81257bd5e62439429cc1cd93039710404db2c8dc0f3d9c09c44a
-  data.tar.gz: 0cb236654de0a57184387087c5a7f47dc49d548c1fed0167638439c071b83cda592cd0346f68ffc086c74afccff0b1f08c90ec977238213b9672fa8244052b27
+  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/bin/compile-examples

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SOURCE_DIR="$ROOT_DIR/examples"
+TARGET_DIR="$ROOT_DIR/examples-compiled"
+
+mkdir -p "$TARGET_DIR"
+
+shopt -s nullglob
+kap_files=("$SOURCE_DIR"/*.kap)
+
+if ((${#kap_files[@]} == 0)); then
+  printf 'No .kap files found in %s\n' "$SOURCE_DIR" >&2
+  exit 0
+fi
+
+for kap_file in "${kap_files[@]}"; do
+  name="$(basename "$kap_file" .kap)"
+  ruby_file="$TARGET_DIR/$name.rb"
+
+  "$ROOT_DIR/exe/kapusta" --compile "$kap_file" > "$ruby_file"
+  printf 'Compiled %s -> %s\n' "$kap_file" "$ruby_file"
+done

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,10 +51,42 @@ 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
 
+        def emit_definition_form(form, env, current_scope)
+          return [emit_method_definition(form, env), env] unless current_scope == :toplevel
+
+          emit_toplevel_method_definition(form, env)
+        end
+
+        def emit_toplevel_method_definition(form, env)
+          name_sym = form.items[1]
+          pattern = form.items[2]
+          body = form.items[3..]
+          return [nil, env] if name_sym.dotted?
+          return [nil, env] unless simple_parameter_pattern?(pattern)
+
+          ruby_name = direct_method_definition_name(name_sym)
+          return [nil, env] unless ruby_name
+          return [nil, env] if captures_outer_binding?(body, env, pattern_names(pattern))
+
+          env.define(name_sym.name, Env::MethodBinding.new(ruby_name))
+          definition = emit_direct_method_definition(name_sym, pattern, body, env)
+          if needs_toplevel_method_bridge?(ruby_name)
+            definition = join_code(definition, emit_toplevel_method_bridge(ruby_name))
+          end
+          [definition, env]
+        end
+
         def emit_named_fn_assignment(form, env, current_scope)
           name_sym = form.items[1]
           ruby_name = define_local(env, name_sym.name)
@@ -70,6 +100,9 @@ module Kapusta
           name_sym = form.items[1]
           pattern = form.items[2]
           body = form.items[3..]
+          direct_definition = emit_direct_method_definition(name_sym, pattern, body, env)
+          return direct_definition if direct_definition
+
           block_header, body_code = emit_method_body(pattern, body, env)
 
           if name_sym.name.start_with?('self.')
@@ -89,6 +122,48 @@ module Kapusta
           end
         end
 
+        def emit_direct_method_definition(name_sym, pattern, body, env)
+          return unless simple_parameter_pattern?(pattern)
+
+          ruby_name = direct_method_definition_name(name_sym)
+          return unless ruby_name
+          return if captures_outer_binding?(body, env, pattern_names(pattern))
+
+          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)
+          header = params.empty? ? "def #{ruby_name}" : "def #{ruby_name}(#{params.join(', ')})"
+          [
+            header,
+            indent(body_code),
+            'end'
+          ].join("\n")
+        end
+
+        def direct_method_definition_name(name_sym)
+          source_name = name_sym.name
+          if source_name.start_with?('self.')
+            method_name = Kapusta.kebab_to_snake(source_name.delete_prefix('self.'))
+            return unless direct_method_name?(method_name)
+
+            "self.#{method_name}"
+          else
+            method_name = Kapusta.kebab_to_snake(source_name)
+            return unless direct_method_name?(method_name)
+
+            method_name
+          end
+        end
+
+        def needs_toplevel_method_bridge?(ruby_name)
+          %w[context describe example it specify].include?(ruby_name)
+        end
+
+        def emit_toplevel_method_bridge(ruby_name)
+          method_name = ruby_name.to_sym.inspect
+          "define_singleton_method(#{method_name}, Object.instance_method(#{method_name}).bind(self))"
+        end
+
         def emit_method_body(pattern, body, env)
           return emit_simple_method_body(pattern, body, env) if simple_parameter_pattern?(pattern)
 
@@ -102,12 +177,40 @@ 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
 
+        def captures_outer_binding?(forms, env, local_names)
+          forms.any? { |form| form_captures_outer_binding?(form, env, local_names) }
+        end
+
+        def form_captures_outer_binding?(form, env, local_names)
+          case form
+          when Sym
+            sym_captures_outer_binding?(form, env, local_names)
+          when Vec, List
+            form.items.any? { |item| form_captures_outer_binding?(item, env, local_names) }
+          when HashLit
+            form.pairs.any? do |key, value|
+              form_captures_outer_binding?(key, env, local_names) ||
+                form_captures_outer_binding?(value, env, local_names)
+            end
+          else
+            false
+          end
+        end
+
+        def sym_captures_outer_binding?(sym, env, local_names)
+          name = sym.dotted? ? sym.segments.first : sym.name
+          return false if local_names.include?(name)
+
+          binding = env.lookup_if_defined(name)
+          return false if binding.nil?
+
+          !method_binding?(binding)
+        end
+
         def emit_let(args, env, current_scope)
           binding_code, body_code = emit_let_parts(args, env, current_scope, result: true)
           <<~RUBY.chomp
@@ -169,9 +272,12 @@ 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)
-                env.lookup(target.name)
+              if binding
+                emit_error!("cannot set method binding: #{target.name}") if method_binding?(binding)
+
+                binding
               else
                 define_local(env, target.name)
               end
@@ -192,32 +298,39 @@ 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
-              "#{env.lookup(target.name)} = #{value_code}"
+              binding = env.lookup(target.name)
+              emit_error!("cannot set method binding: #{target.name}") if method_binding?(binding)
+
+              "#{binding} = #{value_code}"
             end
           when List
             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