domainic-type 0.1.0.alpha.3.0.2 → 0.1.0.alpha.3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56d315e14fd05fe94174f580d09843c227cc5d763e994b47fd4094c26365dafc
-  data.tar.gz: cf0288834c42fdd9d985ddb889484273dbae5278e0b8f0f1bd0021317c0387ae
+  metadata.gz: ba2ef6a6a8d06966d736c794476322b088878573154468dc55de61a85704f459
+  data.tar.gz: 8f7fcb77831968e9f6f4f42c58bc2f63892b56bae35902aec892932dc5425acc
 SHA512:
-  metadata.gz: d53f6f1acc6969c093bb3617acb04ec17d507571c514604c941e378ad80341e7145d5f15298ec4922e68fc646e5f984cfc3e49fa8a7f2ab501d30456329dc9a4
-  data.tar.gz: 9e5a0a9815c013086aeb5d183b66f2dfa3e0db4c31d62b8357ce0a2a12ca5bd3aafdad0a94d8c01781171a61df7a37d9dacd21b5d9d9256fe218ce62bc7b81e7
+  metadata.gz: 8fbe93a49fd3d0063c7d9e392cc1e99180cbdfacb3a1a355c813eaa3df5f476be03e6c44b265871bdea82c646c250b5f486b4446f8c0ce2efbc4481c778d5553
+  data.tar.gz: 2509ae814a1dbb07a2100c24fe0aff90b8c59123f41d8b37a90bce60c9ad33fe1ecd9d57562533e3f7c52f5c051c27120136d1d7f1efe1df4714212281663827

data/lib/domainic/type/behavior/string_behavior/matching_behavior.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Domainic
+  module Type
+    module Behavior
+      module StringBehavior
+        # A module providing string matching constraint methods
+        #
+        # This module extends types with methods for constraining string values based on
+        # equality, pattern matching, and substring inclusion/exclusion. It provides a
+        # fluent interface for building complex string matching constraints.
+        #
+        # @example Basic equality constraints
+        #   type = StringType.new
+        #     .being_equal_to("expected")
+        #     .not_being_equal_to("forbidden")
+        #
+        # @example Pattern matching constraints
+        #   type = StringType.new
+        #     .matching(/^\w+$/, /[0-9]/)
+        #     .not_matching(/admin/i)
+        #
+        # @example Substring constraints
+        #   type = StringType.new
+        #     .containing("allowed", "required")
+        #     .excluding("forbidden", "blocked")
+        #
+        # @author {https://aaronmallen.me Aaron Allen}
+        # @since 0.1.0
+        module MatchingBehavior
+          # Constrain string to equal a specific value
+          #
+          # @param literal [String, Symbol] the value to match against
+          # @return [Behavior] self for method chaining
+          # @rbs (String | Symbol literal) -> Behavior
+          def being_equal_to(literal)
+            # @type self: Object & Behavior
+            constrain :self, :equality, literal, description: 'equaling'
+          end
+          alias eql being_equal_to
+          alias equal_to being_equal_to
+          alias equaling being_equal_to
+
+          # Constrain string to contain specific substrings
+          #
+          # @param literals [Array<String, Symbol>] the required substrings
+          # @return [Behavior] self for method chaining
+          # @rbs (*String | Symbol literals) -> Behavior
+          def containing(*literals)
+            # @type self: Object & Behavior
+            including = literals.map do |literal|
+              @constraints.prepare :self, :inclusion, literal, coerce_with: lambda(&:to_s)
+            end
+            constrain :self, :and, including, concerning: :inclusion
+          end
+          alias including containing
+
+          # Constrain string to exclude specific substrings
+          #
+          # @param literals [Array<String, Symbol>] the forbidden substrings
+          # @return [Behavior] self for method chaining
+          # @rbs (*String | Symbol literals) -> Behavior
+          def excluding(*literals)
+            # @type self: Object & Behavior
+            including = literals.map do |literal|
+              @constraints.prepare :self, :inclusion, literal, coerce_with: lambda(&:to_s)
+            end
+            constrain :self, :nor, including, concerning: :exclusion
+          end
+          alias omitting excluding
+
+          # Constrain string to match specific patterns
+          #
+          # @param patterns [Array<String, Regexp>] the required patterns
+          # @return [Behavior] self for method chaining
+          # @rbs (*String | Regexp patterns) -> Behavior
+          def matching(*patterns)
+            # @type self: Object & Behavior
+            matching_patterns = patterns.map do |pattern|
+              @constraints.prepare :self, :match_pattern, pattern
+            end
+            constrain :self, :and, matching_patterns, concerning: :pattern_inclusion
+          end
+
+          # Constrain string to not equal a specific value
+          #
+          # @param literal [String, Symbol] the forbidden value
+          # @return [Behavior] self for method chaining
+          # @rbs (String | Symbol literal) -> Behavior
+          def not_being_equal_to(literal)
+            # @type self: Object & Behavior
+            equal_to = @constraints.prepare :self, :equality, literal
+            constrain :self, :not, equal_to, concerning: :equality, description: 'being'
+          end
+          alias not_eql not_being_equal_to
+          alias not_equal_to not_being_equal_to
+          alias not_equaling not_being_equal_to
+
+          # Constrain string to not match specific patterns
+          #
+          # @param patterns [Array<String, Regexp>] the forbidden patterns
+          # @return [Behavior] self for method chaining
+          # @rbs (*String | Regexp patterns) -> Behavior
+          def not_matching(*patterns)
+            # @type self: Object & Behavior
+            matching_patterns = patterns.map do |pattern|
+              @constraints.prepare :self, :match_pattern, pattern
+            end
+            constrain :self, :nor, matching_patterns, concerning: :pattern_exclusion
+          end
+        end
+      end
+    end
+  end
+end

