lowtype 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fa1f2cac7f1067dd6d9c7c8f9a2c9d206cc22638c0223259a39909b65b8169f
-  data.tar.gz: bd3eaa654437ebabeecad44fccd7aa01cff8fb92d489318181c7d0fc0f757ebe
+  metadata.gz: 82aa9ca5209933447a6c144575a923487ed7a9454b24af79e814e96322657459
+  data.tar.gz: 1c589f63849d78d9f8f80acb02288192650fc115f294741d0ef4098d92d132bb
 SHA512:
-  metadata.gz: ece1f0a96afaebdb246a4448875873fddd1eb8b2785a83f20c41f8960d46f6d37bab589743bec4fc945c237c8fef6cca5ce1a973133e81dcb08fddfdb39273a4
-  data.tar.gz: 5e5d946234acf6666fc3671d7027368fce3f0bcfcdf665083d45b15a6ea8bd56111c9c61f5ad3bbfeb09995ebce1563160c0a3c3eebb46d0902638077637e3be
+  metadata.gz: f5dc29f5c922d64de71b94dc7e72bd263bdefe21fe2463f472893edd3ac37bd1ebcc1502038f1b719004b6db86b6c6884d906bca59bba8f6c48ff45e423e9ef7
+  data.tar.gz: 51f526a9ee47bae2d5018e9e7f8e3ecc60eddf4ce1f30bb2df439997912713dde8f30f073230d02a6b8ccc63d0a5245dfe0baee43d396c2b225e986f7f2e8c7b

data/lib/adapters/adapter_loader.rb

@@ -11,7 +11,7 @@ module Low
 
           return unless ancestors.include?('Sinatra::Base')
 
-          klass.prepend SinatraAdapter.new.module(file_path: class_proxy.file_path)
+          klass.prepend SinatraAdapter.new.module(class_proxy:)
         end
       end
     end

data/lib/adapters/sinatra_adapter.rb

@@ -11,10 +11,11 @@ module Low
   module Adapter
     # We don't use https://sinatrarb.com/extensions.html because we need to type check all Ruby methods (not just Sinatra) at a lower level.
     class SinatraAdapter < AdapterInterface
-      def module(file_path:) # rubocop:disable Metrics/AbcSize
-        Module.new do
-          @@file_path = file_path # rubocop:disable Style/ClassVars
+      # Route method proxies are captured on class load, so that validating a response doesn't need Lowkey's cache.
+      def module(class_proxy:) # rubocop:disable Metrics/AbcSize
+        route_proxies = class_proxy.keyed_methods
 
+        Module.new do
           # Unfortunately overriding invoke() is the best way to validate types for now. Though direct it's also very compute efficient.
           # I originally tried an after filter and it mostly worked but it only had access to Response which isn't the raw return value.
           # I suggest that Sinatra provide a hook that allows us to access the raw return value of a route before it becomes a Response.
@@ -36,9 +37,9 @@ module Low
             nil # avoid double setting the same response tuple twice
           end
 
-          def lowtype_validate!(value:)
+          define_method(:lowtype_validate!) do |value:|
             route = "#{request.request_method} #{request.path}"
-            if (method_proxy = Lowkey[@@file_path][self.class.name][route]) && (proxy = method_proxy.return_proxy)
+            if (method_proxy = route_proxies[route]) && (proxy = method_proxy.return_proxy)
               proxy.expression.validate!(value:, proxy:)
             end
           end

data/lib/cli/cli.rb

@@ -22,8 +22,8 @@ module LowType
     end
 
     line('strip!') do
-      s { 'Strips files from the current directory of their types' }
-      e { 'lowtype strip' }
+      s { 'Strips types from files in the current directory' }
+      e { 'lowtype strip!' }
       x { TypeStripper.export(src: '.', dest: '.') }
     end
 

data/lib/cli/rbs/type_mapper.rb

@@ -23,6 +23,8 @@ module LowType
             return COMPLEX_TYPE_MAP[type] if COMPLEX_TYPE_MAP.key?(type)
 
             case type
+            when ::Low::Types::Enum::Definition then map_enum(type)
+            when ::Low::Types::Status::StatusCode then 'Integer'
             when ::Low::TypeExpression then map_expression(type)
             when Array then map_array(type)
             when Hash then map_hash(type)
@@ -47,6 +49,17 @@ module LowType
             "Array[#{map(type.first)}]"
           end
 
