more source docs, deprecated some Where clause utilities

Sources/From+Querying.swift

@@ -217,17 +217,37 @@ public extension From {
 
 public extension From where D: NSManagedObject {
     
+    /**
+     Creates a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     
+     - parameter keyPath: the keyPath to query the value for
+     - returns: a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     */
     public func select<R>(_ keyPath: KeyPath<D, R>) -> QueryChainBuilder<D, R> {
         
         return self.select(R.self, [SelectTerm<D>.attribute(keyPath)])
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections
+     
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, T>) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionBy(sectionKeyPath._kvcKeyPathString!, { $0 })
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections, and a closure to transform the value for the key path to an appropriate section name
+     
+     - Important: Some utilities (such as `ListMonitor`s) may keep `SectionBy`s in memory and may thus introduce retain cycles if reference captures are not handled properly.
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - parameter sectionIndexTransformer: a closure to transform the value for the key path to an appropriate section name
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, T>, _ sectionIndexTransformer: @escaping (_ sectionName: String?) -> String?) -> SectionMonitorChainBuilder<D> {
         
@@ -237,73 +257,159 @@ public extension From where D: NSManagedObject {
 
 public extension From where D: CoreStoreObject {
     
+    /**
+     Creates a `FetchChainBuilder` that starts with the specified `Where` clause
+     
+     - parameter clause: a closure that returns a `Where` clause
+     - returns: a `FetchChainBuilder` that starts with the specified `Where` clause
+     */
     public func `where`<T: AnyWhereClause>(_ clause: (D) -> T) -> FetchChainBuilder<D> {
         
         return self.fetchChain(appending: clause(D.meta))
     }
     
+    /**
+     Creates a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     
+     - parameter keyPath: the keyPath to query the value for
+     - returns: a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     */
     public func select<R>(_ keyPath: KeyPath<D, ValueContainer<D>.Required<R>>) -> QueryChainBuilder<D, R> {
         
         return self.select(R.self, [SelectTerm<D>.attribute(keyPath)])
     }
     
+    /**
+     Creates a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     
+     - parameter keyPath: the keyPath to query the value for
+     - returns: a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     */
     public func select<R>(_ keyPath: KeyPath<D, ValueContainer<D>.Optional<R>>) -> QueryChainBuilder<D, R> {
         
         return self.select(R.self, [SelectTerm<D>.attribute(keyPath)])
     }
     
+    /**
+     Creates a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     
+     - parameter keyPath: the keyPath to query the value for
+     - returns: a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     */
     public func select<R>(_ keyPath: KeyPath<D, TransformableContainer<D>.Required<R>>) -> QueryChainBuilder<D, R> {
         
         return self.select(R.self, [SelectTerm<D>.attribute(keyPath)])
     }
     
+    /**
+     Creates a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     
+     - parameter keyPath: the keyPath to query the value for
+     - returns: a `QueryChainBuilder` that starts with a `Select` clause created from the specified key path
+     */
     public func select<R>(_ keyPath: KeyPath<D, TransformableContainer<D>.Optional<R>>) -> QueryChainBuilder<D, R> {
         
         return self.select(R.self, [SelectTerm<D>.attribute(keyPath)])
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections
+     
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, ValueContainer<D>.Required<T>>) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionBy(D.meta[keyPath: sectionKeyPath].keyPath, { $0 })
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections
+     
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, ValueContainer<D>.Optional<T>>) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionBy(D.meta[keyPath: sectionKeyPath].keyPath, { $0 })
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections
+     
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, TransformableContainer<D>.Required<T>>) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionBy(D.meta[keyPath: sectionKeyPath].keyPath, { $0 })
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections
+     
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, TransformableContainer<D>.Optional<T>>) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionBy(D.meta[keyPath: sectionKeyPath].keyPath, { $0 })
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections, and a closure to transform the value for the key path to an appropriate section name
+     
+     - Important: Some utilities (such as `ListMonitor`s) may keep `SectionBy`s in memory and may thus introduce retain cycles if reference captures are not handled properly.
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - parameter sectionIndexTransformer: a closure to transform the value for the key path to an appropriate section name
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, ValueContainer<D>.Required<T>>, _ sectionIndexTransformer: @escaping (_ sectionName: String?) -> String?) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionBy(D.meta[keyPath: sectionKeyPath].keyPath, sectionIndexTransformer)
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections, and a closure to transform the value for the key path to an appropriate section name
+     
+     - Important: Some utilities (such as `ListMonitor`s) may keep `SectionBy`s in memory and may thus introduce retain cycles if reference captures are not handled properly.
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - parameter sectionIndexTransformer: a closure to transform the value for the key path to an appropriate section name
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, ValueContainer<D>.Optional<T>>, _ sectionIndexTransformer: @escaping (_ sectionName: String?) -> String?) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionBy(D.meta[keyPath: sectionKeyPath].keyPath, sectionIndexTransformer)
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections, and a closure to transform the value for the key path to an appropriate section name
+     
+     - Important: Some utilities (such as `ListMonitor`s) may keep `SectionBy`s in memory and may thus introduce retain cycles if reference captures are not handled properly.
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - parameter sectionIndexTransformer: a closure to transform the value for the key path to an appropriate section name
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, TransformableContainer<D>.Required<T>>, _ sectionIndexTransformer: @escaping (_ sectionName: String?) -> String?) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionBy(D.meta[keyPath: sectionKeyPath].keyPath, sectionIndexTransformer)
     }
     