data/lib/domainic/type/behavior/string_behavior.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'domainic/type/behavior/string_behavior/matching_behavior'
 require 'domainic/type/behavior/sizable_behavior'
 
 module Domainic
@@ -54,6 +55,7 @@ module Domainic
       # @author {https://aaronmallen.me Aaron Allen}
       # @since 0.1.0
       module StringBehavior
+        include MatchingBehavior
         include SizableBehavior
 
         # Validate string contains only alphanumeric characters.
@@ -102,24 +104,6 @@ module Domainic
         end
         alias empty being_empty
 
-        # Validate string equals a specific value.
-        #
-        # @example
-        #   type.being_equal_to("hello")
-        #   type.validate("hello")  # => true
-        #   type.validate("world")  # => false
-        #
-        # @param literal [String, Symbol] the value to compare against
-        # @return [Behavior] self for method chaining
-        # @rbs (String | Symbol literal) -> Behavior
-        def being_equal_to(literal)
-          # @type self: Object & Behavior
-          constrain :self, :equality, literal, description: 'equaling'
-        end
-        alias eql being_equal_to
-        alias equal_to being_equal_to
-        alias equaling being_equal_to
-
         # Validate string is lowercase.
         #
         # @example
@@ -266,62 +250,6 @@ module Domainic
         alias not_being_lowercase being_uppercase
         alias uppercase being_uppercase
 
-        # Validate string contains all specified substrings.
-        #
-        # @example
-        #   type.containing("hello", "world")
-        #   type.validate("hello world")  # => true
-        #   type.validate("hello")        # => false
-        #
-        # @param literals [Array<String, Symbol>] the substrings to look for
-        # @return [Behavior] self for method chaining
-        # @rbs (*String | Symbol literals) -> Behavior
-        def containing(*literals)
-          # @type self: Object & Behavior
-          including = literals.map do |literal|
-            @constraints.prepare :self, :inclusion, literal, coerce_with: lambda(&:to_s)
-          end
-          constrain :self, :and, including, concerning: :inclusion
-        end
-        alias including containing
-
-        # Validate string does not contain any specified substrings.
-        #
-        # @example
-        #   type.excluding("foo", "bar")
-        #   type.validate("hello world")  # => true
-        #   type.validate("foo bar")      # => false
-        #
-        # @param literals [Array<String, Symbol>] the substrings to exclude
-        # @return [Behavior] self for method chaining
-        # @rbs (*String | Symbol literals) -> Behavior
-        def excluding(*literals)
-          # @type self: Object & Behavior
-          including = literals.map do |literal|
-            @constraints.prepare :self, :inclusion, literal, coerce_with: lambda(&:to_s)
-          end
-          constrain :self, :nor, including, concerning: :exclusion
-        end
-        alias omitting excluding
-
-        # Validate string matches all specified patterns.
-        #
-        # @example
-        #   type.matching(/^\w+$/, /\d/)
-        #   type.validate("hello123")  # => true
-        #   type.validate("hello")     # => false
-        #
-        # @param patterns [Array<String, Regexp>] the patterns to match against
-        # @return [Behavior] self for method chaining
-        # @rbs (*String | Regexp patterns) -> Behavior
-        def matching(*patterns)
-          # @type self: Object & Behavior
-          matching_patterns = patterns.map do |pattern|
-            @constraints.prepare :self, :match_pattern, pattern
-          end
-          constrain :self, :and, matching_patterns, concerning: :pattern_inclusion
-        end
-
         # Validate string is not empty.
         #
         # @example
