low_type 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a175f78281d51fe16720ca8231b1790506d2eea0d96660c52ff78f1717689836
-  data.tar.gz: f8615b0754c2a5e30e99e37922311d7d9436a37025f3a1a76334d4b14da21e7d
+  metadata.gz: f2ff86050dbdbbaf494210b5ccb0ca36735305cae2a90701d406ee41830eb8b1
+  data.tar.gz: 5345157740d454fa13dbf8d78c37e989b1e1a5a7e0e76cf914b5d9b8da324c58
 SHA512:
-  metadata.gz: 04d69b82160152e0c04cc114e196c68fc5122dc79fa3b622ebafa21106a01ab8d44d7a483df497f2cc51c8280c2038bbf114b680505a2c9e35b73b9cbef2cd04
-  data.tar.gz: f2baaeeeaaec312a7306c12094e3b4cd661a935e3b6072b8824df5451fbd88538ffcacc48ba6beedc06e75ec2d685f015227289c529f051cadd246de127aa033
+  metadata.gz: 75b594af3ac1947a5adda7a9b56d1e31a2fecb95098f48be0b0af54f16364d3c43cad27412e19f3f525f06864a9c5e7b74f45f6f41734641287bb76160e4c17d
+  data.tar.gz: 423c63f4242bb7c4bf3fdbea6786eba6fc8408fd1c16ba26cd2400e6963e86e2f5ba38882bbe1cba167e42a334bf8fd85a5b320b7d5a1975b0c8a756886643f8

data/lib/adapters/sinatra_adapter.rb

@@ -2,8 +2,8 @@
 
 require 'prism'
 
+require_relative '../factories/proxy_factory'
 require_relative '../interfaces/adapter_interface'
-require_relative '../proxies/file_proxy'
 require_relative '../proxies/return_proxy'
 require_relative '../types/error_types'
 
@@ -27,8 +27,7 @@ module LowType
 
           pattern = arguments_node.arguments.first.content
 
-          line = FileParser.line_number(node: method_call)
-          file = FileProxy.new(path: @file_path, line:, scope: "#{@klass}##{method_call.name}")
+          file = ProxyFactory.file_proxy(node: method_call, path: @file_path, scope: "#{@klass}##{method_call.name}")
           next unless (return_proxy = return_proxy(method_node: method_call, pattern:, file:))
 
           route = "#{method_call.name.upcase} #{pattern}"

data/lib/{redefiner.rb → definitions/redefiner.rb}

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'factories/expression_factory'
-require_relative 'factories/proxy_factory'
-require_relative 'proxies/file_proxy'
-require_relative 'proxies/method_proxy'
-require_relative 'proxies/param_proxy'
-require_relative 'queries/type_query'
-require_relative 'syntax/syntax'
-require_relative 'type_expression'
-require_relative 'value_expression'
+require_relative '../expressions/expressions'
+require_relative '../expressions/type_expression'
+require_relative '../expressions/value_expression'
+require_relative '../factories/expression_factory'
+require_relative '../factories/proxy_factory'
+require_relative '../proxies/file_proxy'
+require_relative '../proxies/method_proxy'
+require_relative '../proxies/param_proxy'
+require_relative '../queries/type_query'
+require_relative '../syntax/syntax'
+require_relative 'repository'
 
 module LowType
   # Redefine methods to have their arguments and return values type checked.
@@ -16,44 +18,57 @@ module LowType
     using Syntax
 
     class << self
