kapusta 0.1.2 → 0.1.4

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

@@ -6,7 +6,7 @@ module Kapusta
       module Support
         private
 
-        def emit_forms_with_headers(forms, env, current_scope)
+        def emit_forms_with_headers(forms, env, current_scope, result: true)
           i = 0
           codes = []
           while i < forms.length
@@ -15,7 +15,9 @@ module Kapusta
               codes << emit_bodyless_header(form, forms[(i + 1)..], env, current_scope)
               break
             else
-              code, env = emit_form_in_sequence(form, env, current_scope, allow_method_definitions: true)
+              code, env = emit_form_in_sequence(form, env, current_scope,
+                                                allow_method_definitions: true,
+                                                result_needed: result && i == forms.length - 1)
               codes << code
               i += 1
             end
@@ -50,25 +52,29 @@ module Kapusta
               if inner.length == 1 && bodyless_header?(inner[0])
                 emit_bodyless_header(inner[0], remaining_forms, env, :module)
               else
-                emit_forms_with_headers(remaining_forms, env, :module)
+                emit_forms_with_headers(remaining_forms, env, :module, result: false)
               end
-            emit_module_wrapper(name_sym, body)
+            emit_direct_module_header(name_sym, body) || emit_module_wrapper(name_sym, body)
           else
             name_sym, supers, = split_class_args(form.items[1..])
-            body = emit_forms_with_headers(remaining_forms, env, :class)
-            emit_class_wrapper(name_sym, supers, env, body)
+            body = emit_forms_with_headers(remaining_forms, env, :class, result: false)
+            emit_direct_class_header(name_sym, supers, body) || emit_class_wrapper(name_sym, supers, env, body)
           end
         end
 
-        def emit_form_in_sequence(form, env, current_scope, allow_method_definitions:)
+        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)
             emit_named_fn_assignment(form, env, current_scope)
           elsif local_form?(form)
-            emit_local_form(form, env, current_scope)
+            code, env = emit_local_form(form, env, current_scope)
+            code = code.delete_suffix("\nnil") unless result_needed
+            [code, env]
           elsif do_form?(form)
-            emit_do_form(form.rest, env, current_scope)
+            emit_do_form(form.rest, env, current_scope, result_needed:)
+          elsif sequence_statement_form?(form)
+            emit_sequence_statement_form(form, env, current_scope, result_needed:)
           elsif set_new_local_form?(form, env)
             emit_set_form(form, env, current_scope)
           else
@@ -76,22 +82,51 @@ module Kapusta
           end
         end
 
-        def emit_do_form(forms, env, current_scope)
-          body, new_env = emit_sequence(forms, env, current_scope, allow_method_definitions: false)
+        def emit_do_form(forms, env, current_scope, result_needed: true)
+          body, new_env = emit_sequence(forms, env, current_scope,
+                                        allow_method_definitions: false,
+                                        result: result_needed)
+          return [body, new_env] unless result_needed
+
           ["begin\n#{indent(body)}\nend", new_env]
         end
 
-        def emit_sequence(forms, env, current_scope, allow_method_definitions:)
+        def emit_sequence(forms, env, current_scope, allow_method_definitions:, result: true)
           current_env = env
           codes = []
-          forms.each do |form|
+          forms.each_with_index do |form, index|
             code, current_env = emit_form_in_sequence(form, current_env, current_scope,
-                                                      allow_method_definitions:)
+                                                      allow_method_definitions:,
+                                                      result_needed: result && index == forms.length - 1)
             codes << code
           end
           [codes.join("\n"), current_env]
         end
 
+        def sequence_statement_form?(form)
+          return false unless form.is_a?(List) && form.head.is_a?(Sym)
+
+          %w[let while for each].include?(form.head.name)
+        end
+
+        def emit_sequence_statement_form(form, env, current_scope, result_needed:)
+          case form.head.name
+          when 'let'
+            return [emit_let_statement(form.rest, env, current_scope), env] unless result_needed
+          when 'while'
+            return [emit_while_statement(form.rest, env, current_scope), env]
+          when 'for'
+            return [emit_for_statement(form.rest, env, current_scope), env]
+          when 'each'
+            code = emit_each_statement(form.rest, env, current_scope)
+            return ["#{code}\nnil", env] if result_needed
+
+            return [code, env]
+          end
+
+          [emit_expr(form, env, current_scope), env]
+        end
+
         def special_form?(name)
           Compiler::SPECIAL_FORMS.include?(name)
         end
