kapusta 0.1.5 → 0.2.0

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

@@ -8,8 +8,11 @@ module Kapusta
 
         def emit_lookup(args, env, current_scope)
           object_code = emit_expr(args[0], env, current_scope)
-          keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }.join(', ')
-          runtime_call(:get_path, object_code, "[#{keys}]")
+          keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }
+          return object_code if keys.empty?
+
+          receiver = simple_expression?(object_code) ? object_code : parenthesize(object_code)
+          "#{receiver}#{keys.map { |k| "[#{k}]" }.join}"
         end
 
         def emit_safe_lookup(args, env, current_scope)
@@ -20,9 +23,16 @@ module Kapusta
 
         def emit_colon(args, env, current_scope)
           receiver = emit_expr(args[0], env, current_scope)
-          method_name = emit_method_name(args[1], env, current_scope)
+          method_form = args[1]
           positional, kwargs, block = split_call_args(args[2..], env, current_scope)
-          runtime_call(:send_call, receiver, method_name, positional, kwargs, block)
+          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)
+          end
+
+          method_name = emit_method_name(method_form, env, current_scope)
+          parts = build_call_args([method_name, *positional], kwargs, block)
+          "#{parenthesize(receiver)}.public_send(#{parts})"
         end
 
         def emit_require(arg, env, current_scope)
@@ -33,9 +43,30 @@ module Kapusta
             when String then arg.inspect
             else "(#{emit_expr(arg, env, current_scope)}).to_s"
             end
+          if kapusta_require?(arg)
+            return [
+              'unless defined?(Kapusta)',
+              indent('require "kapusta"'),
+              'end',
+              "Kapusta.require(#{path_code}, relative_to: #{@path.inspect})"
+            ].join("\n")
+          end
+
           "require #{path_code}"
         end
 
+        def kapusta_require?(arg)
+          path =
+            case arg
+            when Sym then arg.name
+            when Symbol then arg.to_s
+            when String then arg
+            end
+          return false unless path
+
+          path.end_with?('.kap') || path.start_with?('./', '../') || File.absolute_path?(path)
+        end
+
         def emit_module_expr(args, env)
           body = emit_sequence(args[1..], env, :module, allow_method_definitions: true, result: false).first
           emit_module_wrapper(args[0], body)
@@ -184,6 +215,15 @@ module Kapusta
           end.join(' && ')
         end
 
+        def emit_compare_any(args, env, current_scope, operator)
+          values = args.map { |arg| emit_expr(arg, env, current_scope) }
+          return 'false' if values.length <= 1
+
+          (0...(values.length - 1)).map do |i|
+            "#{parenthesize(values[i])} #{operator} #{parenthesize(values[i + 1])}"
+          end.join(' || ')
+        end
+
         def emit_reduce(args, env, current_scope, empty_value, operator)
           return empty_value if args.empty?
 
@@ -207,9 +247,16 @@ module Kapusta
 
         def emit_callable_call(callee_code, args, env, current_scope)
           positional, kwargs, block = split_call_args(args, env, current_scope)
-          return emit_direct_callable_call(callee_code, positional) unless kwargs || block
+          rendered = build_call_args(positional, kwargs, block)
+          suffix = rendered.empty? ? '.call' : ".call(#{rendered})"
+          "#{parenthesize(callee_code)}#{suffix}"
+        end
 
-          runtime_call(:call, callee_code, "[#{positional.join(', ')}]", kwargs, block)
+        def build_call_args(positional, kwargs, block)
+          parts = positional.dup
+          parts << "**#{kwargs}" if kwargs
+          parts << "&#{block}" if block
+          parts.join(', ')
         end
 
         def emit_bound_call(binding, args, env, current_scope)
@@ -228,30 +275,31 @@ module Kapusta
           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})"
-          "#{parenthesize(callee_code)}#{suffix}"
-        end
-
         def emit_multisym_call(head, args, env, current_scope)
           base_code, segments = multisym_base(head.segments, env)
           if segments.empty?
             emit_callable_call(base_code, args, env, current_scope)
           else
