kapusta 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c136e4c7cc9c5dde0ced8c828ab80882900b278db86010986eb7271a7b45309e
-  data.tar.gz: 46ff912715738e99c454727224a5e19f6d1635fbfccb1ade3820a9a51a996d0d
+  metadata.gz: 52369f7a4cd658385e7ddc69f552477d94b55340cb9f796ac635550a7def6e6a
+  data.tar.gz: 6d673c9c387b52b0e4cd9e55b8ae2cf1d0a7e2c5f741dc7705f405b0ddaf25c6
 SHA512:
-  metadata.gz: 9d36ad79125c72a9e804f10ce9e0e5983e852b428f1a1a3718e21ef9394c66f39e57bec366ed81257bd5e62439429cc1cd93039710404db2c8dc0f3d9c09c44a
-  data.tar.gz: 0cb236654de0a57184387087c5a7f47dc49d548c1fed0167638439c071b83cda592cd0346f68ffc086c74afccff0b1f08c90ec977238213b9672fa8244052b27
+  metadata.gz: 53510507ba41a4d67ec73184eaef665fee182220407046eb9db64cf05cae7d28a315b5b8cf4ace6071b359a83801bd85d7e45ce5e4aefd3c608fef614f116fee
+  data.tar.gz: ff1b88fc11dc10ccffc1459686b17754bd39dc6a941756d7cab304253aec3b63bc36967c9edcf50cf4c29eadee3ae2afb0467383b6428dcb74f41c452173ab4a

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/lib/kapusta/compiler/emitter/bindings.rb

@@ -57,6 +57,31 @@ module Kapusta
           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 +95,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 +117,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)
 
@@ -108,6 +178,33 @@ module Kapusta
           [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) || !env.defined?(name)
+
+          !method_binding?(env.lookup(name))
+        end
+
         def emit_let(args, env, current_scope)
           binding_code, body_code = emit_let_parts(args, env, current_scope, result: true)
           <<~RUBY.chomp
@@ -171,7 +268,10 @@ module Kapusta
           if target.is_a?(Sym) && !target.dotted?
             ruby_name =
               if env.defined?(target.name)
-                env.lookup(target.name)
+                binding = env.lookup(target.name)
+                raise Error, "cannot set method binding: #{target.name}" if method_binding?(binding)
+
+                binding
               else
                 define_local(env, target.name)
               end
@@ -194,7 +294,10 @@ module Kapusta
               base_code, segments = multisym_base(target.segments, env)
               runtime_call(:set_method_path, base_code, segments.inspect, value_code)
             else
-              "#{env.lookup(target.name)} = #{value_code}"
+              binding = env.lookup(target.name)
+              raise Error, "cannot set method binding: #{target.name}" if method_binding?(binding)
+
+              "#{binding} = #{value_code}"
             end
           when List
             head = target.head

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

@@ -36,7 +36,7 @@ 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_callable_call(env.lookup(head.name), args, env, current_scope) if env.defined?(head.name)
+            return emit_bound_call(env.lookup(head.name), args, env, current_scope) if env.defined?(head.name)
 
             return emit_self_call(head.name, args, env, current_scope)
           end
@@ -68,9 +68,7 @@ module Kapusta
           when '.' then emit_lookup(args, env, current_scope)
           when '?.' then emit_safe_lookup(args, env, current_scope)
           when ':' then emit_colon(args, env, current_scope)
-          when '..' then runtime_call(:concat, args.map do |arg|
-            emit_expr(arg, env, current_scope)
-          end)
+          when '..' then emit_concat(args, env, current_scope)
           when 'length' then "(#{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)
@@ -95,13 +93,31 @@ module Kapusta
           when '*' then emit_reduce(args, env, current_scope, '1', :*)
           when '/' then emit_div(args, env, current_scope)
           when '%' then args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(' % ')
-          when 'print' then runtime_call(:print_values, *args.map do |arg|
-            emit_expr(arg, env, current_scope)
-          end)
+          when 'print' then emit_print(args, env, current_scope)
           else
             raise Error, "unknown special form: #{name}"
           end
         end