@@ -336,43 +264,6 @@ module Domainic
           empty = @constraints.prepare :self, :emptiness
           constrain :self, :not, empty, concerning: :emptiness, description: 'being'
         end
-
-        # Validate string does not equal a specific value.
-        #
-        # @example
-        #   type.not_being_equal_to("admin")
-        #   type.validate("user")   # => true
-        #   type.validate("admin")  # => false
-        #
-        # @param literal [String, Symbol] the value to compare against
-        # @return [Behavior] self for method chaining
-        # @rbs (String | Symbol literal) -> Behavior
-        def not_being_equal_to(literal)
-          # @type self: Object & Behavior
-          equal_to = @constraints.prepare :self, :equality, literal
-          constrain :self, :not, equal_to, concerning: :equality, description: 'being'
-        end
-        alias not_eql not_being_equal_to
-        alias not_equal_to not_being_equal_to
-        alias not_equaling not_being_equal_to
-
-        # Validate string does not match any specified patterns.
-        #
-        # @example
-        #   type.not_matching(/\d/, /[A-Z]/)
-        #   type.validate("hello")     # => true
-        #   type.validate("Hello123")  # => false
-        #
-        # @param patterns [Array<String, Regexp>] the patterns to avoid matching
-        # @return [Behavior] self for method chaining
-        # @rbs (*String | Regexp patterns) -> Behavior
-        def not_matching(*patterns)
-          # @type self: Object & Behavior
-          matching_patterns = patterns.map do |pattern|
-            @constraints.prepare :self, :match_pattern, pattern
-          end
-          constrain :self, :nor, matching_patterns, concerning: :pattern_exclusion
-        end
       end
     end
   end

