plumb 0.2.0.beta.1 → 0.2.0.beta.3

data/lib/plumb/composable.rb

@@ -232,8 +232,8 @@ module Plumb
         callable
       elsif callable.respond_to?(:to_composable)
         # The context-free resolution hook for objects that become a type on
-        # demand: an Encoder class resolves to its default (declared)
-        # direction, a Codec class to its instance. Used in schema literals,
+        # demand: an Encoder class resolves to its default (declared) direction; a
+        # Codec raises, having no type to become. Used in schema literals,
         # `Array[Enc]`, `#/`, etc. The composition operators (#>>, #|, #&)
         # consult #to_plumb_type BEFORE wrapping, so a composed operand can
         # resolve against context and never reaches this branch.

data/lib/plumb/hash_class.rb

@@ -453,11 +453,12 @@ module Plumb
     # A filtered Hash is lenient: it accepts ANY hash and drops invalid/missing/
     # extra fields (it never rejects a Hash), so as a #>> consumer it accepts any
     # hash-like value. (Its #input_type still declares the schema it relaxes.)
-    # Memoized at the class level (instances are frozen; Types isn't loaded yet
-    # when this file is).
-    def self.each_pair_interface = @each_pair_interface ||= Types::Interface[:each_pair]
+    def accepted_type = Types::EachPair
 
-    def accepted_type = FilteredHash.each_pair_interface
+    # Re-derived, NOT rebuilt around the old #fn: the filter closes over the schema it
+    # was built from, so Function#with_children returns a node that inspects as the
+    # new schema and still filters by the old one.
+    def with_children(children) = children.first.filtered
 
     # Neither boundary check runs — the per-field validation in HashClass#filtered
     # subsumes both. Overriding #call is also what excludes this node from fusion,

data/lib/plumb/hash_map.rb

@@ -93,11 +93,7 @@ module Plumb
       # entries (it never rejects a Hash), so as a #>> consumer it accepts any
       # hash-like value — not itself. Without this, `Hash >> Hash[K, V].filtered`
       # would be flagged as an illegal narrowing.
-      # Memoized at the class level (instances are frozen; Types isn't loaded
-      # yet when this file is).
-      def self.each_pair_interface = @each_pair_interface ||= Types::Interface[:each_pair]
-
-      def accepted_type = FilteredHashMap.each_pair_interface
+      def accepted_type = Types::EachPair
 
       def call(result)
         result.invalid(errors: 'must be a Hash') unless result.value.is_a?(::Hash)

data/lib/plumb/stream_class.rb

@@ -41,11 +41,7 @@ module Plumb
     # #>> composition check. This lets a producer of a raw Enumerator/Array (eg.
     # a CSV enumerator) feed a Stream. Covariant Stream[X] <= Stream[Y]
     # subtyping is unaffected (that goes through #subtype_of? / #children).
-    # Memoized at the class level (instances are frozen; Types isn't loaded yet
-    # when this file is) — #call hits it on every data invocation.
-    def self.each_interface = @each_interface ||= Types::Interface[:each]
-
-    def input_type = StreamClass.each_interface
+    def input_type = Types::Each
 
     # The [Step] interface
     # @param result [Result]

data/lib/plumb/types.rb

@@ -96,11 +96,16 @@ module Plumb
   # Works with a block too:
   #   date = Type::Any[Date].default { Date.today }
   #
+  # A generated default declares, and is checked against, `type`'s OUTPUT — not `type`
+  # itself, which would re-run a conversion on a value the block already produced
+  # (`Types::String.transform(::Integer).default { 10 }` generates the Integer).
+  # Declaring it also tells the rest of the library what fills this position: without
+  # it the branch resolves to `Any`, and a Codec has nothing to encode.
   policy :default, helper: true do |type, value = Undefined, &block|
     val_type = if value == Undefined
-                 Function.opaque(inspect: 'default proc', identity: [:default, block]) do |result|
-                   result.valid(block.call)
-                 end
+                 fn = ->(result) { result.valid(block.call) }
+                 Function.new(Types::Any, Plumb::Subtyping.resolved_output(type), fn,
+                              inspect: 'default proc', identity: [:default, block])
                else
                  Types::Static[value]
                end
@@ -112,12 +117,20 @@ module Plumb
   # Expect a specific exception class, and return an invalid result if it is raised.
   # Usage:
   #   type = Types::String.build(Date, :parse).policy(:rescue, Date::Error)
+  #
+  # The guard returns what `type` returned, so it declares `type`'s OUTPUT — opaque,
+  # it would erase the type it wraps (the closure is invisible) and resolve to `Any`.
+  # Unchecked: `type` already validated what it produced. The INPUT stays `Any`, or
+  # `type`'s own input check runs a second time, outside the rescue.
   policy :rescue do |type, exception_class|
-    Function.opaque(inspect: 'Rescue', identity: [:rescue, type, exception_class]) do |result|
+    fn = lambda do |result|
       type.call(result)
     rescue exception_class => e
       result.invalid(errors: e.message)
     end
+
+    GuaranteedFunction.new(Types::Any, Plumb::Subtyping.resolved_output(type), fn,
+                           inspect: 'Rescue', identity: [:rescue, type, exception_class])
   end
 
   # Split a string into an array. Default separator is /\s*,\s*/
@@ -168,6 +181,10 @@ module Plumb
     Email = String[URI::MailTo::EMAIL_REGEXP].as_node(:email)
     Date = Any[::Date]
     Time = Any[::Time]
+    # What a lenient container accepts (a Stream, a `.filtered` Array/Hash/HashMap).
+    # Here, not beside those classes, because Types is loaded after all of them.
+    Each = Interface[:each]
+    EachPair = Interface[:each_pair]
 
     # A type that recursively converts string keys to symbols in nested hashes.
     # This is commonly used for normalizing payload data in commands and events.

data/lib/plumb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plumb
-  VERSION = '0.2.0.beta.1'
+  VERSION = '0.2.0.beta.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plumb
 version: !ruby/object:Gem::Version
-  version: 0.2.0.beta.1
+  version: 0.2.0.beta.3
 platform: ruby
 authors:
 - Ismael Celis