+          def map_enum(type)
+            literals = type.values.map do |value|
+              case value
+              when Symbol, String, Integer, true, false, nil then value.inspect
+              else return 'untyped'
+              end
+            end
+
+            literals.length > 1 ? "(#{literals.join(' | ')})" : literals.first
+          end
+
           def map_hash(type)
             return 'Hash[untyped, untyped]' if type.empty?
 

data/lib/cli/type_stripper.rb

@@ -1,9 +1,158 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+require 'lowkey'
+
+require_relative '../definitions/type_accessors'
+require_relative '../queries/file_query'
+
 module LowType
+  # Removes LowType from source files, leaving plain Ruby:
+  #   method: def greet(name = String | 'World') -> { String }  =>  def greet(name = 'World')
+  #   variable: greeting = type String | 'Hello'                =>  greeting = 'Hello'
+  #   accessor: type_accessor name: String                      =>  attr_accessor :name
+  #
+  # Files are loaded into Ruby to evaluate args and decide a type from a default value. Slim syntax may reduce this need.
+  # Lowkey then rewrites the method signatures and method calls.
   module TypeStripper
+    LOWTYPE_PATTERN = /^\s*include\s+LowType\b/
+    REQUIRE_PATTERN = /\A['"][^'"]*(?:lowtype|low_type)['"]\z/
+    ACCESSOR_METHODS = { type_reader: 'attr_reader', type_writer: 'attr_writer', type_accessor: 'attr_accessor' }.freeze
+    TYPE_METHODS = %i[type low_type].freeze
+
     module_function
 