-            receiver =
-              if segments.length == 1
-                base_code
-              else
-                runtime_call(:method_path_value, base_code, segments[0...-1].inspect)
-              end
-            method_name = Kapusta.kebab_to_snake(segments.last).to_sym.inspect
+            receiver = emit_method_path(base_code, segments[0...-1])
             positional, kwargs, block = split_call_args(args, env, current_scope)
-            if segments.length == 1 && !kwargs && !block && direct_method_name?(segments.last)
+            if !kwargs && !block && direct_method_name?(segments.last)
               return emit_direct_method_call(receiver, Kapusta.kebab_to_snake(segments.last), positional)
             end
 
-            runtime_call(:send_call, receiver, method_name, positional, kwargs, block)
+            method_name = Kapusta.kebab_to_snake(segments.last).to_sym.inspect
+            parts = build_call_args([method_name, *positional], kwargs, block)
+            "#{receiver}.public_send(#{parts})"
+          end
+        end
+
+        def emit_method_path(base_code, segments)
+          segments.reduce(base_code) do |acc, segment|
+            snake = Kapusta.kebab_to_snake(segment)
+            if direct_method_name?(segment)
+              "#{acc}.#{snake}"
+            else
+              "#{acc}.public_send(#{snake.to_sym.inspect})"
+            end
           end
         end
 
@@ -265,7 +313,8 @@ module Kapusta
         def emit_self_call(name, args, env, current_scope)
           positional, kwargs, block = split_call_args(args, env, current_scope)
           method_name = Kapusta.kebab_to_snake(name).to_sym.inspect
-          runtime_call(:invoke_self, 'self', method_name, positional, kwargs, block)
+          parts = build_call_args([method_name, *positional], kwargs, block)
+          "send(#{parts})"
         end
 
         def split_call_args(args, env, current_scope)
@@ -301,33 +350,31 @@ module Kapusta
           name = sym.name
           return 'self' if name == 'self'
           return 'Float::INFINITY' if name == 'math.huge'
-          return binding_value_code(env.lookup(name)) if env.defined?(name)
+
+          if (binding = env.lookup_if_defined(sym))
+            return binding_value_code(binding)
+          end
           return emit_multisym_value(sym, env) if sym.dotted?
           return 'ARGV' if name == 'ARGV'
           return name if name.match?(/\A[A-Z]/)
 
-          raise Error, "undefined symbol: #{name}"
+          emit_error!("undefined symbol: #{name}")
         end
 
         def emit_gvar(sym)
-          ruby_name = global_name(sym.name)
-          return "$#{ruby_name}" if direct_global_name?(ruby_name)
-
-          runtime_call(:get_gvar, sym.name.inspect)
+          "$#{global_name(sym.name)}"
         end
 
         def emit_multisym_value(sym, env)
           base_code, segments = multisym_base(sym.segments, env)
-          return base_code if segments.empty?
-
-          runtime_call(:method_path_value, base_code, segments.inspect)
+          emit_method_path(base_code, segments)
         end
 
         def multisym_base(segments, env)
           if segments[0] == 'self'
             ['self', segments[1..]]
-          elsif env.defined?(segments[0])
-            [binding_value_code(env.lookup(segments[0])), segments[1..]]
+          elsif (binding = env.lookup_if_defined(segments[0]))
+            [binding_value_code(binding), segments[1..]]
           else
             idx = 0
             const_path = []
@@ -335,7 +382,7 @@ module Kapusta
               const_path << segments[idx]
               idx += 1
             end
-            raise Error, "bad multisym: #{segments.join('.')}" if const_path.empty?
+            emit_error!("bad multisym: #{segments.join('.')}") if const_path.empty?
 
             [const_path.join('::'), segments[idx..]]
           end
@@ -351,10 +398,6 @@ module Kapusta
           Kapusta.kebab_to_snake(name).match?(/\A[a-z_]\w*[!?=]?\z/)
         end
 