-      def redefine(method_nodes:, klass:, line_numbers:, file_path:)
-        create_proxies(method_nodes:, klass:, file_path:)
-        define_methods(method_nodes:, line_numbers:)
+      include Expressions
+
+      def redefine(method_nodes:, class_proxy:, file_path:)
+        method_proxies = create_method_proxies(method_nodes:, klass: class_proxy.klass, file_path:)
+        define_methods(method_proxies:, class_proxy:)
+      end
+
+      def redefinable?(method_proxy:, class_proxy:)
+        # Method has no types.
+        if method_proxy.params == [] && method_proxy.return_proxy.nil?
+          LowType::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
+          return false
+        end
+
+        # Method outside class bounds.
+        within_bounds = method_proxy.start_line > class_proxy.start_line && method_proxy.end_line <= class_proxy.end_line
+        if method_proxy.lines? && class_proxy.lines? && !within_bounds
+          LowType::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
+          return false
+        end
+
+        true
       end
 
       private
 
-      def create_proxies(method_nodes:, klass:, file_path:)
-        method_nodes.each do |method_node|
-          name = method_node.name
-          line = FileParser.line_number(node: method_node)
-          file = FileProxy.new(path: file_path, line:, scope: "#{klass}##{name}")
-          params = param_proxies(method_node:, file:)
+      def create_method_proxies(method_nodes:, klass:, file_path:)
+        method_nodes.each do |name, method_node|
+          file = ProxyFactory.file_proxy(path: file_path, node: method_node, scope: "#{klass}##{name}")
+
+          param_proxies = param_proxies(method_node:, file:)
           return_proxy = ProxyFactory.return_proxy(method_node:, file:)
+          method_proxy = MethodProxy.new(name:, params: param_proxies, return_proxy:, file:)
 
-          klass.low_methods[name] = MethodProxy.new(name:, params:, return_proxy:)
+          Repository.save(method: method_proxy, klass:)
         end
-      end
 
-      def define_methods(method_nodes:, line_numbers:) # rubocop:disable Metrics
-        class_start = line_numbers[:class_start]
-        class_end = line_numbers[:class_end]
-        private_start = line_numbers[:private_start]
+        Repository.all(klass:)
+      end
 
+      def define_methods(method_proxies:, class_proxy:) # rubocop:disable Metrics
         Module.new do
-          method_nodes.each do |method_node|
-            method_start = method_node.respond_to?(:start_line) ? method_node.start_line : nil
-            method_end = method_node.respond_to?(:end_line) ? method_node.end_line : nil
-
-            next if method_start && method_end && class_end && !(method_start > class_start && method_end <= class_end)
-
-            name = method_node.name
+          method_proxies.each do |name, method_proxy|
+            next unless LowType::Redefiner.redefinable?(method_proxy:, class_proxy:)
 
+            # NOTE: You are now in the binding of the includer class (`name` is also available here).
             define_method(name) do |*args, **kwargs|
+              # Inlined version of Repository.load() for performance increase.
               method_proxy = instance_of?(Class) ? low_methods[name] : self.class.low_methods[name] || Object.low_methods[name]
 
               method_proxy.params.each do |param_proxy|
-                # Get argument value or default value.
                 value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
                 if value.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
                   value = param_proxy.type_expression.default_value
@@ -73,7 +88,7 @@ module LowType
               super(*args, **kwargs)
             end
 
-            private name if private_start && method_start > private_start
+            private name if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
           end
         end
       end
@@ -137,11 +152,6 @@ module LowType
 
         [required_args, required_kwargs]
       end
-
-      # Value expressions are eval()'d in the context of this module class (the instance doesn't exist yet) so alias API.
-      def value(type)
-        ExpressionFactory.type_expression_with_value(type:)
-      end
     end
   end
 end

data/lib/definitions/repository.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module LowType
+  class Repository
+    class << self
+      def all(klass:)
+        klass.low_methods
+      end
+
+      def save(method:, klass:)
+        klass.low_methods[method.name] = method
+      end
+
+      def delete(name:, klass:)
+        klass.low_methods.delete(name)
+      end
+
+      # Redefiner inlines this method in define_method() for better performance. TODO: Test this assumption.
+      def load(name:, object:)
+        singleton(object:).low_methods[name]
+      end
+
+      # TODO: export() to RBS
+
+      private
+
+      def singleton(object:)
+        object.instance_of?(Class) ? object : object.class || Object
+      end
+    end
+  end
+end