@@ -140,7 +175,35 @@ module Kapusta
 
         def temp(prefix)
           @temp_index += 1
-          "__kap_#{prefix}_#{@temp_index}"
+          "kap_#{prefix}_#{@temp_index}"
+        end
+
+        def define_local(env, source_name, shadow: false)
+          ruby_name = local_name(source_name, env, shadow:)
+          env.define(source_name, ruby_name)
+          ruby_name
+        end
+
+        def local_name(source_name, env, shadow:)
+          base = sanitize_local(source_name)
+          base = "user_#{base}" if reserved_generated_name?(base)
+          return base unless ruby_name_defined?(env, base, shadow:)
+
+          index = 2
+          loop do
+            candidate = "#{base}_#{index}"
+            return candidate unless ruby_name_defined?(env, candidate, shadow:)
+
+            index += 1
+          end
+        end
+
+        def ruby_name_defined?(env, name, shadow:)
+          shadow ? env.local_ruby_name_defined?(name) : env.ruby_name_defined?(name)
+        end
+
+        def reserved_generated_name?(name)
+          name.start_with?('kap_', '__kap_')
         end
 
         def runtime_helper(name)
@@ -156,11 +219,52 @@ module Kapusta
           "#{runtime_helper(name)}(#{rendered_args.join(', ')})"
         end
 
+        def parse_counted_for_bindings(bindings, env, current_scope)
+          name_sym = bindings[0]
+          loop_env = env.child
+          ruby_name = define_local(loop_env, name_sym.name)
+          start_code = emit_expr(bindings[1], env, current_scope)
+          finish_code = emit_expr(bindings[2], env, current_scope)
+          step_code = '1'
+          until_form = nil
+          i = 3
+          while i < bindings.length
+            if bindings[i].is_a?(Sym) && bindings[i].name == '&until'
+              until_form = bindings[i + 1]
+              i += 2
+            else
+              step_code = emit_expr(bindings[i], env, current_scope)
+              i += 1
+            end
+          end
+          { ruby_name:, loop_env:, start_code:, finish_code:, step_code:, until_form: }
+        end
+
+        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")
+          [
+            "#{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})",
+            indent(body),
+            'end'
+          ].join("\n")
+        end
+
         def sanitize_local(name)
           base = Kapusta.kebab_to_snake(name)
           base = base.gsub('?', '_q').gsub('!', '_bang')
           base = base.gsub(/[^a-zA-Z0-9_]/, '_')
-          base = "_#{base}" if base.empty? || base.match?(/\A\d/) || self.class::RUBY_KEYWORDS.include?(base)
+          if base.empty? || base.match?(/\A\d/) || base.match?(/\A[A-Z]/) || self.class::RUBY_KEYWORDS.include?(base)
+            base = "_#{base}"
+          end
           base
         end
       end

data/lib/kapusta/compiler/runtime.rb