-        def direct_global_name?(name)
-          name.match?(/\A[a-z_]\w*\z/)
-        end
-
         def global_name(name)
           Kapusta.kebab_to_snake(name).gsub(/[^a-zA-Z0-9_]/, '_')
         end
@@ -364,11 +407,19 @@ module Kapusta
             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*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/) ||
             code.match?(/\A:[a-zA-Z_]\w*[!?=]?\z/) ||
             code.match?(/\A"(?:[^"\\]|\\.)*"\z/) ||
             code.match?(/\A'(?:[^'\\]|\\.)*'\z/) ||
-            %w[nil true false self].include?(code)
+            %w[nil true false self].include?(code) ||
+            negation_simple?(code)
+        end
+
+        def negation_simple?(code)
+          return false unless code.start_with?('!') && code.length > 1
+
+          rest = code[1..]
+          simple_expression?(rest) || (rest.start_with?('(') && rest.end_with?(')'))
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Kapusta
           if pattern.is_a?(Sym)
             return ['nil', env] if pattern.name == '_'
 
-            ruby_name = define_local(env, pattern.name)
+            ruby_name = define_local(env, pattern)
             ["#{ruby_name} = #{value_code}", env]
           else
             bindings_var = temp('bindings')
@@ -61,7 +61,7 @@ module Kapusta
             elsif or_pattern?(pattern)
               emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
             elsif where_pattern?(pattern)
-              raise Error, '`where` is only valid as a case/match clause head'
+              emit_error!('`where` is only valid as a case/match clause head')
             else
               emit_sequence_match_pattern(pattern.items, env, mode:, allow_pins:, state:)
             end
@@ -70,7 +70,7 @@ module Kapusta
           when Symbol, String, Numeric, true, false
             "[:lit, #{pattern.inspect}]"
           else
-            raise Error, "bad pattern: #{pattern.inspect}"
+            emit_error!("bad pattern: #{pattern.inspect}")
           end
         end
 
@@ -88,10 +88,11 @@ module Kapusta
         end
 
         def emit_named_match_pattern(name, env, mode:, state:, allow_nil:, prefer_pin:)
+          binding = prefer_pin && mode == :match ? env.lookup_if_defined(name) : nil
           if state[:bound_names].key?(name)
             "[:ref, #{name.inspect}]"
-          elsif prefer_pin && mode == :match && env.defined?(name)
-            "[:pin, #{binding_value_code(env.lookup(name))}]"
+          elsif binding
+            "[:pin, #{binding_value_code(binding)}]"
           else
             state[:bound_names][name] = true
             state[:binding_names] << name
@@ -115,13 +116,15 @@ module Kapusta
         end
 
         def emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
-          raise Error, 'pin patterns are only supported inside `case` guards' unless allow_pins && mode == :case
+          emit_error!('pin patterns are only supported inside `case` guards') unless allow_pins && mode == :case
 
           name_sym = pattern.items[1]
-          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)
+          emit_error!("bad pin pattern: #{pattern.inspect}") unless name_sym.is_a?(Sym)
 
-          "[:pin, #{binding_value_code(env.lookup(name_sym.name))}]"
+          binding = env.lookup_if_defined(name_sym.name)
+          emit_error!("cannot pin undefined name: #{name_sym.name}") unless binding
+
+          "[:pin, #{binding_value_code(binding)}]"
         end
 
         def emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
@@ -136,7 +139,7 @@ module Kapusta
             compiled = emit_match_pattern(subpattern, env, mode:, allow_pins:, state: alt_state)
             alt_names = alt_state[:binding_names][initial_names..]
             canonical_names ||= alt_names
-            raise Error, 'all `or` patterns must bind the same names' if canonical_names.sort != alt_names.sort
+            emit_error!('all `or` patterns must bind the same names') if canonical_names.sort != alt_names.sort
 
             compiled
           end