data/lib/{instance_types.rb → definitions/type_accessors.rb}

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'proxies/return_proxy'
-require_relative 'queries/type_query'
-require_relative 'type_expression'
+require_relative '../expressions/type_expression'
+require_relative '../proxies/return_proxy'
+require_relative '../queries/type_query'
 
 module LowType
-  module InstanceTypes
+  module TypeAccessors
     def type_reader(named_expressions)
       named_expressions.each do |name, expression|
         last_caller = caller_locations(1, 1).first
         type_expression = type_expression(expression)
-        file = FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: "#{self}##{name}")
+        file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
 
         @low_methods[name] = MethodProxy.new(name:, return_proxy: ReturnProxy.new(type_expression:, name:, file:))
 
@@ -27,7 +27,7 @@ module LowType
       named_expressions.each do |name, expression|
         last_caller = caller_locations(1, 1).first
         type_expression = type_expression(expression)
-        file = FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: "#{self}##{name}")
+        file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
 
         @low_methods["#{name}="] = MethodProxy.new(name:, params: [ParamProxy.new(type_expression:, name:, type: :hashreq, file:)])
 

data/lib/{local_types.rb → expressions/expressions.rb}

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require_relative 'factories/expression_factory'
-require_relative 'proxies/file_proxy'
-require_relative 'proxies/local_proxy'
-require_relative 'types/error_types'
+require_relative '../factories/expression_factory'
+require_relative '../proxies/file_proxy'
+require_relative '../proxies/local_proxy'
+require_relative '../types/error_types'
 
 module LowType
-  module LocalTypes
+  module Expressions
     def type(type_expression)
       value = type_expression.default_value
 
       last_caller = caller_locations(1, 1).first
-      file = FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: 'local type')
+      file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: 'local type')
       proxy = LocalProxy.new(type_expression:, name: self, file:)
 
       type_expression.validate!(value:, proxy:)

data/lib/{type_expression.rb → expressions/type_expression.rb}

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'proxies/param_proxy'
-require_relative 'queries/type_query'
+require_relative '../proxies/param_proxy'
+require_relative '../queries/type_query'
 
 module LowType
   root_path = File.expand_path(__dir__)
   adapter_paths = Dir.chdir(root_path) { Dir.glob('adapters/*') }.map { |path| File.join(root_path, path) }
-  module_paths = %w[instance_types local_types redefiner].map { |path| File.join(root_path, "#{path}.rb") }
+  module_paths = %w[expressions/expressions instance_types redefiner].map { |path| File.join(root_path, "#{path}.rb") }
 
   HIDDEN_PATHS = [File.expand_path(__FILE__), *adapter_paths, *module_paths].freeze
 
@@ -122,7 +122,7 @@ module LowType
 
     def type_matches_value?(type:, value:, proxy:)
       if type.instance_of?(Class)
-        return type.match?(value:) if LowType::TypeQuery.complex_type?(type:)
+        return type.match?(value:) if LowType::TypeQuery.complex_type?(expression: type)
 
         return type == value.class
       elsif type.instance_of?(::LowType::TypeExpression)

data/lib/factories/expression_factory.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../type_expression'
-require_relative '../value_expression'
+require_relative '../expressions/type_expression'
+require_relative '../expressions/value_expression'
 
 module LowType
   class ExpressionFactory

data/lib/factories/proxy_factory.rb

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
 
+require_relative '../expressions/type_expression'
+require_relative '../proxies/file_proxy'
 require_relative '../proxies/return_proxy'
 require_relative '../queries/file_parser'
-require_relative '../type_expression'
 
 module LowType
   class ProxyFactory
     class << self
+      def file_proxy(node:, path:, scope:)
+        start_line = node.respond_to?(:start_line) ? node.start_line : nil
+        end_line = node.respond_to?(:end_line) ? node.end_line : nil
+
+        FileProxy.new(path:, start_line:, end_line:, scope:)
+      end
+
       def return_proxy(method_node:, file:)
         return_type = FileParser.return_type(method_node:)
         return nil if return_type.nil?

