             let value = try T.InputType.make(with: self)
             return try value.validated(by: suite)
     }
-}
-
-// TODO:
-/*
-    var array: [Node]? { get }
-    var object: [String : Node]? { get }
-    var json: Json? { get }
+
+    /**
+        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)

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

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

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)