@@ -174,7 +177,7 @@ module Kapusta
           when Symbol, String, Numeric, true, false
             "[:lit, #{pattern.inspect}]"
           else
-            raise Error, "bad pattern: #{pattern.inspect}"
+            emit_error!("bad pattern: #{pattern.inspect}")
           end
         end
 

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

@@ -6,6 +6,10 @@ module Kapusta
       module Support
         private
 
+        def emit_error!(message)
+          raise Error, "#{@path}: #{message}"
+        end
+
         def emit_forms_with_headers(forms, env, current_scope, result: true)
           i = 0
           codes = []
@@ -191,7 +195,7 @@ module Kapusta
 
         def local_name(source_name, env, shadow:)
           base = sanitize_local(source_name)
-          base = "user_#{base}" if reserved_generated_name?(base)
+          base = "user_#{base}" if !generated_symbol?(source_name) && reserved_generated_name?(base)
           return base unless ruby_name_defined?(env, base, shadow:)
 
           index = 2
@@ -211,6 +215,10 @@ module Kapusta
           name.start_with?('kap_', '__kap_')
         end
 
+        def generated_symbol?(source_name)
+          source_name.is_a?(GeneratedSym)
+        end
+
         def runtime_helper(name)
           helper = name.to_sym
           @runtime_helpers << helper unless @runtime_helpers.include?(helper)
@@ -255,24 +263,18 @@ module Kapusta
 
         def emit_counted_loop(ruby_name:, start_code:, finish_code:, step_code:,
                               until_form:, loop_env:, current_scope:, body_code:)
-          finish_var = temp('finish')
-          step_var = temp('step')
-          cmp_var = temp('cmp')
           until_code = until_form ? "break if #{emit_expr(until_form, loop_env, current_scope)}" : nil
-          body = [until_code, body_code, "#{ruby_name} += #{step_var}"].compact.reject(&:empty?).join("\n")
+          body = [until_code, body_code].compact.reject(&:empty?).join("\n")
+          step_part = step_code == '1' ? '' : ", #{step_code}"
           [
-            "#{ruby_name} = #{start_code}",
-            "#{finish_var} = #{finish_code}",
-            "#{step_var} = #{step_code}",
-            "#{cmp_var} = #{step_var} >= 0 ? :<= : :>=",
-            "while #{ruby_name}.public_send(#{cmp_var}, #{finish_var})",
+            "#{parenthesize(start_code)}.step(#{finish_code}#{step_part}) do |#{ruby_name}|",
             indent(body),
             'end'
           ].join("\n")
         end
 
         def sanitize_local(name)
-          base = Kapusta.kebab_to_snake(name)
+          base = Kapusta.kebab_to_snake(name.respond_to?(:name) ? name.name : name)
           base = base.gsub('?', '_q').gsub('!', '_bang')
           base = base.gsub(/[^a-zA-Z0-9_]/, '_')
           if base.empty? || base.match?(/\A\d/) || base.match?(/\A[A-Z]/) || self.class::RUBY_KEYWORDS.include?(base)

data/lib/kapusta/compiler/emitter.rb

@@ -34,11 +34,7 @@ module Kapusta
         env = Env.new
         body = emit_forms_with_headers(forms, env, :toplevel)
         helpers = Runtime.helper_source(@runtime_helpers)
-        [
-          '# frozen_string_literal: true',
-          helpers,
-          body
-        ].reject(&:empty?).join("\n\n") << "\n"
+        [helpers, body].reject(&:empty?).join("\n\n") << "\n"
       end
     end
   end

data/lib/kapusta/compiler/normalizer.rb

@@ -38,11 +38,11 @@ module Kapusta
         when 'when'
           cond = items[1]
           body = wrap_do(items[2..])
-          List.new([Sym.new('if'), cond, body, nil])
+          List.new([Sym.new('if'), cond, body])
         when 'unless'
           cond = items[1]
           body = wrap_do(items[2..])
