plumb 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db1a6e5f70bf36e91d053ff465e9f566cd4371e4620dac88aea6f028918311a8
-  data.tar.gz: 13e986c5a7815c3ecbdf6f1f6cabb4d9341b88421d8048a7e7182d9b638e1632
+  metadata.gz: 2f8b93e98170481b05c028f2ffa16c3f52cb57347efb373671cf4fbd915ca153
+  data.tar.gz: 89ae563b7e75ee76c2672f195ef94553123e41a6fffebc6835033f6401c7506a
 SHA512:
-  metadata.gz: 540cb16d4ab114931dad7b278578428357341e5318f5371a40d22b6d53714fe71290cb66892725316faf2060e5a1ca8e4c318951e9dc8eeb7839eac2a38d4800
-  data.tar.gz: 6404ab512cb061af57be9d7b3e41dfb967e3e651819f4fb540a6e018f55a5ab18a976649fe891338181f7e769b9efb0a29df1e8dd0586471b14ea0b7b04a511d
+  metadata.gz: acaa62117892affe3eb921f76ade115f21f0dda711492a3ce9265f1ad859bf25b4dfecc1e9f920058d716b54d4ae1389c06b2d716ef9eac49d977eb4638d1db7
+  data.tar.gz: 200dc5ba480ddf4fedee46afa7c5b8e5c6191b8c796cb31df4b246841826aac9d8df181be2c3b5c90b53739fa791c3dc6c2b3d014a6822db74121f81873fa145

data/README.md

@@ -39,6 +39,52 @@ result.valid? # false
 result.errors # ""
 ```
 
+### Specialize your types with `#[]`
+
+Use `#[]` to make your types match a class.
+
+```ruby
+module Types
+  include Plumb::Types
+  
+  String = Types::Any[::String]
+  Integer = Types::Any[::Integer]
+end
+
+Types::String.parse("hello") # => "hello"
+Types::String.parse(10) # raises "Must be a String" (Plumb::TypeError)
+```
+
+Plumb ships with basic types already defined, such as `Types::String` and `Types::Integer`. See the full list below.
+
+The `#[]` method is not just for classes. It works with anything that responds to `#===`
+
+```ruby
+# Match against a regex
+Email = Types::String[/@/] # ie Types::Any[String][/@/]
+
+Email.parse('hello') # fails
+Email.parse('hello@server.com') # 'hello@server.com'
+
+# Or a Range
+AdultAge = Types::Integer[18..]
+AdultAge.parse(20) # 20
+AdultAge.parse(17) # raises "Must be within 18.."" (Plumb::TypeError)
+
+# Or literal values
+Twenty = Types::Integer[20]
+Twenty.parse(20) # 20
+Twenty.parse(21) # type error
+```
+
+It can be combined with other methods. For example to cast strings as integers, but only if they _look_ like integers.
+
+```ruby
+StringToInt = Types::String[/^\d+$/].transform(::Integer, &:to_i)
+
+StringToInt.parse('100') # => 100
+StringToInt.parse('100lol') # fails
+```
 
 ### `#resolve(value) => Result`
 
@@ -55,8 +101,6 @@ result.value # '10'
 result.errors # 'must be an Integer'
 ```
 
-
-
 ### `#parse(value) => value`
 
 `#parse` takes an input value and returns the parsed/coerced value if successful. or it raises an exception if failed.
@@ -68,6 +112,80 @@ Types::Integer.parse('10') # raises Plumb::TypeError
 
 
 