@@ -20,12 +20,12 @@ module Kapusta
 
       HELPER_SOURCES = {
         kebab_to_snake: <<~RUBY.chomp,
-          def __kap_kebab_to_snake(name)
+          def kap_kebab_to_snake(name)
             name.tr('-', '_')
           end
         RUBY
         call: <<~'RUBY'.chomp,
-          def __kap_call(callee, positional, kwargs = nil, block = nil)
+          def kap_call(callee, positional, kwargs = nil, block = nil)
             raise "not callable: #{callee.inspect}" unless callee.respond_to?(:call)
 
             if block
@@ -36,7 +36,7 @@ module Kapusta
           end
         RUBY
         send_call: <<~RUBY.chomp,
-          def __kap_send_call(receiver, method_name, positional, kwargs = nil, block = nil)
+          def kap_send_call(receiver, method_name, positional, kwargs = nil, block = nil)
             if block
               if kwargs
                 receiver.public_send(method_name, *positional, **kwargs, &block)
@@ -51,7 +51,7 @@ module Kapusta
           end
         RUBY
         invoke_self: <<~RUBY.chomp,
-          def __kap_invoke_self(receiver, method_name, positional, kwargs = nil, block = nil)
+          def kap_invoke_self(receiver, method_name, positional, kwargs = nil, block = nil)
             if block
               if kwargs
                 receiver.send(method_name, *positional, **kwargs, &block)
@@ -64,7 +64,7 @@ module Kapusta
           end
         RUBY
         stringify: <<~'RUBY'.chomp,
-          def __kap_stringify(value)
+          def kap_stringify(value)
             render = nil
             render = lambda do |item|
               case item
@@ -91,23 +91,23 @@ module Kapusta
           end
         RUBY
         print_values: <<~'RUBY'.chomp,
-          def __kap_print_values(*values)
-            $stdout.puts(values.map { |value| __kap_stringify(value) }.join("\t"))
+          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
+          def kap_concat(values)
+            values.map { |value| kap_stringify(value) }.join
           end
         RUBY
         get_path: <<~RUBY.chomp,
-          def __kap_get_path(obj, keys)
+          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)
+          def kap_qget_path(obj, keys)
             keys.each do |key|
               return nil if obj.nil?
 
@@ -117,64 +117,64 @@ module Kapusta
           end
         RUBY
         set_path: <<~RUBY.chomp,
-          def __kap_set_path(obj, keys, value)
+          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) }
+          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)
+          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)
+              target = target.public_send(kap_kebab_to_snake(segment).to_sym)
             end
-            setter = "#{__kap_kebab_to_snake(segments.last)}="
+            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)
+          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)}")
+          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)
+          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)}")
+          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)
+          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__)
+          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__)
+          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)
+          def kap_ensure_module(holder, path)
             segments = path.split('.')
             last = segments.pop
             scope = holder.is_a?(Module) ? holder : Object
@@ -198,7 +198,7 @@ module Kapusta
           end
         RUBY
         ensure_class: <<~RUBY.chomp,
-          def __kap_ensure_class(holder, path, super_class)
+          def kap_ensure_class(holder, path, super_class)
             segments = path.split('.')
             last = segments.pop
             scope = holder.is_a?(Module) ? holder : Object
@@ -222,14 +222,14 @@ module Kapusta
           end
         RUBY
         destructure: <<~RUBY.chomp,
-          def __kap_destructure(pattern, value)
+          def kap_destructure(pattern, value)
             bindings = {}
-            __kap_destructure_into(pattern, value, bindings)
+            kap_destructure_into(pattern, value, bindings)
             bindings
           end
         RUBY
         destructure_into: <<~'RUBY'.chomp,
-          def __kap_destructure_into(pattern, value, bindings)
+          def kap_destructure_into(pattern, value, bindings)
             case pattern[0]
             when :sym
               name = pattern[1]
@@ -241,18 +241,18 @@ module Kapusta
                 before = items[0...rest_idx]
                 rest_pattern = items[rest_idx][1]
                 before.each_with_index do |item, i|
-                  __kap_destructure_into(item, value ? value[i] : nil, bindings)
+                  kap_destructure_into(item, value ? value[i] : nil, bindings)
                 end
                 rest_value = value ? (value[rest_idx..] || []) : []
-                __kap_destructure_into(rest_pattern, rest_value, bindings)
+                kap_destructure_into(rest_pattern, rest_value, bindings)
               else
                 items.each_with_index do |item, i|
-                  __kap_destructure_into(item, value ? value[i] : nil, bindings)
+                  kap_destructure_into(item, value ? value[i] : nil, bindings)
                 end
               end
             when :hash
               pattern[1].each do |key, subpattern|
-                __kap_destructure_into(subpattern, value ? value[key] : nil, bindings)
+                kap_destructure_into(subpattern, value ? value[key] : nil, bindings)
               end
             when :ignore
               nil
@@ -262,17 +262,24 @@ module Kapusta
           end
         RUBY
         match_pattern: <<~RUBY.chomp,
-          def __kap_match_pattern(pattern, value)
+          def kap_match_pattern(pattern, value)
             bindings = {}