+    /**
+     Creates a `SectionMonitorChainBuilder` with the key path to use to group `ListMonitor` objects into sections, and a closure to transform the value for the key path to an appropriate section name
+     
+     - Important: Some utilities (such as `ListMonitor`s) may keep `SectionBy`s in memory and may thus introduce retain cycles if reference captures are not handled properly.
+     - parameter sectionKeyPath: the `KeyPath` to use to group the objects into sections
+     - parameter sectionIndexTransformer: a closure to transform the value for the key path to an appropriate section name
+     - returns: a `SectionMonitorChainBuilder` that is sectioned by the specified key path
+     */
     @available(OSX 10.12, *)
     public func sectionBy<T>(_ sectionKeyPath: KeyPath<D, TransformableContainer<D>.Optional<T>>, _ sectionIndexTransformer: @escaping (_ sectionName: String?) -> String?) -> SectionMonitorChainBuilder<D> {
         
@@ -313,36 +419,81 @@ public extension From where D: CoreStoreObject {
 
 public extension FetchChainBuilder {
     
+    /**
+     Adds a `Where` clause to the `FetchChainBuilder`
+     
+     - parameter clause: a `Where` clause to add to the fetch builder
+     - returns: a new `FetchChainBuilder` containing the `Where` clause
+     */
     public func `where`(_ clause: Where<D>) -> FetchChainBuilder<D> {
         
         return self.fetchChain(appending: clause)
     }
     
+    /**
+     Adds a `Where` clause to the `FetchChainBuilder`
+     
+     - parameter format: the format string for the predicate
+     - parameter args: the arguments for `format`
+     - returns: a new `FetchChainBuilder` containing the `Where` clause
+     */
     public func `where`(format: String, _ args: Any...) -> FetchChainBuilder<D> {
         
         return self.fetchChain(appending: Where<D>(format, argumentArray: args))
     }
     
+    /**
+     Adds a `Where` clause to the `FetchChainBuilder`
+     
+     - parameter format: the format string for the predicate
+     - parameter argumentArray: the arguments for `format`
+     - returns: a new `FetchChainBuilder` containing the `Where` clause
+     */
     public func `where`(format: String, argumentArray: [Any]?) -> FetchChainBuilder<D> {
         
         return self.fetchChain(appending: Where<D>(format, argumentArray: argumentArray))
     }
     
+    /**
+     Adds an `OrderBy` clause to the `FetchChainBuilder`
+     
+     - parameter sortKey: a single `SortKey`
+     - parameter sortKeys: a series of other `SortKey`s
+     - returns: a new `FetchChainBuilder` containing the `OrderBy` clause
+     */
     public func orderBy(_ sortKey: OrderBy<D>.SortKey, _ sortKeys: OrderBy<D>.SortKey...) -> FetchChainBuilder<D> {
         
         return self.fetchChain(appending: OrderBy<D>([sortKey] + sortKeys))
     }
     
+    /**
+     Adds a `Tweak` clause to the `FetchChainBuilder` with a closure where the `NSFetchRequest` may be configured
+     
+     - parameter fetchRequest: the block to customize the `NSFetchRequest`
+     - returns: a new `FetchChainBuilder` containing the `Tweak` clause
+     */
     public func tweak(_ fetchRequest: @escaping (NSFetchRequest<NSFetchRequestResult>) -> Void) -> FetchChainBuilder<D> {
         
         return self.fetchChain(appending: Tweak(fetchRequest))
     }
     
+    /**
+     Appends a `FetchClause` to the `FetchChainBuilder`
+     
+     - parameter clause: the `FetchClause` to add to the `FetchChainBuilder`
+     - returns: a new `FetchChainBuilder` containing the `FetchClause`
+     */
     public func appending(_ clause: FetchClause) -> FetchChainBuilder<D> {
         
         return self.fetchChain(appending: clause)
     }
     
+    /**
+     Appends a series of `FetchClause`s to the `FetchChainBuilder`
+     
+     - parameter clauses: the `FetchClause`s to add to the `FetchChainBuilder`
+     - returns: a new `FetchChainBuilder` containing the `FetchClause`s
+     */
     public func appending<S: Sequence>(contentsOf clauses: S) -> FetchChainBuilder<D> where S.Element == FetchClause {
         
         return self.fetchChain(appending: clauses)
@@ -378,51 +529,115 @@ public extension FetchChainBuilder where D: CoreStoreObject {
 
 public extension QueryChainBuilder {
     
+    /**
+     Adds a `Where` clause to the `QueryChainBuilder`
+     
+     - parameter clause: a `Where` clause to add to the query builder
+     - returns: a new `QueryChainBuilder` containing the `Where` clause
+     */
     public func `where`(_ clause: Where<D>) -> QueryChainBuilder<D, R> {
         
         return self.queryChain(appending: clause)
     }
     
+    /**
+     Adds a `Where` clause to the `QueryChainBuilder`
+     
+     - parameter format: the format string for the predicate
+     - parameter args: the arguments for `format`
+     - returns: a new `QueryChainBuilder` containing the `Where` clause
+     */
     public func `where`(format: String, _ args: Any...) -> QueryChainBuilder<D, R> {
         
         return self.queryChain(appending: Where<D>(format, argumentArray: args))
     }
     
+    /**
+     Adds a `Where` clause to the `QueryChainBuilder`
+     
+     - parameter format: the format string for the predicate
+     - parameter argumentArray: the arguments for `format`
+     - returns: a new `QueryChainBuilder` containing the `Where` clause
+     */
     public func `where`(format: String, argumentArray: [Any]?) -> QueryChainBuilder<D, R> {
         
         return self.queryChain(appending: Where<D>(format, argumentArray: argumentArray))
     }
     
+    /**
+     Adds an `OrderBy` clause to the `QueryChainBuilder`
+     
+     - parameter sortKey: a single `SortKey`
+     - parameter sortKeys: a series of other `SortKey`s
+     - returns: a new `QueryChainBuilder` containing the `OrderBy` clause
+     */
     public func orderBy(_ sortKey: OrderBy<D>.SortKey, _ sortKeys: OrderBy<D>.SortKey...) -> QueryChainBuilder<D, R> {
         
         return self.queryChain(appending: OrderBy<D>([sortKey] + sortKeys))
     }
     
+    /**
+     Adds a `Tweak` clause to the `QueryChainBuilder` with a closure where the `NSFetchRequest` may be configured
+     
+     - parameter fetchRequest: the block to customize the `NSFetchRequest`
+     - returns: a new `QueryChainBuilder` containing the `Tweak` clause
+     */
     public func tweak(_ fetchRequest: @escaping (NSFetchRequest<NSFetchRequestResult>) -> Void) -> QueryChainBuilder<D, R> {
         
         return self.queryChain(appending: Tweak(fetchRequest))
     }
     
+    /**
+     Adds a `GroupBy` clause to the `QueryChainBuilder`
+     
+     - parameter clause: a `GroupBy` clause to add to the query builder
+     - returns: a new `QueryChainBuilder` containing the `GroupBy` clause
+     */
     public func groupBy(_ clause: GroupBy<D>) -> QueryChainBuilder<D, R> {
         
         return self.queryChain(appending: clause)
     }
     
+    /**
+     Adds a `GroupBy` clause to the `QueryChainBuilder`
+     
+     - parameter keyPath: a key path to group the query results with
+     - parameter keyPaths: other key paths to group the query results with
+     - returns: a new `QueryChainBuilder` containing the `GroupBy` clause
+     */
     public func groupBy(_ keyPath: KeyPathString, _ keyPaths: KeyPathString...) -> QueryChainBuilder<D, R> {
         
         return self.groupBy(GroupBy<D>([keyPath] + keyPaths))
     }
     
+    /**
+     Adds a `GroupBy` clause to the `QueryChainBuilder`
+     
+     - parameter keyPaths: a series of key paths to group the query results with
+     - returns: a new `QueryChainBuilder` containing the `GroupBy` clause
+     */
     public func groupBy(_ keyPaths: [KeyPathString]) -> QueryChainBuilder<D, R> {
         
         return self.queryChain(appending: GroupBy<D>(keyPaths))
     }
     
+    /**
+     Appends a `QueryClause` to the `QueryChainBuilder`
+     
+     - parameter clause: the `QueryClause` to add to the `QueryChainBuilder`
+     - returns: a new `QueryChainBuilder` containing the `QueryClause`
+     */
     public func appending(_ clause: QueryClause) -> QueryChainBuilder<D, R> {
         
         return self.queryChain(appending: clause)
     }
     
+    /**
+     Appends a series of `QueryClause`s to the `QueryChainBuilder`
+     
+     - parameter clauses: the `QueryClause`s to add to the `QueryChainBuilder`
+     - returns: a new `QueryChainBuilder` containing the `QueryClause`s
+     */
     public func appending<S: Sequence>(contentsOf clauses: S) -> QueryChainBuilder<D, R> where S.Element == QueryClause {
         
         return self.queryChain(appending: clauses)
@@ -452,6 +667,12 @@ public extension QueryChainBuilder {
 
 public extension QueryChainBuilder where D: NSManagedObject {
     
+    /**
+     Adds a `GroupBy` clause to the `QueryChainBuilder`
+     
+     - parameter keyPath: a key path to group the query results with
+     - returns: a new `QueryChainBuilder` containing the `GroupBy` clause
+     */
     public func groupBy<T>(_ keyPath: KeyPath<D, T>) -> QueryChainBuilder<D, R> {
         
         return self.groupBy(GroupBy<D>(keyPath))
@@ -460,26 +681,56 @@ public extension QueryChainBuilder where D: NSManagedObject {
 
 public extension QueryChainBuilder where D: CoreStoreObject {
     
+    /**
+     Adds a `Where` clause to the `QueryChainBuilder`
+     
+     - parameter clause: a `Where` clause to add to the query builder
+     - returns: a new `QueryChainBuilder` containing the `Where` clause
+     */
     public func `where`<T: AnyWhereClause>(_ clause: (D) -> T) -> QueryChainBuilder<D, R> {
         
         return self.queryChain(appending: clause(D.meta))
     }
     
+    /**
+     Adds a `GroupBy` clause to the `QueryChainBuilder`
+     
+     - parameter keyPath: a key path to group the query results with
+     - returns: a new `QueryChainBuilder` containing the `GroupBy` clause
+     */
     public func groupBy<T>(_ keyPath: KeyPath<D, ValueContainer<D>.Required<T>>) -> QueryChainBuilder<D, R> {
         
         return self.groupBy(GroupBy<D>(keyPath))
     }
     
+    /**
+     Adds a `GroupBy` clause to the `QueryChainBuilder`
+     
+     - parameter keyPath: a key path to group the query results with
+     - returns: a new `QueryChainBuilder` containing the `GroupBy` clause
+     */
     public func groupBy<T>(_ keyPath: KeyPath<D, ValueContainer<D>.Optional<T>>) -> QueryChainBuilder<D, R> {
         
         return self.groupBy(GroupBy<D>(keyPath))
     }
     
+    /**
+     Adds a `GroupBy` clause to the `QueryChainBuilder`
+     
+     - parameter keyPath: a key path to group the query results with
+     - returns: a new `QueryChainBuilder` containing the `GroupBy` clause
+     */
     public func groupBy<T>(_ keyPath: KeyPath<D, TransformableContainer<D>.Required<T>>) -> QueryChainBuilder<D, R> {
         
         return self.groupBy(GroupBy<D>(keyPath))
     }
     
+    /**
+     Adds a `GroupBy` clause to the `QueryChainBuilder`
+     
+     - parameter keyPath: a key path to group the query results with
+     - returns: a new `QueryChainBuilder` containing the `GroupBy` clause
+     */
     public func groupBy<T>(_ keyPath: KeyPath<D, TransformableContainer<D>.Optional<T>>) -> QueryChainBuilder<D, R> {
         
         return self.groupBy(GroupBy<D>(keyPath))
@@ -489,36 +740,81 @@ public extension QueryChainBuilder where D: CoreStoreObject {
 @available(OSX 10.12, *)
 public extension SectionMonitorChainBuilder {
     
+    /**
+     Adds a `Where` clause to the `SectionMonitorChainBuilder`
+     
+     - parameter clause: a `Where` clause to add to the fetch builder
+     - returns: a new `SectionMonitorChainBuilder` containing the `Where` clause
+     */
     public func `where`(_ clause: Where<D>) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionMonitorChain(appending: clause)
     }
     
+    /**
+     Adds a `Where` clause to the `SectionMonitorChainBuilder`
+     
+     - parameter format: the format string for the predicate
+     - parameter args: the arguments for `format`
+     - returns: a new `SectionMonitorChainBuilder` containing the `Where` clause
+     */
     public func `where`(format: String, _ args: Any...) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionMonitorChain(appending: Where<D>(format, argumentArray: args))
     }
     
+    /**
+     Adds a `Where` clause to the `SectionMonitorChainBuilder`
+     
+     - parameter format: the format string for the predicate
+     - parameter argumentArray: the arguments for `format`
+     - returns: a new `SectionMonitorChainBuilder` containing the `Where` clause
+     */
     public func `where`(format: String, argumentArray: [Any]?) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionMonitorChain(appending: Where<D>(format, argumentArray: argumentArray))
     }
     
+    /**
+     Adds an `OrderBy` clause to the `SectionMonitorChainBuilder`
+     
+     - parameter sortKey: a single `SortKey`
+     - parameter sortKeys: a series of other `SortKey`s
+     - returns: a new `SectionMonitorChainBuilder` containing the `OrderBy` clause
+     */
     public func orderBy(_ sortKey: OrderBy<D>.SortKey, _ sortKeys: OrderBy<D>.SortKey...) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionMonitorChain(appending: OrderBy<D>([sortKey] + sortKeys))
     }
     
+    /**
+     Adds a `Tweak` clause to the `SectionMonitorChainBuilder` with a closure where the `NSFetchRequest` may be configured
+     
+     - parameter fetchRequest: the block to customize the `NSFetchRequest`
+     - returns: a new `SectionMonitorChainBuilder` containing the `Tweak` clause
+     */
     public func tweak(_ fetchRequest: @escaping (NSFetchRequest<NSFetchRequestResult>) -> Void) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionMonitorChain(appending: Tweak(fetchRequest))
     }
     
+    /**
+     Appends a `QueryClause` to the `SectionMonitorChainBuilder`
+     
+     - parameter clause: the `QueryClause` to add to the `SectionMonitorChainBuilder`
+     - returns: a new `SectionMonitorChainBuilder` containing the `QueryClause`
+     */
     public func appending(_ clause: FetchClause) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionMonitorChain(appending: clause)
     }
     
+    /**
+     Appends a series of `QueryClause`s to the `SectionMonitorChainBuilder`
+     
+     - parameter clauses: the `QueryClause`s to add to the `SectionMonitorChainBuilder`
+     - returns: a new `SectionMonitorChainBuilder` containing the `QueryClause`s
+     */
     public func appending<S: Sequence>(contentsOf clauses: S) -> SectionMonitorChainBuilder<D> where S.Element == FetchClause {
         
         return self.sectionMonitorChain(appending: clauses)
@@ -549,6 +845,12 @@ public extension SectionMonitorChainBuilder {
 @available(OSX 10.12, *)
 public extension SectionMonitorChainBuilder where D: CoreStoreObject {
     
+    /**
+     Adds a `Where` clause to the `SectionMonitorChainBuilder`
+     
+     - parameter clause: a `Where` clause to add to the fetch builder
+     - returns: a new `SectionMonitorChainBuilder` containing the `Where` clause
+     */
     public func `where`<T: AnyWhereClause>(_ clause: (D) -> T) -> SectionMonitorChainBuilder<D> {
         
         return self.sectionMonitorChain(appending: clause(D.meta))