-    def export(src:, dest:); end
+    def export(src:, dest:)
+      src = File.expand_path(src)
+      dest = File.expand_path(dest)
+
+      # Stripping reads method calls from their Prism nodes, which Lowkey releases once a file loads by default.
+      keeping_nodes do
+        file_paths(src:, dest:).each do |file_path|
+          dest_path = File.file?(src) ? dest : File.join(dest, file_path.delete_prefix(src))
+          next copy(file_path:, dest_path:) unless file_path.end_with?('.rb') && File.read(file_path).match?(LOWTYPE_PATTERN)
+
+          export_file(file_path:, dest_path:)
+        end
+      end
+    end
+
+    def keeping_nodes
+      release_nodes = ::Lowkey.config.release_nodes
+      ::Lowkey.config.release_nodes = false
+      yield
+    ensure
+      ::Lowkey.config.release_nodes = release_nodes
+    end
+
+    def export_file(file_path:, dest_path:)
+      stripped = strip(file_path:)
+      write(path: dest_path, content: stripped)
+
+      puts "Stripped #{dest_path}"
+      warn "lowtype: Kept LowType in #{dest_path} as some type accessors have default values" if stripped.match?(LOWTYPE_PATTERN)
+    rescue ScriptError, StandardError => e
+      warn "lowtype: Skipped #{file_path} as it could not be loaded (#{e.class}: #{e.message.lines.first&.strip})"
+      copy(file_path:, dest_path:)
+    end
+
+    # Excludes the destination when it's inside the source, so that a previous export isn't exported again.
+    def file_paths(src:, dest: nil)
+      return [src] if File.file?(src)
+
+      Dir.glob('**/*', File::FNM_DOTMATCH, base: src).filter_map do |path|
+        file_path = File.join(src, path)
+        next if path.split('/').intersect?(%w[. .. .git]) || (dest != src && file_path.start_with?("#{dest}/"))
+
+        file_path if File.file?(file_path)
+      end
+    end
+
+    def strip(file_path:)
+      require file_path
+      raise ::Low::MissingFileError, "LowType did not load #{file_path}" unless (file_proxy = ::Lowkey[file_path])
+
+      # Method calls first, as a method call can be on the same line as a signature: "def method(arg = Type) = type(...)".
+      rewrite_method_calls(method_calls: file_proxy.definitions.values.flat_map(&:method_calls), file_path:)
+      method_proxies(file_proxy:).each { |method_proxy| method_proxy.rewrite_signature if method_proxy.expressions? }
+
+      file_proxy.lines.join
+    end
+
+    # Instance and class methods with the same name share a key in "keyed_methods".
+    def method_proxies(file_proxy:)
+      file_proxy.definitions.values.flat_map { |proxy| [*proxy.keyed_methods.values, *proxy.class_methods.values] }.uniq
+    end
+
+    # Method calls on the same line are rewritten from last to first so that their offsets stay valid.
+    # Type accessors with default values keep LowType included.
+    def rewrite_method_calls(method_calls:, file_path:)
+      # Filter before sorting, so that only the method calls being rewritten build their source.
+      method_calls = method_calls.filter { |method_call| rewritable?(method_call:) }
+
+      accessors = method_calls.filter { |method_call| accessor?(method_call:) }
+      attributes = accessors.filter { |method_call| attribute?(method_call:, file_path:) }
+      keep_lowtype = attributes.count < accessors.count
+
+      method_calls.sort_by { |method_call| -method_call.start_offset }.each do |method_call|
+        rewrite_method_call(method_call:, attribute: attributes.include?(method_call), keep_lowtype:)
+      end
+    end
+
+    def rewritable?(method_call:)
+      local_type?(method_call:) || accessor?(method_call:) || lowtype?(method_call:)
+    end
+
+    def rewrite_method_call(method_call:, attribute:, keep_lowtype:)
+      if local_type?(method_call:)
+        method_call.rewrite(method_call.default)
+      elsif attribute
+        method_call.rewrite("#{ACCESSOR_METHODS[method_call.name]} #{method_call.keywords.map(&:inspect).join(', ')}")
+      elsif !keep_lowtype && lowtype?(method_call:)
+        method_call.remove
+      end
+    end
+
+    # "type String | 'Hello'" becomes "'Hello'".
+    def local_type?(method_call:)
+      !method_call.receiver? && TYPE_METHODS.include?(method_call.name) && !method_call.default.nil?
+    end
+
+    # Only symbol keys can become attribute names. A double splat like "**expressions" can't be converted.
+    def accessor?(method_call:)
+      !method_call.receiver? && ACCESSOR_METHODS.key?(method_call.name)
+    end
+
+    # Type accessors are attributes when they have no default value. Their expressions are evaluated on class load.
+    def attribute?(method_call:, file_path:)
+      return false unless method_call.arguments.one? && method_call.keywords
+      return false unless (expressions = ::Low::TypeAccessors.expressions[[file_path, method_call.start_line]])
+
+      expressions.values.all? { |expression| expression.required? || expression.default_value.nil? }
+    end
+
+    # "include LowType", "using LowType::Syntax" and "require 'lowtype'".
+    def lowtype?(method_call:)
+      return false if method_call.receiver?
+
+      case method_call.name
+      when :include then method_call.arguments == ['LowType']
+      when :using then method_call.arguments == ['LowType::Syntax']
+      when :require, :require_relative then method_call.arguments.one? && method_call.arguments.first.match?(REQUIRE_PATTERN)
+      else false
+      end
+    end
+
+    def write(path:, content:)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, content)
+    end
+
+    def copy(file_path:, dest_path:)
+      return if dest_path == file_path
+
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      FileUtils.cp(file_path, dest_path, preserve: true)
+    end
   end
 end

data/lib/definitions/evaluator.rb

@@ -66,6 +66,9 @@ module Low
               new.class_evaluate(proxy: param_proxy, class_binding:)
             end
             param_proxy.expression = cast_type_expression(expression:, param_proxy:)
+
+            polyfill_default(param_proxy:)
+            validate_default!(param_proxy:)
           end
         rescue NameError => e
           mp = method_proxy
@@ -99,6 +102,30 @@ module Low
 
         nil
       end
+
+      def polyfill_default(param_proxy:)
+        expression = param_proxy.expression
+
+        case expression.class.name
+        when 'Low::Dependency'
+          # Remap dependency expression to providers hash lookup method.
+          param_proxy.default = "Providers[#{expression.provider_key.inspect}]"
+        end
+      end
+
+      # Fail early on class load rather than on method call.
+      def validate_default!(param_proxy:)
+        expression = param_proxy.expression
+        return unless expression.is_a?(TypeExpression) && !expression.required?
+
+        # When an enum's default value isn't an allowed value.
+        if expression.types.any? { |type| type.is_a?(Types::Enum::Definition) }
+          expression.validate!(value: expression.default_value, proxy: param_proxy)
+        end
+      rescue ArgumentError
+        raise AllowedTypeError, "Invalid default value #{expression.display_default} for parameter '#{param_proxy.name}' " \
+                                "at #{param_proxy.file_path}:#{param_proxy.start_line}. Valid types: '#{expression.valid_types}'"
+      end
     end
   end
 end