data/lib/domainic/type/behavior/uri_behavior.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Domainic
+  module Type
+    module Behavior
+      # A module providing URI-based validation behaviors for types.
+      #
+      # This module extends the base Type::Behavior with methods designed for validating URI-related constraints.
+      # It focuses on ensuring URIs conform to specific rules, such as restricting or excluding particular
+      # top-level domains (TLDs). These features are useful for scenarios like domain-specific validations
+      # or blocking specific domain extensions.
+      #
+      # Key features:
+      # - Top-level domain inclusion constraints
+      # - Top-level domain exclusion constraints
+      # - Flexible and customizable pattern matching
+      # - Consistent interface for defining URI-related constraints
+      #
+      # @example Basic usage
+      #   class MyType
+      #     include Domainic::Type::Behavior::URIBehavior
+      #
+      #     def initialize
+      #       super
+      #       having_top_level_domain("com", "org")      # Allow only .com and .org
+      #       not_having_top_level_domain("test", "dev") # Exclude .test and .dev
+      #     end
+      #   end
+      #
+      # @example Method aliases
+      #   type.having_top_level_domain("com")      # Allow only .com
+      #   type.tld("com")                          # Same as above
+      #   type.with_tld("com")                     # Same as above
+      #
+      #   type.not_having_top_level_domain("test") # Exclude .test
+      #   type.not_tld("test")                     # Same as above
+      #   type.not_top_level_domain("test")        # Same as above
+      #
+      # This module provides a consistent interface for working with URIs, ensuring flexibility and
+      # extensibility for domain and TLD validation tasks.
+      #
+      # @author {https://aaronmallen.me Aaron Allen}
+      # @since 0.1.0
+      module URIBehavior
+        # Constrain URIBehavior to allowed top-level domains
+        #
+        # Creates a constraint ensuring the URIBehavior uses one of the specified top-level
+        # domains (TLDs). This allows restricting emails to specific TLDs like .com or .org.
+        #
+        # @example
+        #   type.having_top_level_domain("com", "org")
+        #   type.validate("example.com")  # => true
+        #   type.validate("example.net")  # => false
+        #
+        # @param top_level_domains [Array<String>] List of allowed TLDs
+        # @return [self] self for method chaining
+        # @rbs (*String top_level_domains) -> Behavior
+        def having_top_level_domain(*top_level_domains)
+          pattern = /\.(#{top_level_domains.map { |t| Regexp.escape(t) }.join('|')})\z/i
+          # @type self: Object & Behavior
+          constrain :self, :match_pattern, pattern, concerning: :top_level_domain_inclusion
+        end
+        alias allowing_tld having_top_level_domain
+        alias allowing_top_level_domain having_top_level_domain
+        alias having_tld having_top_level_domain
+        alias tld having_top_level_domain
+        alias with_tld having_top_level_domain
+        alias with_top_level_domain having_top_level_domain
+
+        # Constrain URIBehavior to exclude specific top-level domains
+        #
+        # Creates a constraint ensuring the email does not use any of the specified
+        # top-level domains (TLDs). Useful for blocking certain TLDs.
+        #
+        # @example
+        #   type.not_having_top_level_domain("test")
+        #   type.validate("example.com")   # => true
+        #   type.validate("example.test")  # => false
+        #
+        # @param top_level_domains [Array<String>] List of forbidden TLDs
+        # @return [self] self for method chaining
+        # @rbs (*String top_level_domains) -> Behavior
+        def not_having_top_level_domain(*top_level_domains)
+          pattern = /\.(#{top_level_domains.map { |t| Regexp.escape(t) }.join('|')})\z/i
+          top_level_domains = @constraints.prepare :self, :match_pattern, pattern
+          # @type self: Object & Behavior
+          constrain :self, :not, top_level_domains, concerning: :top_level_domain_exclusion
+        end
+        alias forbidding_tld not_having_top_level_domain
+        alias forbidding_top_level_domain not_having_top_level_domain
+        alias not_having_tld not_having_top_level_domain
+        alias not_tld not_having_top_level_domain
+        alias not_top_level_domain not_having_top_level_domain
+      end
+    end
+  end
+end

data/lib/domainic/type/behavior.rb

@@ -105,6 +105,8 @@ module Domainic
         #
         # @see Constraint::Set#add
         #
+        # @deprecated Use {#intrinsically_constrain} instead
+        #
         # @return [void]
         # @rbs (
         #   Type::accessor accessor,
@@ -113,7 +115,10 @@ module Domainic
         #   **untyped options
         #   ) -> void
         def intrinsic(...)
-          intrinsic_constraints.add(...)
+          warn 'Domainic::Type::Behavior.intrinsic is deprecated and will be remove in a future release. Use ' \
+               "Domainic::Type::Behavior.intrinsically_constrain instead.\n" \
+               "Called from: #{caller_locations(1..1)&.first}"
+          intrinsically_constrain(...)
         end
 
         # Get the set of intrinsic constraints for this type.
@@ -124,6 +129,21 @@ module Domainic
           @intrinsic_constraints ||= Constraint::Set.new
         end
 
+        # Add an intrinsic constraint to this type.
+        #
+        # @see Constraint::Set#add
+        #
+        # @return [void]
+        # @rbs (
+        #   Type::accessor accessor,
+        #   String | Symbol constraint_type,
+        #   ?untyped expectation,
+        #   **untyped options
+        #   ) -> void
+        def intrinsically_constrain(...)
+          intrinsic_constraints.add(...)
+        end
+
         # Delegate unknown methods to a new instance.
         #
         # @return [Object] The result of calling the method on a new instance

data/lib/domainic/type/config/registry.yml

@@ -78,9 +78,15 @@ types:
   anything:
     constant: Domainic::Type::AnythingType
     require_path: domainic/type/types/specification/anything_type
+  cuid:
+    constant: Domainic::Type::CUIDType
+    require_path: domainic/type/types/identifier/cuid_type
   duck:
     constant: Domainic::Type::DuckType
     require_path: domainic/type/types/specification/duck_type
+  email_address:
+    constant: Domainic::Type::EmailAddressType
+    require_path: domainic/type/types/network/email_address_type
   enum:
     constant: Domainic::Type::EnumType
     require_path: domainic/type/types/specification/enum_type
@@ -90,6 +96,9 @@ types:
   hash:
     constant: Domainic::Type::HashType
     require_path: domainic/type/types/core/hash_type
+  hostname:
+    constant: Domainic::Type::HostnameType
+    require_path: domainic/type/types/network/hostname_type
   instance_type:
     constant: Domainic::Type::InstanceType
     require_path: domainic/type/types/specialized/instance_type
@@ -105,6 +114,12 @@ types:
   union:
     constant: Domainic::Type::UnionType
     require_path: domainic/type/types/specification/union_type
+  uri:
+    constant: Domainic::Type::URIType
+    require_path: domainic/type/types/network/uri_type
+  uuid:
+    constant: Domainic::Type::UUIDType
+    require_path: domainic/type/types/identifier/uuid_type
   void:
     constant: Domainic::Type::VoidType
     require_path: domainic/type/types/specification/void_type

data/lib/domainic/type/definitions.rb

@@ -103,6 +103,36 @@ module Domainic
       end
       alias _Bool? _Boolean?
 
+      # Creates a CUIDType instance
+      #
+      # @example
+      #   type = _CUID.v2
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::CUIDType] the created type
+      # @rbs (**__todo__ options) -> CUIDType
+      def _CUID(**options)
+        require 'domainic/type/types/identifier/cuid_type'
+        Domainic::Type::CUIDType.new(**options)
+      end
+      alias _Cuid _CUID
+
+      # Creates a nilable CUIDType instance.
+      #
+      # @example
+      #   _CUID? === "la6m1dv00000gv25zp9ru12g" # => true
+      #   _CUID? === nil                        # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (CUIDType or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _CUID?(**options)
+        _Nilable(_CUID(**options))
+      end
+      alias _Cuid? _CUID?
+
       # Creates a DuckType instance.
       #
       # DuckType allows specifying behavior based on method availability.
@@ -122,6 +152,38 @@ module Domainic
       alias _Protocol _Duck
       alias _RespondingTo _Duck
 
+      # Creates an EmailAddressType instance.
+      #
+      # EmailAddressType restricts values to valid email addresses.
+      #
+      # @example
+      #   type = _EmailAddress.having_hostname('example.com')
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::EmailAddressType] the created type
+      # @rbs (**__todo__ options) -> EmailAddressType
+      def _EmailAddress(**options)
+        require 'domainic/type/types/network/email_address_type'
+        Domainic::Type::EmailAddressType.new(**options)
+      end
+      alias _Email _EmailAddress
+
+      # Creates a nilable EmailAddressType instance.
+      #
+      # @example
+      #   _EmailAddress?.validate("user@example.com") # => true
+      #   _EmailAddress?.validate(nil)                # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (EmailAddress or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _EmailAddress?(**options)
+        _Nilable(_EmailAddress(**options))
+      end
+      alias _Email? _EmailAddress?
+
       # Creates an EnumType instance.
       #
       # EnumType restricts values to a specific set of literals.
