In docs, define types module before (re)opening it

Author: timriley

docsite/source/array-with-member.html.md

@@ -7,6 +7,8 @@ name: dry-types
 The built-in array type supports defining the member's type:
 
 ``` ruby
+Types = Dry.Types()
+
 PostStatuses = Types::Array.of(Types::Coercible::String)
 
 PostStatuses[[:foo, :bar]] # ["foo", "bar"]

docsite/source/built-in-types.html.md

@@ -15,7 +15,7 @@ Built-in types are grouped under 6 categories:
 
 ### Categories
 
-Assuming you included `Dry::Types` ([see instructions](docs::getting-started)) in a module called `Types`:
+Assuming you've defined your own `Types` module ([see instructions](docs::getting-started)):
 
 * Nominal types:
   - `Types::Nominal::Any`

docsite/source/constraints.html.md

@@ -11,6 +11,8 @@ All types support the constraints API, but not all constraints are suitable for
 Under the hood it uses [`dry-logic`](/gems/dry-logic) and all of its predicates are supported.
 
 ``` ruby
+Types = Dry.Types()
+
 string = Types::String.constrained(min_size: 3)
 
 string['foo']

docsite/source/custom-types.html.md

@@ -11,6 +11,8 @@ There are a bunch of helpers for building your own types based on existing class
 `Types.Instance` builds a type that checks if a value has the given class.
 
 ```ruby
+Types = Dry.Types()
+
 range_type = Types.Instance(Range)
 range_type[1..2] # => 1..2
 ```
@@ -20,6 +22,8 @@ range_type[1..2] # => 1..2
 `Types.Value` builds a type that checks a value for equality (using `==`).
 
 ```ruby
+Types = Dry.Types()
+
 valid = Types.Value('valid')
 valid['valid'] # => 'valid'
 valid['invalid']
@@ -31,6 +35,8 @@ valid['invalid']
 `Types.Constant` builds a type that checks a value for identity (using `equal?`).
 
 ```ruby
+Types = Dry.Types()
+
 valid = Types.Constant(:valid)
 valid[:valid] # => :valid
 valid[:invalid]
@@ -42,6 +48,8 @@ valid[:invalid]
 `Types.Constructor` builds a new constructor type for the given class. By default uses the `new` method as a constructor.
 
 ```ruby
+Types = Dry.Types()
+
 user_type = Types.Constructor(User)
 
 # It is equivalent to User.new(name: 'John')
@@ -59,6 +67,8 @@ user_type = Types.Constructor(User) { |values| User.new(values) }
 `Types.Nominal` wraps the given class with a simple definition without any behavior attached.
 
 ```ruby
+Types = Dry.Types()
+
 int = Types.Nominal(Integer)
 int[1] # => 1
 
@@ -71,6 +81,8 @@ int['one'] # => 'one'
 `Types.Hash` builds a new hash schema.
 
 ```ruby
+Types = Dry.Types()
+
 # In the full form
 Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
 
@@ -83,6 +95,8 @@ Types.Hash(name: Types::String, age: Types::Coercible::Integer)
 `Types.Array` is a shortcut for `Types::Array.of`
 
 ```ruby
+Types = Dry.Types()
+
 ListOfStrings = Types.Array(Types::String)
 ```
 
@@ -91,6 +105,8 @@ ListOfStrings = Types.Array(Types::String)
 `Types.Interface` builds a type that checks a value responds to given methods.
 
 ```ruby
+Types = Dry.Types()
+
 Callable = Types.Interface(:call)
 Contact = Types.Interface(:name, :phone)
-```
+```

docsite/source/default-values.html.md

@@ -7,6 +7,8 @@ name: dry-types
 A type with a default value will return the configured value when the input is not defined:
 
 ``` ruby
+Types = Dry.Types()
+
 PostStatus = Types::String.default('draft')
 
 PostStatus[] # "draft"

docsite/source/enum.html.md

@@ -10,9 +10,7 @@ In many cases you may want to define an enum. For example, in a blog application
 require 'dry-types'
 require 'dry-struct'
 
-module Types
-  include Dry.Types()
-end
+Types = Dry.Types()
 
 class Post < Dry::Struct
   Statuses = Types::String.enum('draft', 'published', 'archived')
@@ -42,10 +40,10 @@ Note that if you want to define an enum type with a default, you must call `.def
 
 ```ruby
 # this is the correct usage:
-Dry::Types::String.default('red').enum('blue', 'green', 'red')
+Types::String.default('red').enum('blue', 'green', 'red')
 
 # this will raise an error:
-Dry::Types::String.enum('blue', 'green', 'red').default('red')
+Types::String.enum('blue', 'green', 'red').default('red')
 ```
 
 ### Mappings

docsite/source/extensions/maybe.html.md