data/lib/definitions/redefiner.rb

@@ -104,7 +104,10 @@ module Low
         method_proxies.values.filter(&:expressions?).each do |method_proxy|
           method_proxy.rewrite_signature
 
-          klass.class_eval(method_proxy.export, method_proxy.file_path, method_proxy.start_line)
+          # Class methods are evaluated on the singleton class but "def self.method" would define a method on the
+          # singleton class's own singleton class. So methods with a receiver are evaluated in the class instead.
+          target = klass.singleton_class? && method_proxy.receiver? ? klass.attached_object : klass
+          target.class_eval(method_proxy.export, method_proxy.file_path, method_proxy.start_line)
 
           if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
             klass.send(:private, method_proxy.name)

data/lib/definitions/type_accessors.rb

@@ -17,53 +17,76 @@ module Low
   # type_writer name: String | nil # accepts String or nil
   #
   module TypeAccessors
-    def type_reader(named_expressions)
-      named_expressions.each do |name, exp|
-        last_caller = caller_locations(1, 1).first
-
-        file_path = last_caller.path
-        scope = "#{self}##{name}"
-
-        expression = cast_type_expression(exp)
-        # Source usually defined on file load with access to lines in a source file, but type accessors are defined on class load.
-        source = ::Lowkey::Source.new(file_path:, scope:, lines: [], start_line: last_caller.lineno, end_line: last_caller.lineno)
-        proxy = ::Lowkey::ReturnProxy.new(name:, source:, expression:)
-
-        define_method(name) do
-          value = instance_variable_get("@#{name}")
-          expression.validate!(value:, proxy:)
-          value
-        end
+    class << self
+      # Expressions by file path and line, so that tools like TypeStripper can find the expressions of a type accessor.
+      def expressions
+        @expressions ||= {}
+      end
+
+      # A default value is returned when the instance variable is nil. Mutable defaults are new copies each time.
+      def default_value(expression:)
+        return nil if expression.required?
+
+        value = expression.default_value
+        value.is_a?(ValueExpression) ? value : value.dup
       end
     end
 
+    def type_reader(named_expressions)
+      location = caller_locations(1, 1).first
+      named_expressions.each { |name, expression| define_type_reader(name:, expression:, location:) }
+    end
+
     def type_writer(named_expressions)
+      location = caller_locations(1, 1).first
+      named_expressions.each { |name, expression| define_type_writer(name:, expression:, location:) }
+    end
+
+    def type_accessor(named_expressions)
+      location = caller_locations(1, 1).first
+
       named_expressions.each do |name, expression|
-        last_caller = caller_locations(1, 1).first
+        define_type_reader(name:, expression:, location:)
+        define_type_writer(name:, expression:, location:)
+      end
+    end
+
+    private
 
-        file_path = last_caller.path
-        scope = "#{self}##{name}"
+    def define_type_reader(name:, expression:, location:)
+      expression = register(name:, expression:, location:)
+      proxy = ::Lowkey::ReturnProxy.new(name:, source: accessor_source(name:, location:), expression:)
 
-        expression = cast_type_expression(expression)
-        # Source usually defined on file load with access to lines in a source file, but type accessors are defined on class load.
-        source = ::Lowkey::Source.new(file_path:, scope:, lines: [], start_line: last_caller.lineno, end_line: last_caller.lineno)
-        proxy = ::Lowkey::ParamProxy.new(name:, source:, type: :pos_req, position: nil, expression:)
+      define_method(name) do
+        value = instance_variable_get("@#{name}")
+        value = TypeAccessors.default_value(expression:) if value.nil?
 
-        define_method("#{name}=") do |value|
-          expression.validate!(value:, proxy:)
-          instance_variable_set("@#{name}", value)
-        end
+        expression.validate!(value:, proxy:)
+        value.is_a?(ValueExpression) ? value.value : value
       end
     end
 
-    def type_accessor(named_expressions)
-      named_expressions.each do |name, expression|
-        type_reader({ name => expression })
-        type_writer({ name => expression })
+    def define_type_writer(name:, expression:, location:)
+      expression = register(name:, expression:, location:)
+      proxy = ::Lowkey::ParamProxy.new(name:, source: accessor_source(name:, location:), type: :pos_req, position: nil, expression:)
+
+      define_method("#{name}=") do |value|
+        expression.validate!(value:, proxy:)
+        instance_variable_set("@#{name}", value)
       end
     end
 