data/lib/interfaces/error_interface.rb

@@ -35,7 +35,7 @@ module LowType
       filtered_backtrace = backtrace.reject { |line| hidden_paths.find { |file_path| line.include?(file_path) } }
 
       # Add the proxied file to the backtrace.
-      proxy_file_backtrace = "#{file.path}:#{file.line}:in '#{file.scope}'"
+      proxy_file_backtrace = "#{file.path}:#{file.start_line}:in '#{file.scope}'"
       from_prefix = filtered_backtrace.first.match(/\s+from /)
       proxy_file_backtrace = "#{from_prefix}#{proxy_file_backtrace}" if from_prefix
 

data/lib/low_type.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require_relative 'adapters/adapter_loader'
-require_relative 'syntax/syntax'
-require_relative 'types/complex_types'
+require_relative 'definitions/redefiner'
+require_relative 'definitions/type_accessors'
+require_relative 'expressions/expressions'
 require_relative 'queries/file_parser'
 require_relative 'queries/file_query'
-require_relative 'instance_types'
-require_relative 'local_types'
-require_relative 'redefiner'
+require_relative 'syntax/syntax'
+require_relative 'types/complex_types'
 
 module LowType
   # We do as much as possible on class load rather than on instantiation to be thread-safe and efficient.
@@ -22,12 +22,11 @@ module LowType
 
     file_path = FileQuery.file_path(klass:)
     parser = FileParser.new(klass:, file_path:)
-    line_numbers = parser.line_numbers
 
-    klass.extend InstanceTypes
-    klass.include LocalTypes
-    klass.prepend Redefiner.redefine(method_nodes: parser.instance_methods, klass:, line_numbers:, file_path:)
-    klass.singleton_class.prepend Redefiner.redefine(method_nodes: parser.class_methods, klass:, line_numbers:, file_path:)
+    klass.extend TypeAccessors
+    klass.include Expressions
+    klass.prepend Redefiner.redefine(method_nodes: parser.instance_methods, class_proxy: parser.class_proxy, file_path:)
+    klass.singleton_class.prepend Redefiner.redefine(method_nodes: parser.class_methods, class_proxy: parser.class_proxy, file_path:)
 
     if (adapter = Adapter::Loader.load(klass:, parser:, file_path:))
       adapter.process

data/lib/proxies/class_proxy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module LowType
+  class ClassProxy
+    extend Forwardable
+
+    attr_reader :name, :klass, :file, :private_start_line
+
+    def_delegators :@file, :start_line, :end_line, :lines?
+
+    def initialize(klass:, file:, private_start_line:)
+      @name = klass.to_s
+      @klass = klass
+      @file = file
+      @private_start_line = private_start_line
+    end
+  end
+end

data/lib/proxies/file_proxy.rb

@@ -2,12 +2,18 @@
 
 module LowType
   class FileProxy
-    attr_reader :path, :line, :scope
+    attr_reader :path, :scope
+    attr_accessor :start_line, :end_line
 
-    def initialize(path:, line:, scope:)
+    def initialize(path:, scope:, start_line:, end_line: nil)
       @path = path
-      @line = line
+      @start_line = start_line
+      @end_line = end_line || start_line
       @scope = scope
     end
+
+    def lines?
+      start_line && end_line
+    end
   end
 end

data/lib/proxies/local_proxy.rb

@@ -20,7 +20,7 @@ module LowType
     end
 
     def error_message(value:)
-      "Invalid variable type #{output(value:)} in '#{@name.class}' on line #{@file.line}. Valid types: '#{@type_expression.valid_types}'"
+      "Invalid variable type #{output(value:)} in '#{name.class}:#{@file.start_line}'. Valid types: '#{type_expression.valid_types}'"
     end
   end
 end