@@ -218,6 +280,63 @@ module Domainic
       end
       alias _Map? _Hash?
 
+      # Creates a HostnameType instance.
+      #
+      # HostnameType restricts values to valid hostnames.
+      #
+      # @example
+      #   type = _Hostname.matching('example.com')
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::HostnameType] the created type
+      # @rbs (**__todo__ options) -> HostnameType
+      def _Hostname(**options)
+        require 'domainic/type/types/network/hostname_type'
+        Domainic::Type::HostnameType.new(**options)
+      end
+
+      # Creates a nilable HostnameType instance.
+      #
+      # @example
+      #   _Hostname?.validate("example.com") # => true
+      #   _Hostname?.validate(nil)           # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (Hostname or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Hostname?(**options)
+        _Nilable(_Hostname(**options))
+      end
+
+      # Creates a UnionType of IntegerType, UUIDType, and CUIDType
+      #
+      # @example
+      #   _ID === 1234567890                             # => true
+      #   _ID === '123e4567-e89b-42d3-a456-426614174000' # => true
+      #   _ID === 'la6m1dv00000gv25zp9ru12g'             # => true
+      #
+      # @return [Domainic::Type::UnionType] the created type
+      # @rbs () -> UnionType
+      def _ID
+        _Union(_Integer, _UUID, _CUID)
+      end
+
+      # Creates a nilable UnionType of IntegerType, UUIDType, and CUIDType
+      #
+      # @example
+      #   _ID === 1234567890                             # => true
+      #   _ID === '123e4567-e89b-42d3-a456-426614174000' # => true
+      #   _ID === 'la6m1dv00000gv25zp9ru12g'             # => true
+      #   _ID === nil                                    # => true
+      #
+      # @return [Domainic::Type::UnionType] the created type
+      # @rbs () -> UnionType
+      def _ID?
+        _Nilable(_ID)
+      end
+
       # Create an InstanceType instance.
       #
       # @example