+### Composite types
+
+Some built-in types such as `Types::Array` and `Types::Hash` allow defininig array or hash data structures composed of other types.
+
+```ruby
+# A user hash
+User = Types::Hash[name: Types::String, email: Email, age: AdultAge]
+
+# An array of User hashes
+Users = Types::Array[User]
+
+joe = User.parse({ name: 'Joe', email: 'joe@email.com', age: 20}) # returns valid hash
+Users.parse([joe]) # returns valid array of user hashes
+```
+
+More about [Types::Array](#typeshash) and [Types::Array](#typesarray). There's also tuples and hash maps, and it's possible to create your own composite types.
+
+## Type composition
+
+At the core, Plumb types are little [Railway-oriented pipelines](https://ismaelcelis.com/posts/composable-pipelines-in-ruby/) that can be composed together with _and_, _or_ and _not_ semantics. Everything else builds on top of these two ideas.
+
+### Composing types with `#>>` ("And")
+
+```ruby
+Email = Types::String[/@/]
+# You can compose procs and lambdas, or other types.
+Greeting = Email >> ->(result) { result.valid("Your email is #{result.value}") }
+
+Greeting.parse('joe@bloggs.com') # "Your email is joe@bloggs.com"
+```
+
+### Disjunction with `#|` ("Or")
+
+```ruby
+StringOrInt = Types::String | Types::Integer
+StringOrInt.parse('hello') # "hello"
+StringOrInt.parse(10) # 10
+StringOrInt.parse({}) # raises Plumb::TypeError
+```
+
+Custom default value logic for non-emails
+
+```ruby
+EmailOrDefault = Greeting | Types::Static['no email']
+EmailOrDefault.parse('joe@bloggs.com') # "Your email is joe@bloggs.com"
+EmailOrDefault.parse('nope') # "no email"
+```
+
+## Composing with `#>>` and `#|`
+
+This more elaborate example defines a combination of types which, when composed together with `>>` and `|`, can coerce strings or integers into Money instances with currency.
+
+```ruby
+require 'money'
+
+module Types
+  include Plumb::Types
+  
+  Money = Any[::Money]
+  IntToMoney = Integer.transform(::Money) { |v| ::Money.new(v, 'USD') }
+  StringToInt = String.match(/^\d+$/).transform(::Integer, &:to_i)
+  USD = Money.check { |amount| amount.currency.code == 'UDS' }
+  ToUSD = Money.transform(::Money) { |amount| amount.exchange_to('USD') }
+  
+  FlexibleUSD = (Money | ((Integer | StringToInt) >> IntToMoney)) >> (USD | ToUSD)
+end
+
+FlexibleUSD.parse('1000') # Money(USD 10.00)
+FlexibleUSD.parse(1000) # Money(USD 10.00)
+FlexibleUSD.parse(Money.new(1000, 'GBP')) # Money(USD 15.00)
+```
+
+You can see more use cases in [the examples directory](/ismasan/plumb/tree/main/examples)
+
 ## Built-in types
 
 * `Types::Value`
@@ -79,12 +197,10 @@ Types::Integer.parse('10') # raises Plumb::TypeError
 * `Types::False`
 * `Types::Tuple`
 * `Types::Split`
-* `Types::Blank`
 * `Types::Any`
 * `Types::Static`
 * `Types::Undefined`
 * `Types::Nil`
-* `Types::Present`
 * `Types::Integer`
 * `Types::Numeric`
 * `Types::String`
@@ -99,6 +215,10 @@ Types::Integer.parse('10') # raises Plumb::TypeError
 
 
 
+### Policies
+
+Policies are methods that encapsulate common compositions. Plumb ships with some, listed below, and you can also define your own.
+
 ### `#present`
 
 Checks that the value is not blank (`""` if string, `[]` if array, `{}` if Hash, or `nil`)
@@ -119,14 +239,12 @@ nullable_str.parse('hello') # 'hello'
 nullable_str.parse(10) # TypeError
 ```
 
-Note that this is syntax sugar for 
+Note that this just encapsulates the following composition:
 
 ```ruby
 nullable_str = Types::String | Types::Nil
 ```
 
-
-
 ### `#not`
 
 Negates a type. 
@@ -155,8 +273,6 @@ type.resolve(['a', 'a', 'b']) # Valid
 type.resolve(['a', 'x', 'b']) # Failure
 ```
 
-
-
 ### `#transform`
 
 Transform value. Requires specifying the resulting type of the value after transformation.
@@ -240,45 +356,6 @@ Same if you want to apply a default to several cases.
 str = Types::String | ((Types::Nil | Types::Undefined) >> Types::Static['nope'.freeze])
 ```
 
-
-
-### `#match` and `#[]`
-
-Checks the value against a regular expression (or anything that responds to `#===`).
-
-```ruby
-email = Types::String.match(/@/)
-# Same as
-email = Types::String[/@/]
-email.parse('hello') # fails
-email.parse('hello@server.com') # 'hello@server.com'
-```
-
-It can be combined with other methods. For example to cast strings as integers, but only if they _look_ like integers.
-
-```ruby
-StringToInt = Types::String[/^\d+$/].transform(::Integer, &:to_i)
-
-StringToInt.parse('100') # => 100
-StringToInt.parse('100lol') # fails
-```
-
-It can be used with other `#===` interfaces.
-
-```ruby
-AgeBracket = Types::Integer[21..45]
-
-AgeBracket.parse(22) # 22
-AgeBracket.parse(20) # fails
-
-# With literal values
-Twenty = Types::Integer[20]
-Twenty.parse(20) # 20
-Twenty.parse(21) # type error
-```
-
-
-
 ### `#build`
 
 Build a custom object or class.
@@ -312,8 +389,6 @@ Note that this case is identical to `#transform` with a block.
 StringToMoney = Types::String.transform(Money) { |value| Monetize.parse(value) }
 ```
 
-
-
 ### `#check`
 
 Pass the value through an arbitrary validation
@@ -343,8 +418,6 @@ All scalar types support this:
 ten = Types::Integer.value(10)
 ```
 
-
-
 ### `#meta` and `#metadata`
 
 Add metadata to a type
@@ -373,7 +446,60 @@ Types::String.transform(Integer, &:to_i).metadata[:type] # Integer
 
 TODO: document custom visitors.
 
-## `Types::Hash`
+### Other policies
+
+There's some other built-in "policies" that can be used via the `#policy` method. Helpers such as `#default` and `#present` are shortcuts for this and can also be used via `#policy(default: 'Hello')` or `#policy(:present)` See [custom policies](#custom-policies) for how to define your own policies.
+
+#### `:respond_to`
+
+Similar to `Types::Interface`, this is a quick way to assert that a value supports one or more methods.
+
+```ruby
+List = Types::Any.policy(respond_to: :each)
+# or
+List = Types::Any.policy(respond_to: [:each, :[], :size)
+```
+
+#### `:excluded_from`
+
+The opposite of `#options`, this policy validates that the value _is not_ included in a list.
+
+```ruby
+Name = Types::String.policy(excluded_from: ['Joe', 'Joan'])
+```
+
+#### `:size`
+
+Works for any value that responds to `#size` and validates that the value's size matches the argument.
+
+```ruby
+LimitedArray = Types::Array[String].policy(size: 10)
+LimitedString = Types::String.policy(size: 10)
+LimitedSet = Types::Any[Set].policy(size: 10)
+```
+
+The size is matched via `#===`, so ranges also work.
+
+```ruby
+Password = Types::String.policy(size: 10..20)
+```
+
+#### `:split` (strings only)
+
+Splits string values by a separator (default: `,`).
+
+```ruby
+CSVLine = Types::String.split
+CSVLine.parse('a,b,c') # => ['a', 'b', 'c']
+
+# Or, with custom separator
+CSVLine = Types::String.split(/\s*;\s*/)
+CSVLine.parse('a;b;c') # => ['a', 'b', 'c']
+```
+
+
+
+### `Types::Hash`
 
 ```ruby
 Employee = Types::Hash[
@@ -466,8 +592,6 @@ Types::Hash[
 ]
 ```
 
-
-
 #### Merging hash definitions
 
 Use `Types::Hash#+` to merge two definitions. Keys in the second hash override the first one's.
@@ -478,8 +602,6 @@ Employee = Types::Hash[name: Types::String, company: Types::String]
 StaffMember = User + Employee # Hash[:name, :age, :company]
 ```
 
-
-
 #### Hash intersections
 
 Use `Types::Hash#&` to produce a new Hash definition with keys present in both.
@@ -488,8 +610,6 @@ Use `Types::Hash#&` to produce a new Hash definition with keys present in both.
 intersection = User & Employee # Hash[:name]
 ```
 
-
-
 #### `Types::Hash#tagged_by`
 
 Use `#tagged_by` to resolve what definition to use based on the value of a common key.
@@ -509,8 +629,6 @@ Events = Types::Hash.tagged_by(
 Events.parse(type: 'name_updated', name: 'Joe') # Uses NameUpdatedEvent definition
 ```
 
-
-
 #### `Types::Hash#inclusive`
 
 Use `#inclusive` to preserve input keys not defined in the hash schema.
@@ -551,8 +669,6 @@ User.parse(name: 'Joe', age: 40) # => { name: 'Joe', age: 40 }
 User.parse(name: 'Joe', age: 'nope') # => { name: 'Joe' }
 ```
 
-
-
 ### Hash maps
 
 You can also use Hash syntax to define a hash map with specific types for all keys and values:
@@ -747,57 +863,6 @@ TODO
 
 TODO
 
-## Composing types with `#>>` ("And")
-
-```ruby
-Email = Types::String.match(/@/)
-Greeting = Email >> ->(result) { result.valid("Your email is #{result.value}") }
-
-Greeting.parse('joe@bloggs.com') # "Your email is joe@bloggs.com"
-```
-
-
-## Disjunction with `#|` ("Or")
-
-```ruby
-StringOrInt = Types::String | Types::Integer
-StringOrInt.parse('hello') # "hello"
-StringOrInt.parse(10) # 10
-StringOrInt.parse({}) # raises Plumb::TypeError
-```
-
-Custom default value logic for non-emails
-
-```ruby
-EmailOrDefault = Greeting | Types::Static['no email']
-EmailOrDefault.parse('joe@bloggs.com') # "Your email is joe@bloggs.com"
-EmailOrDefault.parse('nope') # "no email"
-```
-
-## Composing with `#>>` and `#|`
-
-```ruby
-require 'money'
-
-module Types
-  include Plumb::Types
-  
-  Money = Any[::Money]
-  IntToMoney = Integer.transform(::Money) { |v| ::Money.new(v, 'USD') }
-  StringToInt = String.match(/^\d+$/).transform(::Integer, &:to_i)
-  USD = Money.check { |amount| amount.currency.code == 'UDS' }
-  ToUSD = Money.transform(::Money) { |amount| amount.exchange_to('USD') }
-  
-  FlexibleUSD = (Money | ((Integer | StringToInt) >> IntToMoney)) >> (USD | ToUSD)
-end
-
-FlexibleUSD.parse('1000') # Money(USD 10.00)
-FlexibleUSD.parse(1000) # Money(USD 10.00)
-FlexibleUSD.parse(Money.new(1000, 'GBP')) # Money(USD 15.00)
-```
-
-
-
 ### Recursive types
 
 You can use a proc to defer evaluation of recursive definitions.
@@ -831,10 +896,6 @@ LinkedList = Types::Hash[
 
 
 
-### Type-specific Rules
-
-TODO
-
 ### Custom types
 
 Compose procs or lambdas directly
@@ -859,8 +920,99 @@ end
 MyType = Types::String >> Greeting.new('Hola')
 ```
 
-You can return `result.invalid(errors: "this is invalid")` to halt processing.
+### Custom policies
+
+`Plumb.policy` can be used to encapsulate common type compositions, or compositions that can be configurable by parameters.
+
+This example defines a `:default_if_nil` policy that returns a default if the value is `nil`.
+
+```ruby
+Plumb.policy :default_if_nil do |type, default_value|
+  type | (Types::Nil >> Types::Static[default_value])
+end
+```
+
+It can be used for any of your own types.
+
+```ruby
+StringWithDefault = Types::String.policy(default_if_nil: 'nothing here')
+StringWithDefault.parse('hello') # 'hello'
+StringWithDefault.parse(nil) # 'nothing here'
+```
+
+The `#policy` helper supports applying multiply policies.
+
+```ruby
+Types::String.policy(default_if_nil: 'nothing here', size: (10..20))
+```
+
+
+
+#### Policies as helper methods
+
+Use the `helper: true` option to register the policy as a method you can call on types directly.
+
+```ruby
+Plumb.policy :default_if_nil, helper: true do |type, default_value|
+  type | (Types::Nil >> Types::Static[default_value])
+end
+
+# Now use #default_if_nil directly
+StringWithDefault = Types::String.default_if_nil('nothing here')
+```
+
+Many built-in helpers such as `#default` and `#options` are implemented as policies. This means that you can overwrite their default behaviour by defining a policy with the same name (use with caution!).
+
+#### Type-specific policies
+
+You can use the `for_type:` option to define policies that only apply to steps that output certain types. This example only applies for types that return `Integer` values.
+
+```ruby
+Plumb.policy :multiply_by, for_type: Integer, helper: true do |type, factor|
+  type.invoke(:*, factor)
+end
+
+Doubled = Types::Integer.multiply_by(2)
+Doubled.parse(2) # 4
+
+# Tryin to apply this policy to a non Integer will raise an exception
+DoubledString = Types::String.multiply_by(2) # raises error
+```
+
+#### Interface-specific policies
+
+`for_type`also supports a Symbol for a method name, so that the policy can be applied to any types that support that method.
+
+This example allows the `multiply_by` policy to work with any type that can be multiplied (by supporting the `:*` method).
+
+```ruby
+Plumb.policy :multiply_by, for_type: :*, helper: true do |type, factor|
+  type.invoke(:*, factor)
+end
+
+# Now it works with anything that can be multiplied.
+DoubledNumeric = Types::Numeric.multiply_by(2)
+DoubledMoney = Types::Any[Money].multiply_by(2)
+```
+
+#### Self-contained policy modules
+
+You can register a module, class or module with a three-method interface as a policy. This is so that policies can have their own namespace if they need local constants or private methods. For example, this is how the `:split` policy for strings is defined.
 
+```ruby
+module SplitPolicy
+  DEFAULT_SEPARATOR = /\s*,\s*/
+
+  def self.call(type, separator = DEFAULT_SEPARATOR)
+    type.transform(Array) { |v| v.split(separator) }
+  end
+
+  def self.for_type = ::String
+  def self.helper = false
+end
+
+Plumb.policy :split, SplitPolicy
+```
 
 ### JSON Schema
 
@@ -883,6 +1035,22 @@ json_schema = Plumb::JSONSchemaVisitor.call(User)
 }
 ```
 
+The built-in JSON Schema generator handles most standard types and compositions. You can add or override handles on a per-type basis with:
+
+```ruby
+Plumb::JSONSchemaVisitor.on(:not) do |node, props|
+  props.merge('not' => visit(node.step))
+end
+
+# Example
+type = Types::Decimal.not
+schema = Plumb::JSONSchemaVisitor.visit(type) # { 'not' => { 'type' => 'number' } }
+```
+
+#### JSON Schema handlers for custom policies
+
+TODO. See `Plumb::JSONSchemaVisitor`.
+
 
 
 ## Development

data/examples/env_config.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'plumb'
+require 'debug'
+
+# Types and pipelines for defining and parsing ENV configuration
+# Run with `bundle exec ruby examples/env_config.rb`
+#
+# Given an ENV with variables to configure one of three types of network/IO clients,
+# parse, validate and coerce the configuration into the appropriate client object.
+# ENV vars are expected to be prefixed with `FILE_UPLOAD_`, followed by the client type.
+# See example usage at the bottom of this file.
+module Types
+  include Plumb::Types
+
+  # Define a custom policy to extract a string using a regular expression.
+  # Policies are factories for custom type compositions.
+  #
+  # Usage:
+  #   type = Types::String.extract(/^FOO_(\w+)$/).invoke(:[], 1)
+  #   type.parse('FOO_BAR') # => 'BAR'
+  #
+  Plumb.policy :extract, for_type: ::String, helper: true do |type, regex|
+    type >> lambda do |result|
+      match = result.value.match(regex)
+      return result.invalid(errors: "does not match #{regex.source}") if match.nil?
+      return result.invalid(errors: 'no captures') if match.captures.none?
+
+      result.valid(match)
+    end
+  end
+
+  # A dummy S3 client
+  S3Client = Data.define(:bucket, :region)
+
+  # A dummy SFTP client
+  SFTPClient = Data.define(:host, :username, :password)
+
+  # Map these fields to an S3 client
+  S3Config = Types::Hash[
+    transport: 's3',
+    bucket: String.present,
+    region: String.options(%w[us-west-1 us-west-2 us-east-1])
+  ].invoke(:except, :transport).build(S3Client) { |h| S3Client.new(**h) }
+
+  # Map these fields to an SFTP client
+  SFTPConfig = Types::Hash[
+    transport: 'sftp',
+    host: String.present,
+    username: String.present,
+    password: String.present,
+  ].invoke(:except, :transport).build(SFTPClient) { |h| SFTPClient.new(**h) }
+
+  # Map these fields to a File client
+  FileConfig = Types::Hash[
+    transport: 'file',
+    path: String.present,
+  ].invoke(:[], :path).build(::File)
+
+  # Take a string such as 'FILE_UPLOAD_BUCKET', extract the `BUCKET` bit,
+  # downcase and symbolize it.
+  FileUploadKey = String.extract(/^FILE_UPLOAD_(\w+)$/).invoke(:[], 1).invoke(%i[downcase to_sym])
+
+  # Filter a Hash (or ENV) to keys that match the FILE_UPLOAD_* pattern
+  FileUploadHash = Types::Hash[FileUploadKey, Any].filtered
+
+  # Pipeline syntax to put the program together
+  FileUploadClientFromENV = Any.pipeline do |pl|
+    # 1. Accept any Hash-like object (e.g. ENV)
+    pl.step Types::Interface[:[], :key?, :each, :to_h]
+
+    # 2. Transform it to a Hash
+    pl.step Any.transform(::Hash, &:to_h)
+
+    # 3. Filter keys with FILE_UPLOAD_* prefix
+    pl.step FileUploadHash
+
+    # 4. Parse the configuration for a particular client object
+    pl.step(S3Config | SFTPConfig | FileConfig)
+  end
+
+  # Ex.
+  # client = FileUploadClientFromENV.parse(ENV) # SFTP, S3 or File client
+
+  # The above is the same as:
+  #
+  # FileUploadClientFromENV = Types::Interface[:[], :key?, :each, :to_h] \
+  #                           .transform(::Hash, &:to_h) >> \
+  #                           Types::Hash[FileUploadKey, Any].filtered >> \
+  #                           (S3Config | SFTPConfig | FileConfig)
+end
+
+# Simulated ENV hashes. Just use ::ENV for the real thing.
+ENV_S3 = {
+  'FILE_UPLOAD_TRANSPORT' => 's3',
+  'FILE_UPLOAD_BUCKET' => 'my-bucket',
+  'FILE_UPLOAD_REGION' => 'us-west-2',
+  'SOMETHING_ELSE' => 'ignored'
+}.freeze
+# => S3Client.new(bucket: 'my-bucket', region: 'us-west-2')
+
+ENV_SFTP = {
+  'FILE_UPLOAD_TRANSPORT' => 'sftp',
+  'FILE_UPLOAD_HOST' => 'sftp.example.com',
+  'FILE_UPLOAD_USERNAME' => 'username',
+  'FILE_UPLOAD_PASSWORD' => 'password',
+  'SOMETHING_ELSE' => 'ignored'
+}.freeze
+# => SFTPClient.new(host: 'sftp.example.com', username: 'username', password: 'password')
+
+ENV_FILE = {
+  'FILE_UPLOAD_TRANSPORT' => 'file',
+  'FILE_UPLOAD_PATH' => File.join('examples', 'programmers.csv')
+}.freeze
+
+p Types::FileUploadClientFromENV.parse(ENV_S3) # #<data Types::S3Client bucket="my-bucket", region="us-west-2">
+p Types::FileUploadClientFromENV.parse(ENV_SFTP) # #<data Types::SFTPClient host="sftp.example.com", username="username", password="password">
+p Types::FileUploadClientFromENV.parse(ENV_FILE) # #<File path="examples/programmers.csv">
+
+# Or with invalid or missing configuration
+# p Types::FileUploadClientFromENV.parse({}) # raises error

data/examples/weekdays.rb

@@ -41,7 +41,7 @@ module Types
   # Ex. [1, 2, 3, 4, 5, 6, 7], [1, 2, 4], ['monday', 'tuesday', 'wednesday', 7]
   # Turn day names into numbers, and sort the array.
   Week = Array[DayNameOrNumber]
-         .rule(size: 1..7)
+         .policy(size: 1..7)
          .check('repeated days') { |days| days.uniq.size == days.size }
          .transform(::Array, &:sort)
 end

data/lib/plumb/hash_class.rb

@@ -30,9 +30,7 @@ module Plumb
       case args
       in [::Hash => hash]
         self.class.new(schema: _schema.merge(wrap_keys_and_values(hash)), inclusive: @inclusive)
-      in [Steppable => key_type, value_type]
-        HashMap.new(key_type, Steppable.wrap(value_type))
-      in [Class => key_type, value_type]
+      in [key_type, value_type]
         HashMap.new(Steppable.wrap(key_type), Steppable.wrap(value_type))
       else
         raise ::ArgumentError, "unexpected value to Types::Hash#schema #{args.inspect}"