-    private
+    def register(name:, expression:, location:)
+      expression = cast_type_expression(expression)
+      expressions = TypeAccessors.expressions[[location.path, location.lineno]] ||= {}
+      expressions[name] = expression
+    end
+
+    # Type accessors are defined on class load (not file load) so Source needs to be simulated.
+    def accessor_source(name:, location:)
+      line = location.lineno
+      ::Lowkey::Source.new(file_path: location.path, scope: "#{self}##{name}", lines: [], start_line: line, end_line: line)
+    end
 
     def cast_type_expression(expression)
       if expression.is_a?(::Expressions::Expression)

data/lib/expressions/type_expression.rb

@@ -55,7 +55,7 @@ module Low
         if type.is_a?(Array)
           "[#{type.map { |subtype| valid_subtype(subtype:) }.join(', ')}]"
         else
-          type.inspect.to_s.delete_prefix('Low::Types::')
+          display_name(type:)
         end
       end
 
@@ -63,6 +63,13 @@ module Low
       types.join(' | ')
     end
 
+    def display_default
+      display_default = default_value
+      display_default = default_value.value if default_value.is_a?(ValueExpression)
+
+      display_default.inspect.to_s
+    end
+
     private
 
     def union_expression(expression)
@@ -85,14 +92,20 @@ module Low
 
     def valid_subtype(subtype:)
       if subtype.is_a?(TypeExpression)
-        types = subtype.types
+        types = subtype.types.map { |type| display_name(type:) }
         types << 'nil' if subtype.default_value.nil?
         types.join(' | ')
       else
-        subtype.to_s.delete_prefix('Low::Types::')
+        display_name(type: subtype)
       end
     end
 
+    def display_name(type:)
+      return type.display_name if type.respond_to?(:display_name)
+
+      type.inspect.to_s.delete_prefix('Low::Types::')
+    end
+
     def array_types_match_values?(types:, values:, proxy:)
       # [X, Y, Z] An arbitrary amount of elements are arbitrary types in an arbitrary order.
       if types.length > 1
@@ -136,8 +149,9 @@ module Low
     end
 
     def type_matches_value?(type:, value:, proxy:)
-      if type.instance_of?(Class)
-        return type.match?(value:) if Low::TypeQuery.complex_type?(expression: type)
+      if Low::TypeQuery.complex_type?(expression: type)
+        return type.match?(value:)
+      elsif type.instance_of?(Class)
         return value.value <= type if value.instance_of?(ValueExpression)
 
         return value.is_a?(type)

data/lib/lowtype.rb

@@ -32,10 +32,11 @@ require_relative 'types/complex_types'
 #      │              │                 │                 │               │
 module LowType
   # Defers evaluation and redefinition until after the class body finishes loading via TracePoint :end.
-  def self.included(klass)
-    file_path = Low::FileQuery.file_path(klass:)
-    file_proxy = Lowkey.load(file_path)
-    class_proxy = file_proxy[klass.name]
+  def self.included(klass) # rubocop:disable Metrics/AbcSize
+    class_proxy = Lowkey[Low::FileQuery.file_path(klass:)][klass.name]
+
+    # Type accessors evaluate union types in the class body, before the class is evaluated.
+    require_relative 'syntax/union_types' if LowType.config.union_type_expressions
 
     klass.include Low::ExpressionHelpers
     klass.extend Low::ExpressionHelpers
@@ -45,7 +46,7 @@ module LowType
     # Use TracePoint :end to capture the class binding after the class body finishes loading.
     # At :end time, trace.self is the including class and trace.binding is the class body's binding,
     # stored on class_proxy.class_binding for use by LowType and other consumers.
-    tp = TracePoint.new(:end) do |trace|
+    trace_point = TracePoint.new(:end) do |trace|
       next unless trace.self == klass
 
       class_proxy.class_binding = trace.binding
@@ -60,10 +61,10 @@ module LowType
 
       Low::Adapter::Loader.load(klass:, class_proxy:)
 
-      tp.disable
+      trace_point.disable
     end
 