@@ -13,9 +13,8 @@ The [dry-monads gem](/gems/dry-monads/) provides approach to handling optional v
 require 'dry-types'
 
 Dry::Types.load_extensions(:maybe)
-module Types
-  include Dry.Types()
-end
+
+Types = Dry.Types()
 ```
 
 2. Append `.maybe` to a _Type_ to return a _Monad_ object  

docsite/source/getting-started.html.md

@@ -6,15 +6,13 @@ name: dry-types
 
 ### Using `Dry::Types` in Your Application
 
-1. Make `Dry::Types` available to the application by creating a namespace that includes `Dry::Types`:
+1. Make the base types available to your application by defining your own module built from `Dry.Types()`:
 
     ```ruby
-    module Types
-     include Dry.Types()
-    end
+    Types = Dry.Types()
     ```
-   
-2. Reload the environment, & type `Types::Coercible::String` in the ruby console to confirm it worked:
+
+2. Reload the environment, & enter `Types::Coercible::String` in your ruby console to confirm it worked:
 
     ``` ruby
     Types::Coercible::String
@@ -31,15 +29,16 @@ name: dry-types
     end
     ```
 
-2. Define [Custom Types](docs::custom-types) in the `Types` module, then pass the name & type to `attribute`:
+2. Define [Custom Types](docs::custom-types) in your types module, then pass the name & type to `attribute`:
 
     ```ruby
+    Types = Dry.Types()
+
     module Types
-      include Dry.Types()
-    
       Email = String.constrained(format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i)
       Age = Integer.constrained(gt: 18)
     end
+
     class User < Dry::Struct
       attribute :name, Types::String
       attribute :email, Types::Email

docsite/source/hash-schemas.html.md

@@ -7,6 +7,8 @@ name: dry-types
 It is possible to define a type for a hash with a known set of keys and corresponding value types. Let's say you want to describe a hash containing the name and the age of a user:
 
 ```ruby
+Types = Dry.Types()
+
 # using simple kernel coercions
 user_hash = Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
 
@@ -78,6 +80,8 @@ The process of converting types to constructors like that can be automated, see
 By default, all keys are required to present in the input. You can mark a key as optional by adding `?` to its name:
 
 ```ruby
+Types = Dry.Types()
+
 user_hash = Types::Hash.schema(name: Types::String, age?: Types::Integer)
 
 user_hash[name: 'Jane']
@@ -89,6 +93,8 @@ user_hash[name: 'Jane']
 All keys not declared in the schema are silently ignored. This behavior can be changed by calling `.strict` on the schema:
 
 ```ruby
+Types = Dry.Types()
+
 user_hash = Types::Hash.schema(name: Types::String).strict
 user_hash[name: 'Jane', age: 21]
 # => Dry::Types::UnknownKeysError: unexpected keys [:age] in Hash input
@@ -99,6 +105,8 @@ user_hash[name: 'Jane', age: 21]
 Keys are supposed to be symbols but you can attach a key tranformation to a schema, e.g. for converting strings into symbols:
 
 ```ruby
+Types = Dry.Types()
+
 user_hash = Types::Hash.schema(name: Types::String).with_key_transform(&:to_sym)
 user_hash['name' => 'Jane']
 
@@ -110,6 +118,8 @@ user_hash['name' => 'Jane']
 Hash schemas can be inherited in a sense you can define a new schema based on an existing one. Declared keys will be merged, key and type transformations will be preserved. The `strict` option is also passed to the new schema if present.
 
 ```ruby
+Types = Dry.Types()
+
 # Building an empty base schema
 StrictSymbolizingHash = Types::Hash.schema({}).strict.with_key_transform(&:to_sym)
 
@@ -131,6 +141,8 @@ The resulting schema will have the sum of both sets
 of attributes.
 
 ```ruby
+Types = Dry.Types()
+
 user_hash = Types::Hash.schema(
   name: Types::String
 )
@@ -153,6 +165,8 @@ while each attribute keeps the type transformations from its original hash.
 A schema can transform types with a block. For example, the following code makes all keys optional:
 
 ```ruby
+Types = Dry.Types()
+
 user_hash = Types::Hash.with_type_transform { |type| type.required(false) }.schema(
   name: Types::String,
   age: Types::Integer

docsite/source/index.html.md

@@ -28,9 +28,7 @@ sections:
 require 'dry-types'
 require 'dry-struct'
 
-module Types
-  include Dry.Types()
-end
+Types = Dry.Types()
 
 User = Dry.Struct(name: Types::String, age: Types::Integer)
 
@@ -111,7 +109,7 @@ User.schema.key(:age).meta
 # => {:info=>"extra info about age"}
 ```
 
-- Pass values directly to `Dry::Types` without creating an object using `[]`:
+- Pass values directly to types without creating an object using `[]`:
 
 ```ruby
 Types::Strict::String["foo"]