@@ -240,7 +359,7 @@ module Domainic
       #
       # @param options [Hash] additional configuration options
       #
-      # @return [Domainic::Type::UnionType] the created type (Integer or NilClass)
+      # @return [Domainic::Type::UnionType] the created type (InstanceType or NilClass)
       # @rbs (**__todo__ options) -> UnionType
       def _Instance?(**options)
         _Nilable(_Instance(**options))
@@ -356,6 +475,36 @@ module Domainic
       end
       alias _Interned? _Symbol?
 
+      # Creates a UUIDType instance
+      #
+      # @example
+      #   type = _UUID.v4_compact
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UUIDType] the created type
+      # @rbs (**__todo__ options) -> UUIDType
+      def _UUID(**options)
+        require 'domainic/type/types/identifier/uuid_type'
+        Domainic::Type::UUIDType.new(**options)
+      end
+      alias _Uuid _UUID
+
+      # Creates a nilable UUIDType instance.
+      #
+      # @example
+      #   _UUID? === '123e4567-e89b-42d3-a456-426614174000' # => true
+      #   _UUID? === nil                                    # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (UUIDType or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _UUID?(**options)
+        _Nilable(_UUID(**options))
+      end
+      alias _Uuid? _UUID?
+
       # Creates a UnionType instance.
       #
       # Allows combining multiple types into a single union type.
@@ -374,6 +523,38 @@ module Domainic
       end
       alias _Either _Union
 
+      # Creates a URIType instance.
+      #
+      # URIType restricts values to valid URIs.
+      #
+      # @example
+      #   type = _URI.having_scheme('https')
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::URIType] the created type
+      # @rbs (**__todo__ options) -> URIType
+      def _Uri(**options)
+        require 'domainic/type/types/network/uri_type'
+        Domainic::Type::URIType.new(**options)
+      end
+      alias _Url _Uri
+
+      # Creates a nilable URIType instance.
+      #
+      # @example
+      #   _Uri?.validate("https://example.com") # => true
+      #   _Uri?.validate(nil)                   # => true
+      #
+      # @param options [Hash] additional configuration options
+      #
+      # @return [Domainic::Type::UnionType] the created type (URIType or NilClass)
+      # @rbs (**__todo__ options) -> UnionType
+      def _Uri?(**options)
+        _Nilable(_Uri(**options))
+      end
+      alias _Url? _Uri?
+
       # Creates a VoidType instance.
       #
       # Represents an operation that returns no value.

data/lib/domainic/type/types/core/array_type.rb

@@ -42,7 +42,7 @@ module Domainic
       include Behavior
       include Behavior::EnumerableBehavior
 
-      intrinsic :self, :type, Array, abort_on_failure: true, description: :not_described
+      intrinsically_constrain :self, :type, Array, abort_on_failure: true, description: :not_described
     end
   end
 end