 extension Node {
+    /**
+        Transform and validate a node
+
+        - parameter suite: suite to validate with
+
+        - throws: an error if one occurs
+
+        - returns: a validated object
+    */
     public func validated<
         T: ValidationSuite
         where T.InputType: NodeInitializable>(by suite: T.Type = T.self)

            let value = try V.InputType.make(with: wrapped)
            return try value.validated(by: suite)
    }
}

extension Optional: Extractable {
    public func extract() -> Wrapped? {
        return self
    }

            let value = try T.InputType.make(with: self)
            return try value.validated(by: suite)
    }

    /**
        Transform and validate a node

        - parameter validator: validator to validate with

        - throws: an error if one occurs

        - returns: a validated object
    */
    public func validated<
        T: Validator
        where T.InputType: NodeInitializable>(by validator: T)
        throws -> Valid<T> {
            let value = try T.InputType.make(with: self)
            return try value.validated(by: validator)
    }
}

/**
    We can't generically extend optionals based on their contents being protocols concretely,
    ie: where Wrapped == SomeProtocol
 
    This allows us to do so because extending protocol can use concrete generic constraints
*/
public protocol Extractable {

    /**
        The underlying type
    */
    associatedtype Wrapped

    /**
        Access the underlying value

        - returns: the underlying value if exists
    */
    func extract() -> Wrapped?
}

extension Extractable where Wrapped == Node {

    /**
        transform and validate an extractable encapsulating a node.

        - parameter suite: suite to validate with

        - throws: an error if one occurs

        - returns: a validated object
     */
    public func validated<
        V: ValidationSuite
        where V.InputType: NodeInitializable>(by suite: V.Type = V.self)