-            [__kap_match_pattern_into(pattern, value, bindings), bindings]
+            [kap_match_pattern_into(pattern, value, bindings), bindings]
           end
         RUBY
         match_pattern_into: <<~'RUBY'.chomp
-          def __kap_match_pattern_into(pattern, value, bindings)
+          def kap_match_pattern_into(pattern, value, bindings)
             case pattern[0]
-            when :sym
+            when :bind
               name = pattern[1]
-              bindings[name] = value unless name == '_'
+              allow_nil = pattern[2]
+              return false if value.nil? && !allow_nil
+
+              bindings[name] = value
+              true
+            when :ref
+              bindings.key?(pattern[1]) && bindings[pattern[1]] == value
+            when :wild
               true
             when :vec
               return false unless value.is_a?(Array) || value.respond_to?(:to_ary)
@@ -286,14 +293,14 @@ module Kapusta
                 return false if array.length < before.length
 
                 before.each_with_index do |item, i|
-                  return false unless __kap_match_pattern_into(item, array[i], bindings)
+                  return false unless kap_match_pattern_into(item, array[i], bindings)
                 end
-                __kap_match_pattern_into(rest_pattern, array[rest_idx..], bindings)
+                kap_match_pattern_into(rest_pattern, array[rest_idx..], bindings)
               else
-                return false unless array.length == items.length
+                return false unless array.length >= items.length
 
                 items.each_with_index do |item, i|
-                  return false unless __kap_match_pattern_into(item, array[i], bindings)
+                  return false unless kap_match_pattern_into(item, array[i], bindings)
                 end
                 true
               end
@@ -302,13 +309,21 @@ module Kapusta
 
               pattern[1].each do |key, subpattern|
                 return false unless value.key?(key)
-                return false unless __kap_match_pattern_into(subpattern, value[key], bindings)
+                return false unless kap_match_pattern_into(subpattern, value[key], bindings)
               end
               true
             when :lit
               value == pattern[1]
-            when :nil
-              value.nil?
+            when :pin
+              value == pattern[1]
+            when :or
+              pattern[1].any? do |option|
+                option_bindings = bindings.dup
+                next false unless kap_match_pattern_into(option, value, option_bindings)
+
+                bindings.replace(option_bindings)
+                true
+              end
             else
               raise "bad pattern: #{pattern.inspect}"
             end
@@ -319,7 +334,7 @@ module Kapusta
       module_function
 
       def helper_name(name)
-        "__kap_#{name}"
+        "kap_#{name}"
       end
 
       def helper_source(helpers)
@@ -351,7 +366,7 @@ module Kapusta
       helper_methods = []
 
       HELPER_SOURCES.each_key do |name|
-        helper_method = :"__kap_#{name}"
+        helper_method = :"kap_#{name}"
         define_singleton_method(name, instance_method(helper_method))
         helper_methods << helper_method
       end

data/lib/kapusta/compiler.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require_relative 'error'
 require_relative 'compiler/runtime'
 require_relative 'compiler/normalizer'
 require_relative 'compiler/emitter'
 
 module Kapusta
   module Compiler