data/lib/proxies/method_proxy.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
 module LowType
   class MethodProxy
-    attr_reader :name, :params, :return_proxy
+    extend Forwardable
+
+    attr_reader :name, :file, :params, :return_proxy
+
+    # File is queried by redefiner but not sinatra adapter nor type accessors.
+    def_delegators :@file, :start_line, :end_line, :lines?
 
-    def initialize(name:, params: [], return_proxy: nil)
+    def initialize(name:, file: nil, params: [], return_proxy: nil)
       @name = name
+      @file = file
       @params = params
       @return_proxy = return_proxy
     end

data/lib/queries/file_parser.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require 'prism'
+require_relative '../proxies/class_proxy'
 
 module LowType
   class FileParser
-    attr_reader :parent_map, :instance_methods, :class_methods, :line_numbers
+    attr_reader :parent_map, :instance_methods, :class_methods, :class_proxy
 
     def initialize(klass:, file_path:)
       @root_node = Prism.parse_file(file_path).value
@@ -13,12 +14,12 @@ module LowType
       parent_mapper.visit(@root_node)
       @parent_map = parent_mapper.parent_map
 
-      method_visitor = MethodDefVisitor.new(root_node: @root_node, parent_map:, klass:)
+      method_visitor = MethodDefVisitor.new(root_node: @root_node, parent_map:, klass:, file_path:)
       @root_node.accept(method_visitor)
 
       @instance_methods = method_visitor.instance_methods
       @class_methods = method_visitor.class_methods
-      @line_numbers = method_visitor.line_numbers
+      @class_proxy = ClassProxy.new(klass:, file: method_visitor.file_proxy, private_start_line: method_visitor.private_start_line)
     end
 
     def method_calls(method_names:)
@@ -46,50 +47,46 @@ module LowType
 
         nil
       end
-
-      def line_number(node:)
-        node.respond_to?(:start_line) ? node.start_line : nil
-      end
     end
   end
 
   class MethodDefVisitor < Prism::Visitor
-    attr_reader :class_methods, :instance_methods, :line_numbers
+    attr_reader :class_methods, :instance_methods, :file_proxy, :private_start_line
 
-    def initialize(root_node:, parent_map:, klass:)
+    def initialize(root_node:, parent_map:, klass:, file_path:)
       @parent_map = parent_map
       @klass = klass
 
-      @instance_methods = []
-      @class_methods = []
-      @line_numbers = { class_start: 0, class_end: root_node.respond_to?(:end_line) ? root_node.end_line : nil }
+      @instance_methods = {}
+      @class_methods = {}
+
+      end_line = root_node.respond_to?(:end_line) ? root_node.end_line : nil
+      @file_proxy = FileProxy.new(path: file_path, start_line: 0, end_line:, scope: klass.to_s)
+      @private_start_line = nil
     end
 
     def visit_def_node(node)
       if class_method?(node)
-        @class_methods << node
+        @class_methods[node.name] = node
       else
-        @instance_methods << node
+        @instance_methods[node.name] = node
       end
 
       super # Continue walking the tree.
     end
 
     def visit_call_node(node)
-      start_line = node.name == :private && node.respond_to?(:start_line) && node.start_line || nil
-      class_start = @line_numbers[:class_start]
-      class_end = @line_numbers[:class_end]
+      return super unless node.name == :private && node.respond_to?(:start_line) && file_proxy.start_line && file_proxy.end_line
 
-      if start_line && class_start && class_end && start_line > class_start && start_line < class_end
-        @line_numbers[:private_start] = node.start_line
-      end
+      @private_start_line = node.start_line if node.start_line > file_proxy.start_line && node.start_line < file_proxy.end_line
 
       super
     end
 
     def visit_class_node(node)
       if node.name == @klass.to_s.to_sym