+
+        def emit_concat(args, env, current_scope)
+          return '""' if args.empty?
+
+          args.map { |arg| emit_string_part(arg, env, current_scope) }.join(' + ')
+        end
+
+        def emit_print(args, env, current_scope)
+          return '$stdout.puts("")' 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})"
+        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))
+        end
       end
     end
   end

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

@@ -63,7 +63,7 @@ module Kapusta
 
         def emit_direct_module_header(name_sym, body)
           const_name = simple_constant_name(name_sym)
-          return nil unless const_name
+          return unless const_name
 
           [
             "module #{const_name}",
@@ -94,7 +94,7 @@ module Kapusta
 
         def emit_direct_class_header(name_sym, supers, body)
           const_name = simple_constant_name(name_sym)
-          return nil unless const_name && supers.nil?
+          return unless const_name && supers.nil?
 
           [
             "class #{const_name}",
@@ -105,7 +105,7 @@ module Kapusta
         end
 
         def simple_constant_name(name_sym)
-          return nil unless name_sym.is_a?(Sym) && name_sym.name.match?(/\A[A-Z]\w*\z/)
+          return unless name_sym.is_a?(Sym) && name_sym.name.match?(/\A[A-Z]\w*\z/)
 
           name_sym.name
         end
@@ -212,6 +212,22 @@ module Kapusta
           runtime_call(:call, callee_code, "[#{positional.join(', ')}]", kwargs, block)
         end
 
+        def emit_bound_call(binding, args, env, current_scope)
+          return emit_self_method_binding_call(binding, args, env, current_scope) if method_binding?(binding)
+
+          emit_callable_call(binding, args, env, current_scope)
+        end
+
+        def emit_self_method_binding_call(binding, args, env, current_scope)
+          positional = args.map { |arg| emit_expr(arg, env, current_scope) }
+          emit_direct_self_method_call(binding.ruby_name, positional)
+        end
+
+        def emit_direct_self_method_call(method_name, positional)
+          args = positional.join(', ')
+          args.empty? ? "#{method_name}()" : "#{method_name}(#{args})"
+        end
+
         def emit_direct_callable_call(callee_code, positional)
           rendered_args = positional.join(', ')
           suffix = rendered_args.empty? ? '.call' : ".call(#{rendered_args})"
@@ -285,7 +301,7 @@ module Kapusta
           name = sym.name
           return 'self' if name == 'self'
           return 'Float::INFINITY' if name == 'math.huge'
-          return env.lookup(name) if env.defined?(name)
+          return binding_value_code(env.lookup(name)) if env.defined?(name)
           return emit_multisym_value(sym, env) if sym.dotted?
           return 'ARGV' if name == 'ARGV'
           return name if name.match?(/\A[A-Z]/)
@@ -311,7 +327,7 @@ module Kapusta
           if segments[0] == 'self'
             ['self', segments[1..]]
           elsif env.defined?(segments[0])
-            [env.lookup(segments[0]), segments[1..]]
+            [binding_value_code(env.lookup(segments[0])), segments[1..]]
           else
             idx = 0
             const_path = []

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

@@ -91,7 +91,7 @@ module Kapusta
           if state[:bound_names].key?(name)
             "[:ref, #{name.inspect}]"
           elsif prefer_pin && mode == :match && env.defined?(name)
-            "[:pin, #{env.lookup(name)}]"
+            "[:pin, #{binding_value_code(env.lookup(name))}]"
           else
             state[:bound_names][name] = true
             state[:binding_names] << name
@@ -121,7 +121,7 @@ module Kapusta
           raise Error, "bad pin pattern: #{pattern.inspect}" unless name_sym.is_a?(Sym)
           raise Error, "cannot pin undefined name: #{name_sym.name}" unless env.defined?(name_sym.name)
 
-          "[:pin, #{env.lookup(name_sym.name)}]"
+          "[:pin, #{binding_value_code(env.lookup(name_sym.name))}]"
         end
 
         def emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)

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

@@ -63,9 +63,14 @@ module Kapusta
         end
 
         def emit_form_in_sequence(form, env, current_scope, allow_method_definitions:, result_needed: true)
-          if allow_method_definitions && method_definition_form?(form) && %i[module class].include?(current_scope)
-            [emit_method_definition(form, env), env]
-          elsif named_function_form?(form)
+          if allow_method_definitions &&
+             method_definition_form?(form) &&
+             %i[toplevel module class].include?(current_scope)
+            code, env = emit_definition_form(form, env, current_scope)
+            return [code, env] if code
+          end
+
+          if named_function_form?(form)
             emit_named_fn_assignment(form, env, current_scope)
           elsif local_form?(form)
             code, env = emit_local_form(form, env, current_scope)
@@ -219,6 +224,14 @@ module Kapusta
           "#{runtime_helper(name)}(#{rendered_args.join(', ')})"
         end
 
+        def method_binding?(binding)
+          binding.is_a?(Env::MethodBinding)
+        end
+
+        def binding_value_code(binding)
+          method_binding?(binding) ? "method(#{binding.ruby_name.to_sym.inspect})" : binding
+        end
+
         def parse_counted_for_bindings(bindings, env, current_scope)
           name_sym = bindings[0]
           loop_env = env.child

data/lib/kapusta/compiler/normalizer.rb

@@ -74,7 +74,7 @@ module Kapusta
       end
 
       def wrap_do(forms)
-        return nil if forms.empty?
+        return if forms.empty?
         return forms.first if forms.length == 1
 
         List.new([Sym.new('do'), *forms])

data/lib/kapusta/compiler/runtime.rb

@@ -4,6 +4,7 @@ module Kapusta
   module Compiler
     module Runtime
       HELPER_DEPENDENCIES = {
+        stringify: %i[repr],
         print_values: %i[stringify],
         concat: %i[stringify],
         method_path_value: %i[kebab_to_snake],
@@ -63,33 +64,30 @@ module Kapusta
             end
           end
         RUBY
-        stringify: <<~'RUBY'.chomp,
+        stringify: <<~RUBY.chomp,
           def kap_stringify(value)
-            render = nil
-            render = lambda do |item|
-              case item
-              when nil then 'nil'
-              when true then 'true'
-              when false then 'false'
-              when String, Symbol then item.inspect
-              when Array
-                "[#{item.map { |child| render.call(child) }.join(', ')}]"
-              when Hash
-                "{#{item.map { |key, child| "#{render.call(key)}=>#{render.call(child)}" }.join(', ')}}"
-              else
-                item.inspect
-              end
-            end
-
             case value
             when nil then 'nil'
-            when true then 'true'
-            when false then 'false'
-            when Array, Hash then render.call(value)
+            when Array, Hash then kap_repr(value)
             else value.to_s
             end
           end
         RUBY
+        repr: <<~'RUBY'.chomp,
+          def kap_repr(value)
+            case value
+            when nil then 'nil'
+            when true, false then value.to_s
+            when String, Symbol then value.inspect
+            when Array
+              "[#{value.map { |item| kap_repr(item) }.join(', ')}]"
+            when Hash
+              "{#{value.map { |key, item| "#{kap_repr(key)}=>#{kap_repr(item)}" }.join(', ')}}"
+            else
+              value.inspect
+            end
+          end
+        RUBY
         print_values: <<~'RUBY'.chomp,
           def kap_print_values(*values)
             $stdout.puts(values.map { |value| kap_stringify(value) }.join("\t"))
@@ -109,7 +107,7 @@ module Kapusta
         qget_path: <<~RUBY.chomp,
           def kap_qget_path(obj, keys)
             keys.each do |key|
-              return nil if obj.nil?
+              return if obj.nil?
 
               obj = obj[key]
             end
@@ -367,10 +365,13 @@ module Kapusta
 
       HELPER_SOURCES.each_key do |name|
         helper_method = :"kap_#{name}"
-        define_singleton_method(name, instance_method(helper_method))
+        body = instance_method(helper_method)
+        define_singleton_method(helper_method, body)
+        define_singleton_method(name, body)
         helper_methods << helper_method
       end
 
+      private_class_method(*helper_methods)
       send(:private, *helper_methods)
     end
   end

data/lib/kapusta/env.rb

@@ -2,6 +2,8 @@
 
 module Kapusta
   class Env
+    MethodBinding = Struct.new(:ruby_name)
+
     def initialize(parent = nil)
       @parent = parent
       @vars = {}
@@ -26,11 +28,11 @@ module Kapusta
     end
 
     def ruby_name_defined?(name)
-      @vars.value?(name) || @parent&.ruby_name_defined?(name)
+      @vars.any? { |_source_name, value| binding_ruby_name(value) == name } || @parent&.ruby_name_defined?(name)
     end
 
     def local_ruby_name_defined?(name)
-      @vars.value?(name)
+      @vars.any? { |_source_name, value| binding_ruby_name(value) == name }
     end
 
     def set_existing!(name, value)
@@ -46,5 +48,11 @@ module Kapusta
     def child
       Env.new(self)
     end
+
+    private
+
+    def binding_ruby_name(value)
+      value.respond_to?(:ruby_name) ? value.ruby_name : value
+    end
   end
 end

data/lib/kapusta/formatter.rb

@@ -177,15 +177,15 @@ module Kapusta
       when Sym
         form.name
       when Vec
-        return nil if contains_comments?(form.items)
+        return if contains_comments?(form.items)
 
         "[#{form.items.map { |item| flat_render(item) }.join(' ')}]"
       when HashLit
-        return nil if contains_comments?(form.entries)
+        return if contains_comments?(form.entries)
 
         "{#{form.pairs.map { |key, value| flat_hash_pair(key, value) }.join(' ')}}"
       when List
-        return nil if contains_comments?(form.items)
+        return if contains_comments?(form.items)
         return "##{flat_render(semantic_items(form.items)[1])}" if hashfn_literal?(form)
 
         "(#{form.items.map { |item| flat_render(item) }.join(' ')})"
@@ -548,13 +548,12 @@ module Kapusta
 
     def render_hanging_pairwise_vec(vec)
       pairs = vec.items.each_slice(2).to_a
-      rendered_pairs = pairs.map do |pair|
-        left, right = pair
-        return nil unless pair.length == 2
+      return unless pairs.all? { |pair| pair.length == 2 }
 
+      rendered_pairs = pairs.map do |left, right|
         render_binding_pair(left, right)
       end
-      return nil if rendered_pairs.any?(&:nil?)
+      return if rendered_pairs.any?(&:nil?)
 
       lines = ["[#{rendered_pairs.first}"]
       continuation = ' ' * '(let ['.length
@@ -609,7 +608,7 @@ module Kapusta
     def render_pair(left, right, indent)
       left_rendered = flat_render(left) || render(left, indent)
       right_rendered = flat_render(right) || render(right, indent)
-      return nil unless single_line?(left_rendered) && single_line?(right_rendered)
+      return unless single_line?(left_rendered) && single_line?(right_rendered)
 
       pair = "#{left_rendered} #{right_rendered}"
       fits?(pair, indent) ? pair : nil
@@ -617,12 +616,12 @@ module Kapusta
 
     def render_binding_pair(left, right)
       left_rendered = flat_render(left)
-      return nil unless left_rendered
+      return unless left_rendered
 
       right_rendered = render(right, '(let ['.length + left_rendered.length + 1)
       first_line, *rest = right_rendered.lines(chomp: true)
       pair = "#{left_rendered} #{first_line}"
-      return nil unless pair.length <= MAX_WIDTH
+      return unless pair.length <= MAX_WIDTH
 
       return pair if rest.empty?
 

data/lib/kapusta/reader.rb

@@ -221,9 +221,9 @@ module Kapusta
     def parse_atom(token)
       return true if token == 'true'
       return false if token == 'false'
-      return nil if token == 'nil'
-      return token.to_i if token.match?(/\A-?\d+\z/)
-      return token.to_f if token.match?(/\A-?\d+\.\d+\z/)
+      return if token == 'nil'
+      return Integer(token, 10) if token.match?(/\A-?\d+\z/)
+      return Float(token) if token.match?(/\A-?\d+\.\d+\z/)
 
       if token.start_with?(':') && token.length > 1
         Kapusta.kebab_to_snake(token[1..]).to_sym

data/lib/kapusta/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -22,6 +22,7 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- bin/compile-examples
 - bin/console
 - bin/setup
 - examples/accumulator.kap