-    class Error < StandardError; end
+    class Error < Kapusta::Error; end
     SPECIAL_FORMS = %w[
       fn lambda λ let local var set if when unless case match
       while for each do values

data/lib/kapusta/env.rb

@@ -25,6 +25,14 @@ module Kapusta
       @vars.key?(name) || @parent&.defined?(name)
     end
 
+    def ruby_name_defined?(name)
+      @vars.value?(name) || @parent&.ruby_name_defined?(name)
+    end
+
+    def local_ruby_name_defined?(name)
+      @vars.value?(name)
+    end
+
     def set_existing!(name, value)
       if @vars.key?(name)
         @vars[name] = value

data/lib/kapusta/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kapusta
+  class Error < StandardError; end
+end

data/lib/kapusta/formatter.rb

@@ -519,11 +519,12 @@ module Kapusta
     def render_pairwise_vec(vec, indent)
       lines = ['[']
 
-      vec.items.each_slice(2) do |left, right|
-        if right
-          pair = render_pair(left, right, indent + INDENT)
-          if pair
-            lines << indent_block(pair, INDENT)
+      vec.items.each_slice(2) do |pair|
+        left, right = pair
+        if pair.length == 2
+          rendered_pair = render_pair(left, right, indent + INDENT)
+          if rendered_pair
+            lines << indent_block(rendered_pair, INDENT)
           else
             lines << indent_block(render(left, indent + INDENT), INDENT)
             lines << indent_block(render(right, indent + INDENT), INDENT)
@@ -547,8 +548,9 @@ module Kapusta
 
     def render_hanging_pairwise_vec(vec)
       pairs = vec.items.each_slice(2).to_a
-      rendered_pairs = pairs.map do |left, right|
-        return nil unless right
+      rendered_pairs = pairs.map do |pair|
+        left, right = pair
+        return nil unless pair.length == 2
 
         render_binding_pair(left, right)
       end
@@ -673,15 +675,6 @@ module Kapusta
       end
     end
 
-    def fn_body(form)
-      args = list_rest(form)
-      if args[0].is_a?(Sym) && args[1].is_a?(Vec)
-        args.drop(2)
-      else
-        args.drop(1)
-      end
-    end
-
     def consecutive_requires?(previous, current)
       require_form?(previous) && require_form?(current)
     end
@@ -832,6 +825,6 @@ module Kapusta
       puts 'Formats Kapusta source using the built-in Kapusta reader and pretty-printer.'
     end
 
-    class Error < StandardError; end
+    class Error < Kapusta::Error; end
   end
 end

data/lib/kapusta/reader.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'error'
+
 module Kapusta
   class Reader
+    class Error < Kapusta::Error; end
+
     WHITESPACE = [' ', "\t", "\n", "\r", "\f", "\v", ','].freeze
     DELIMS = ['(', ')', '[', ']', '{', '}', '"', ';'].freeze
 
@@ -61,7 +65,7 @@ module Kapusta
 
     def read_next_item
       skip_ws
-      raise 'unexpected eof' if eof?
+      raise Error, 'unexpected eof' if eof?
 
       return read_comment if @preserve_comments && peek == ';'
 
@@ -70,7 +74,7 @@ module Kapusta
 
     def read_form
       skip_ws
-      raise 'unexpected eof' if eof?
+      raise Error, 'unexpected eof' if eof?
 
       return read_comment if @preserve_comments && peek == ';'
 
@@ -93,7 +97,7 @@ module Kapusta
       items = []
       loop do
         skip_ws
-        raise 'unclosed (' if eof?
+        raise Error, 'unclosed (' if eof?
         break if peek == ')'
 
         items << read_next_item
@@ -107,7 +111,7 @@ module Kapusta
       items = []
       loop do
         skip_ws
-        raise 'unclosed [' if eof?
+        raise Error, 'unclosed [' if eof?
         break if peek == ']'
 
         items << read_next_item
@@ -122,7 +126,7 @@ module Kapusta
       pending = []
       loop do
         skip_ws
-        raise 'unclosed {' if eof?
+        raise Error, 'unclosed {' if eof?
         break if peek == '}'
 
         item = read_next_item
@@ -139,7 +143,7 @@ module Kapusta
       end
       advance
 
-      raise 'odd number of forms in hash' unless pending.empty?
+      raise Error, 'odd number of forms in hash' unless pending.empty?
 
       HashLit.new(entries)
     end
@@ -168,7 +172,7 @@ module Kapusta
           buffer << advance
         end
       end
-      raise 'unterminated string' if eof?
+      raise Error, 'unterminated string' if eof?
 
       advance
       buffer
@@ -209,7 +213,7 @@ module Kapusta
       start = @pos
       advance until delim?(peek)
       token = @src[start...@pos]
-      raise 'empty token' if token.empty?
+      raise Error, 'empty token' if token.empty?
 
       parse_atom(token)
     end
@@ -230,7 +234,7 @@ module Kapusta
 
     def normalize_hash_pair(item, value)
       if item.is_a?(Sym) && item.name == ':'
-        raise 'bad shorthand' unless value.is_a?(Sym)
+        raise Error, 'bad shorthand' unless value.is_a?(Sym)
 
         key = Kapusta.kebab_to_snake(value.name).to_sym
         [key, value]