-          List.new([Sym.new('if'), cond, nil, body])
+          List.new([Sym.new('if'), List.new([Sym.new('not'), cond]), body])
         when 'tset'
           List.new([Sym.new('set'), List.new([Sym.new('.'), items[1], items[2]]), items[3]])
         when 'pcall'
@@ -85,29 +85,48 @@ module Kapusta
         short = %w[-?> -?>>].include?(kind)
         position = %w[-> -?>].include?(kind) ? :first : :last
 
+        return thread_short(forms, position) if short
+
         forms[1..].reduce(value) do |memo, form|
-          threaded =
-            if form.is_a?(List)
-              if position == :first
-                List.new([form.items[0], memo, *form.items[1..]])
-              else
-                List.new([*form.items, memo])
-              end
-            else
-              List.new([form, memo])
-            end
-
-          if short
-            List.new([Sym.new('if'), List.new([Sym.new('='), memo, nil]), nil, threaded])
+          thread_step(memo, form, position)
+        end
+      end
+
+      def thread_short(forms, position)
+        forms[1..].reduce(forms.first) do |memo, form|
+          temp = thread_temp
+          List.new([
+                     Sym.new('let'),
+                     Vec.new([temp, memo]),
+                     List.new([
+                                Sym.new('if'),
+                                List.new([Sym.new('='), temp, nil]),
+                                nil,
+                                thread_step(temp, form, position)
+                              ])
+                   ])
+        end
+      end
+
+      def thread_step(memo, form, position)
+        if form.is_a?(List)
+          if position == :first
+            List.new([form.items[0], memo, *form.items[1..]])
           else
-            threaded
+            List.new([*form.items, memo])
           end
+        else
+          List.new([form, memo])
         end
       end
 
+      def thread_temp
+        gensym('kap_thread')
+      end
+
       def doto(forms)
         value = forms.first
-        temp = Sym.new('__doto__')
+        temp = gensym('kap_doto')
         body = forms[1..].map do |form|
           if form.is_a?(List)
             List.new([form.items[0], temp, *form.items[1..]])
@@ -117,6 +136,11 @@ module Kapusta
         end
         List.new([Sym.new('let'), Vec.new([temp, value]), *body, temp])
       end
+
+      def gensym(prefix)
+        @gensym_index = (@gensym_index || 0) + 1
+        GeneratedSym.new("#{prefix}_#{@gensym_index}", @gensym_index)
+      end
     end
   end
 end

data/lib/kapusta/compiler/runtime.rb