-        @line_numbers = { class_start: node.class_keyword_loc.start_line, class_end: node.end_keyword_loc.end_line }
+        file_proxy.start_line = node.class_keyword_loc.start_line
+        file_proxy.end_line = node.end_keyword_loc.end_line
       end
 
       super

data/lib/queries/type_query.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
-require_relative '../type_expression'
+require_relative '../expressions/type_expression'
 
 module LowType
   # TODO: Unit test.
   class TypeQuery
     class << self
-      def type?(type)
-        basic_type?(type:) || complex_type?(type:)
+      def type?(expression)
+        basic_type?(expression:) || complex_type?(expression:)
+      end
+
+      def typed_array?(expression:)
+        expression.is_a?(Array) && (basic_type?(expression: expression.first) || expression.first.is_a?(TypeExpression))
       end
 
       def value?(value)
-        !basic_type?(type: value) && !complex_type?(type: value)
+        !basic_type?(expression: value) && !complex_type?(expression: value)
       end
 
-      def complex_type?(type:)
-        LowType::COMPLEX_TYPES.include?(type) || typed_array?(type:) || typed_hash?(type:)
+      def complex_type?(expression:)
+        LowType::COMPLEX_TYPES.include?(expression) || typed_array?(expression:) || typed_hash?(expression:)
       end
 
       private
 
-      def basic_type?(type:)
-        type.instance_of?(Class)
-      end
-
-      def typed_array?(type:)
-        type.is_a?(Array) && (basic_type?(type: type.first) || type.first.is_a?(TypeExpression))
+      def basic_type?(expression:)
+        expression.instance_of?(Class)
       end
 
-      def typed_hash?(type:)
-        type.is_a?(Hash) && basic_type?(type: type.keys.first) && basic_type?(type: type.values.first)
+      def typed_hash?(expression:)
+        expression.is_a?(Hash) && basic_type?(expression: expression.keys.first) && basic_type?(expression: expression.values.first)
       end
     end
   end

data/lib/syntax/syntax.rb

@@ -5,8 +5,8 @@ require_relative '../queries/type_query'
 module LowType
   module Syntax
     refine Array.singleton_class do
-      def [](*types)
-        return TypeExpression.new(type: [*types]) if types.all? { |type| TypeQuery.type?(type) }
+      def [](*expression)
+        return TypeExpression.new(type: [*expression]) if TypeQuery.type?(expression.first) || TypeQuery.typed_array?(expression:)
 
         super
       end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LowType
-  VERSION = '1.1.0'
+  VERSION = '1.1.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.2
 platform: ruby
 authors:
 - maedi
@@ -19,14 +19,19 @@ extra_rdoc_files: []
 files:
 - lib/adapters/adapter_loader.rb
 - lib/adapters/sinatra_adapter.rb
+- lib/definitions/redefiner.rb
+- lib/definitions/repository.rb
+- lib/definitions/type_accessors.rb
+- lib/expressions/expressions.rb
+- lib/expressions/type_expression.rb
+- lib/expressions/value_expression.rb
 - lib/factories/expression_factory.rb
 - lib/factories/proxy_factory.rb
 - lib/factories/type_factory.rb
-- lib/instance_types.rb
 - lib/interfaces/adapter_interface.rb
 - lib/interfaces/error_interface.rb
-- lib/local_types.rb
 - lib/low_type.rb
+- lib/proxies/class_proxy.rb
 - lib/proxies/file_proxy.rb
 - lib/proxies/local_proxy.rb
 - lib/proxies/method_proxy.rb
@@ -35,13 +40,10 @@ files:
 - lib/queries/file_parser.rb
 - lib/queries/file_query.rb
 - lib/queries/type_query.rb
-- lib/redefiner.rb
 - lib/syntax/syntax.rb
 - lib/syntax/union_types.rb
-- lib/type_expression.rb
 - lib/types/complex_types.rb
 - lib/types/error_types.rb
-- lib/value_expression.rb
 - lib/version.rb
 homepage: https://codeberg.org/low_ruby/low_type
 licenses: []