-    tp.enable
+    trace_point.enable
   end
 
   Config = Struct.new(

data/lib/queries/type_query.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 require_relative '../expressions/type_expression'
+require_relative '../types/type_definition'
 
 module Low
   # TODO: Unit test.
   class TypeQuery
     class << self
       def type?(expression)
-        basic_type?(expression:) || complex_type?(expression:)
+        basic_type?(expression:) || complex_type?(expression:) || typed_array?(expression:) || typed_hash?(expression:)
       end
 
       def typed_array?(expression:)
@@ -15,11 +16,17 @@ module Low
       end
 
       def value?(value)
-        !basic_type?(expression: value) && !complex_type?(expression: value)
+        !type?(value)
       end
 
+      # Complex types and type definitions respond to "match?(value:)".
       def complex_type?(expression:)
-        Low::Types::COMPLEX_TYPES.include?(expression) || typed_array?(expression:) || typed_hash?(expression:)
+        Low::Types::COMPLEX_TYPES.include?(expression) || typed_definition?(expression:)
+      end
+
+      # A parameterized type such as "Status[200]" or "Enum[:a, :b]".
+      def typed_definition?(expression:)
+        expression.is_a?(Low::TypeDefinition)
       end
 
       private

data/lib/types/boolean.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Low
+  module Types
+    class Boolean
+      class << self
+        def match?(value:)
+          value.equal?(true) || value.equal?(false)
+        end
+
+        def display_name
+          'Boolean'
+        end
+      end
+    end
+  end
+end

data/lib/types/complex_types.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require_relative '../factories/type_factory'
+require_relative 'boolean'
+require_relative 'enum'
 require_relative 'status'
 
 module Low
   module Types
     COMPLEX_TYPES = [
-      Boolean = TypeFactory.complex_type(Object),
+      Boolean,
       Headers = TypeFactory.complex_type(Hash),
       HTML = TypeFactory.complex_type(String),
       JSON = TypeFactory.complex_type(String),

data/lib/types/enum.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'error_types'
+require_relative 'type_definition'
+
+module Low
+  module Types
+    # A set of allowed values like "Enum[:value, 'value', 123]".
+    class Enum
+      def self.[](*values)
+        Definition.new(values:)
+      end
+
+      class Definition
+        include TypeDefinition
+
+        attr_reader :values
+
+        def initialize(values:)
+          raise AllowedTypeError, 'Enum requires at least one allowed value' if values.empty?
+
+          @values = values.freeze
+        end
+
+        def match?(value:)
+          @values.any? { |allowed| allowed == value }
+        end
+
+        def display_name
+          "Enum[#{@values.map(&:inspect).join(', ')}]"
+        end
+
+        def ==(other)
+          other.class == self.class && other.values == @values
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          [self.class, @values].hash
+        end
+      end
+    end
+  end
+end

data/lib/types/status.rb

@@ -2,6 +2,7 @@
 
 require_relative 'complex_type'
 require_relative 'error_types'
+require_relative 'type_definition'
 
 module Low
   module Types
@@ -15,6 +16,8 @@ module Low
       end
 
       class StatusCode
+        include TypeDefinition
+
         attr_reader :status_code
 
         STATUS_CODES = [
@@ -37,6 +40,14 @@ module Low
           @status_code = status_code
         end
 
+        def match?(value:)
+          value == @status_code
+        end
+
+        def display_name
+          "Status[#{@status_code}]"
+        end
+
         def ==(other)
           other.class == self.class && other.status_code == @status_code
         end

data/lib/types/type_definition.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Low
+  # A complex type with params, created via the "Type[params]" syntax.
+  module TypeDefinition
+    # For "Type[params] | [type_expression/type/value]" situations, convert definition into a type expression.
+    def |(other)
+      ::Low::TypeExpression.new(type: self) | other
+    end
+
+    def match?(value:)
+      raise NotImplementedError
+    end
+
+    def display_name
+      raise NotImplementedError
+    end
+  end
+end

data/lib/version.rb

@@ -2,6 +2,6 @@
 
 module Low
   module Type
-    VERSION = '1.5.0'
+    VERSION = '1.6.0'
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lowtype
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - maedi
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dirload
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: trees
   requirement: !ruby/object:Gem::Requirement
@@ -101,10 +101,13 @@ files:
 - lib/queries/type_query.rb
 - lib/syntax/syntax.rb
 - lib/syntax/union_types.rb
+- lib/types/boolean.rb
 - lib/types/complex_type.rb
 - lib/types/complex_types.rb
+- lib/types/enum.rb
 - lib/types/error_types.rb
 - lib/types/status.rb
+- lib/types/type_definition.rb
 - lib/version.rb
 homepage: https://github.com/low-rb/lowtype
 licenses: []
@@ -125,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Elegant types in Ruby
 test_files: []