@@ -4,106 +4,11 @@ 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],
-        set_method_path: %i[kebab_to_snake],
-        get_ivar: %i[kebab_to_snake],
-        set_ivar: %i[kebab_to_snake],
-        get_cvar: %i[current_class_scope kebab_to_snake],
-        set_cvar: %i[current_class_scope kebab_to_snake],
-        get_gvar: %i[kebab_to_snake],
-        set_gvar: %i[kebab_to_snake],
         destructure: %i[destructure_into],
         match_pattern: %i[match_pattern_into]
       }.freeze
 
       HELPER_SOURCES = {
-        kebab_to_snake: <<~RUBY.chomp,
-          def kap_kebab_to_snake(name)
-            name.tr('-', '_')
-          end
-        RUBY
-        call: <<~'RUBY'.chomp,
-          def kap_call(callee, positional, kwargs = nil, block = nil)
-            raise "not callable: #{callee.inspect}" unless callee.respond_to?(:call)
-
-            if block
-              kwargs ? callee.call(*positional, **kwargs, &block) : callee.call(*positional, &block)
-            else
-              kwargs ? callee.call(*positional, **kwargs) : callee.call(*positional)
-            end
-          end
-        RUBY
-        send_call: <<~RUBY.chomp,
-          def kap_send_call(receiver, method_name, positional, kwargs = nil, block = nil)
-            if block
-              if kwargs
-                receiver.public_send(method_name, *positional, **kwargs, &block)
-              else
-                receiver.public_send(method_name, *positional, &block)
-              end
-            elsif kwargs
-              receiver.public_send(method_name, *positional, **kwargs)
-            else
-              receiver.public_send(method_name, *positional)
-            end
-          end
-        RUBY
-        invoke_self: <<~RUBY.chomp,
-          def kap_invoke_self(receiver, method_name, positional, kwargs = nil, block = nil)
-            if block
-              if kwargs
-                receiver.send(method_name, *positional, **kwargs, &block)
-              else
-                receiver.send(method_name, *positional, &block)
-              end
-            else
-              kwargs ? receiver.send(method_name, *positional, **kwargs) : receiver.send(method_name, *positional)
-            end
-          end
-        RUBY
-        stringify: <<~RUBY.chomp,
-          def kap_stringify(value)
-            case value
-            when nil then 'nil'
-            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"))
-            nil
-          end
-        RUBY
-        concat: <<~RUBY.chomp,
-          def kap_concat(values)
-            values.map { |value| kap_stringify(value) }.join
-          end
-        RUBY
-        get_path: <<~RUBY.chomp,
-          def kap_get_path(obj, keys)
-            keys.reduce(obj) { |acc, key| acc[key] }
-          end
-        RUBY
         qget_path: <<~RUBY.chomp,
           def kap_qget_path(obj, keys)
             keys.each do |key|
@@ -114,63 +19,6 @@ module Kapusta
             obj
           end
         RUBY
-        set_path: <<~RUBY.chomp,
-          def kap_set_path(obj, keys, value)
-            target = obj
-            keys[0...-1].each { |key| target = target[key] }
-            target[keys.last] = value
-          end
-        RUBY
-        method_path_value: <<~RUBY.chomp,
-          def kap_method_path_value(base, segments)
-            segments.reduce(base) { |obj, segment| obj.public_send(kap_kebab_to_snake(segment).to_sym) }
-          end
-        RUBY
-        set_method_path: <<~'RUBY'.chomp,
-          def kap_set_method_path(base, segments, value)
-            target = base
-            segments[0...-1].each do |segment|
-              target = target.public_send(kap_kebab_to_snake(segment).to_sym)
-            end
-            setter = "#{kap_kebab_to_snake(segments.last)}="
-            target.public_send(setter.to_sym, value)
-          end
-        RUBY
-        current_class_scope: <<~RUBY.chomp,
-          def kap_current_class_scope(receiver)
-            receiver.is_a?(Module) ? receiver : receiver.class
-          end
-        RUBY
-        get_ivar: <<~'RUBY'.chomp,
-          def kap_get_ivar(receiver, name)
-            receiver.instance_variable_get("@#{kap_kebab_to_snake(name)}")
-          end
-        RUBY
-        set_ivar: <<~'RUBY'.chomp,
-          def kap_set_ivar(receiver, name, value)
-            receiver.instance_variable_set("@#{kap_kebab_to_snake(name)}", value)
-          end
-        RUBY
-        get_cvar: <<~'RUBY'.chomp,
-          def kap_get_cvar(receiver, name)
-            kap_current_class_scope(receiver).class_variable_get("@@#{kap_kebab_to_snake(name)}")
-          end
-        RUBY
-        set_cvar: <<~'RUBY'.chomp,
-          def kap_set_cvar(receiver, name, value)
-            kap_current_class_scope(receiver).class_variable_set("@@#{kap_kebab_to_snake(name)}", value)
-          end
-        RUBY
-        get_gvar: <<~'RUBY'.chomp,
-          def kap_get_gvar(name)
-            Kernel.eval("$#{kap_kebab_to_snake(name)}", binding, __FILE__, __LINE__)
-          end
-        RUBY
-        set_gvar: <<~'RUBY'.chomp,
-          def kap_set_gvar(name, value)
-            Kernel.eval("$#{kap_kebab_to_snake(name)} = value", binding, __FILE__, __LINE__)
-          end
-        RUBY
         ensure_module: <<~RUBY.chomp,
           def kap_ensure_module(holder, path)
             segments = path.split('.')