diff --git a/Sources/KeyPath+Querying.swift b/Sources/KeyPath+Querying.swift
index ceaf7ae..a70491e 100644
--- a/Sources/KeyPath+Querying.swift
+++ b/Sources/KeyPath+Querying.swift
@@ -439,6 +439,155 @@ public func ~= <O, V, S: Sequence>(_ sequence: S, _ keyPath: KeyPath<O, FieldCon
 }
 
 
+// MARK: - KeyPath where Root: CoreStoreObject, Value: FieldContainer<Root>.Stored<QueryableAttributeType & Comparable>
+
+/**
+ Creates a `Where` clause by comparing if a property is less than a value
+ ```
+ let person = dataStack.fetchOne(From<Person>().where(\.$age < 20))
+ ```
+ */
+public func < <O, V: Comparable>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> {
+
+    return Where<O>("%K < %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is less than a value
+ ```
+ let person = dataStack.fetchOne(From<Person>().where(\.$age < 20))
+ ```
+ */
+public func < <O, V: FieldOptionalType>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> where V.Wrapped: Comparable {
+
+    return Where<O>("%K < %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is greater than a value
+ ```
+ let person = dataStack.fetchOne(From<Person>().where(\.$age > 20))
+ ```
+ */
+public func > <O, V: Comparable>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> {
+
+    return Where<O>("%K > %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is greater than a value
+ ```
+ let person = dataStack.fetchOne(From<Person>().where(\.$age > 20))
+ ```
+ */
+public func > <O, V: FieldOptionalType>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> where V.Wrapped: Comparable {
+
+    return Where<O>("%K > %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is less than or equal to a value
+ ```
+ let person = dataStack.fetchOne(From<Person>().where(\.$age <= 20))
+ ```
+ */
+public func <= <O, V: Comparable>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> {
+
+    return Where<O>("%K <= %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is less than or equal to a value
+ ```
+ let person = dataStack.fetchOne(From<Person>().where(\.$age <= 20))
+ ```
+ */
+public func <= <O, V: FieldOptionalType>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> where V.Wrapped: Comparable {
+
+    return Where<O>("%K <= %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is greater than or equal to a value
+ ```
+ let person = dataStack.fetchOne(From<Person>().where(\.$age >= 20))
+ ```
+ */
+public func >= <O, V: Comparable>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> {
+
+    return Where<O>("%K >= %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is greater than or equal to a value
+ ```
+ let person = dataStack.fetchOne(From<Person>().where(\.$age >= 20))
+ ```
+ */
+public func >= <O, V: FieldOptionalType>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> where V.Wrapped: Comparable {
+
+    return Where<O>("%K >= %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
+}
+
+
+// MARK: - KeyPath where Root: CoreStoreObject, Value: FieldContainer<Root>.Relationship<CoreStoreObject>
+
+/**
+ Creates a `Where` clause by comparing if a property is equal to a value
+ ```
+ let dog = dataStack.fetchOne(From<Dog>().where(\.$master == john))
+ ```
+ */
+public func == <O, D: FieldRelationshipToOneType>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, _ object: D.DestinationObjectType?) -> Where<O> {
+
+    return Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object)
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is equal to a value
+ ```
+ let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))
+ ```
+ */
+public func == <O, D: FieldRelationshipToOneType, R: ObjectRepresentation>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, _ object: R?) -> Where<O> where D.DestinationObjectType == R.ObjectType {
+
+    return Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object?.objectID())
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is not equal to a value
+ ```
+ let dog = dataStack.fetchOne(From<Dog>().where(\.$master != john))
+ ```
+ */
+public func != <O, D: FieldRelationshipToOneType>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, _ object: D.DestinationObjectType?) -> Where<O> {
+
+    return !Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object)
+}
+
+/**
+ Creates a `Where` clause by comparing if a property is not equal to a value
+ ```
+ let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))
+ ```
+ */
+public func != <O, D: FieldRelationshipToOneType, R: ObjectRepresentation>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, _ object: R?) -> Where<O> where D.DestinationObjectType == R.ObjectType {
+
+    return !Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object?.objectID())
+}
+
+/**
+ Creates a `Where` clause by checking if a sequence contains a value of a property
+ ```
+ let dog = dataStack.fetchOne(From<Dog>().where([john, bob, joe] ~= \.$master))
+ ```
+ */
+public func ~= <O, D: FieldRelationshipToOneType, S: Sequence>(_ sequence: S, _ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>) -> Where<O> where S.Iterator.Element == D.DestinationObjectType {
+
+    return Where<O>(O.meta[keyPath: keyPath].keyPath, isMemberOf: sequence)
+}
+
+
 // MARK: - KeyPath where Root: CoreStoreObject, Value: ValueContainer<Root>.Required<QueryableAttributeType & Equatable>
 
 /**
@@ -513,17 +662,6 @@ public func ~= <O, V, S: Sequence>(_ sequence: S, _ keyPath: KeyPath<O, ValueCon
 
 // MARK: - KeyPath where Root: CoreStoreObject, Value: ValueContainer<Root>.Required<QueryableAttributeType & Comparable>
 
-/**
- Creates a `Where` clause by comparing if a property is less than a value
- ```
- let person = dataStack.fetchOne(From<Person>().where(\.$age < 20))
- ```
- */
-public func < <O, V: Comparable>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> {
-
-    return Where<O>("%K < %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
-}
-
 /**
  Creates a `Where` clause by comparing if a property is less than a value
  ```
@@ -535,17 +673,6 @@ public func < <O, V: Comparable>(_ keyPath: KeyPath<O, ValueContainer<O>.Require
     return Where<O>("%K < %@", O.meta[keyPath: keyPath].keyPath, value.cs_toQueryableNativeType())
 }
 
-/**
- Creates a `Where` clause by comparing if a property is greater than a value
- ```
- let person = dataStack.fetchOne(From<Person>().where(\.$age > 20))
- ```
- */
-public func > <O, V: Comparable>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> {
-
-    return Where<O>("%K > %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
-}
-
 /**
  Creates a `Where` clause by comparing if a property is greater than a value
  ```
@@ -557,17 +684,6 @@ public func > <O, V: Comparable>(_ keyPath: KeyPath<O, ValueContainer<O>.Require
     return Where<O>("%K > %@", O.meta[keyPath: keyPath].keyPath, value.cs_toQueryableNativeType())
 }
 
-/**
- Creates a `Where` clause by comparing if a property is less than or equal to a value
- ```
- let person = dataStack.fetchOne(From<Person>().where(\.$age <= 20))
- ```
- */
-public func <= <O, V: Comparable>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> {
-
-    return Where<O>("%K <= %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
-}
-
 /**
  Creates a `Where` clause by comparing if a property is less than or equal to a value
  ```
@@ -579,17 +695,6 @@ public func <= <O, V: Comparable>(_ keyPath: KeyPath<O, ValueContainer<O>.Requir
     return Where<O>("%K <= %@", O.meta[keyPath: keyPath].keyPath, value.cs_toQueryableNativeType())
 }
 
-/**
- Creates a `Where` clause by comparing if a property is greater than or equal to a value
- ```
- let person = dataStack.fetchOne(From<Person>().where(\.$age >= 20))
- ```
- */
-public func >= <O, V: Comparable>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> {
-
-    return Where<O>("%K >= %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
-}
-
 /**
  Creates a `Where` clause by comparing if a property is greater than or equal to a value
  ```
@@ -604,17 +709,6 @@ public func >= <O, V: Comparable>(_ keyPath: KeyPath<O, ValueContainer<O>.Requir
 
 // MARK: - KeyPath where Root: CoreStoreObject, Value: ValueContainer<Root>.Optional<QueryableAttributeType & Comparable>
 
-/**
- Creates a `Where` clause by comparing if a property is less than a value
- ```
- let person = dataStack.fetchOne(From<Person>().where(\.$age < 20))
- ```
- */
-public func < <O, V: FieldOptionalType>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> where V.Wrapped: Comparable {
-
-    return Where<O>("%K < %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
-}
-
 /**
  Creates a `Where` clause by comparing if a property is less than a value
  ```
@@ -633,17 +727,6 @@ public func < <O, V>(_ keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, _ val
     }
 }
 
-/**
- Creates a `Where` clause by comparing if a property is greater than a value
- ```
- let person = dataStack.fetchOne(From<Person>().where(\.$age > 20))
- ```
- */
-public func > <O, V: FieldOptionalType>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> where V.Wrapped: Comparable {
-
-    return Where<O>("%K > %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
-}
-
 /**
  Creates a `Where` clause by comparing if a property is greater than a value
  ```
@@ -662,17 +745,6 @@ public func > <O, V>(_ keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, _ val
     }
 }
 
-/**
- Creates a `Where` clause by comparing if a property is less than or equal to a value
- ```
- let person = dataStack.fetchOne(From<Person>().where(\.$age <= 20))
- ```
- */
-public func <= <O, V: FieldOptionalType>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> where V.Wrapped: Comparable {
-
-    return Where<O>("%K <= %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
-}
-
 /**
  Creates a `Where` clause by comparing if a property is less than or equal to a value
  ```
@@ -691,17 +763,6 @@ public func <= <O, V>(_ keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, _ va
     }
 }
 
-/**
- Creates a `Where` clause by comparing if a property is greater than or equal to a value
- ```
- let person = dataStack.fetchOne(From<Person>().where(\.$age >= 20))
- ```
- */
-public func >= <O, V: FieldOptionalType>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, _ value: V) -> Where<O> where V.Wrapped: Comparable {
-
-    return Where<O>("%K >= %@", O.meta[keyPath: keyPath].keyPath, value.cs_toFieldStoredNativeType() as! V.FieldStoredNativeType)
-}
-
 /**
  Creates a `Where` clause by comparing if a property is greater than or equal to a value
  ```
@@ -723,28 +784,6 @@ public func >= <O, V>(_ keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, _ va
 
 // MARK: - KeyPath where Root: CoreStoreObject, Value: RelationshipContainer<Root>.ToOne<CoreStoreObject>
 
-/**
- Creates a `Where` clause by comparing if a property is equal to a value
- ```
- let dog = dataStack.fetchOne(From<Dog>().where(\.$master == john))
- ```
- */
-public func == <O, D: FieldRelationshipToOneType>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, _ object: D.DestinationObjectType?) -> Where<O> {
-
-    return Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object)
-}
-
-/**
- Creates a `Where` clause by comparing if a property is equal to a value
- ```
- let dog = dataStack.fetchOne(From<Dog>().where(\.master == john))
- ```
- */
-public func == <O, D: FieldRelationshipToOneType, R: ObjectRepresentation>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, _ object: R?) -> Where<O> where D.DestinationObjectType == R.ObjectType {
-
-    return Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object?.objectID())
-}
-
 /**
  Creates a `Where` clause by comparing if a property is equal to a value
  ```
@@ -767,28 +806,6 @@ public func == <O, D>(_ keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>,
     return Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object)
 }
 
-/**
- Creates a `Where` clause by comparing if a property is not equal to a value
- ```
- let dog = dataStack.fetchOne(From<Dog>().where(\.$master != john))
- ```
- */
-public func != <O, D: FieldRelationshipToOneType>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, _ object: D.DestinationObjectType?) -> Where<O> {
-
-    return !Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object)
-}
-
-/**
- Creates a `Where` clause by comparing if a property is not equal to a value
- ```
- let dog = dataStack.fetchOne(From<Dog>().where(\.master != john))
- ```
- */
-public func != <O, D: FieldRelationshipToOneType, R: ObjectRepresentation>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>, _ object: R?) -> Where<O> where D.DestinationObjectType == R.ObjectType {
-
-    return !Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object?.objectID())
-}
-
 /**
  Creates a `Where` clause by comparing if a property is not equal to a value
  ```
@@ -811,17 +828,6 @@ public func != <O, D>(_ keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>,
     return !Where<O>(O.meta[keyPath: keyPath].keyPath, isEqualTo: object)
 }
 
-/**
- Creates a `Where` clause by checking if a sequence contains a value of a property
- ```
- let dog = dataStack.fetchOne(From<Dog>().where([john, bob, joe] ~= \.$master))
- ```
- */
-public func ~= <O, D: FieldRelationshipToOneType, S: Sequence>(_ sequence: S, _ keyPath: KeyPath<O, FieldContainer<O>.Relationship<D>>) -> Where<O> where S.Iterator.Element == D.DestinationObjectType {
-
-    return Where<O>(O.meta[keyPath: keyPath].keyPath, isMemberOf: sequence)
-}
-
 /**
  Creates a `Where` clause by checking if a sequence contains a value of a property
  ```
diff --git a/Sources/Where.swift b/Sources/Where.swift
index f9de0c8..40d88d2 100644
--- a/Sources/Where.swift
+++ b/Sources/Where.swift
@@ -469,7 +469,7 @@ extension Where where O: CoreStoreObject {
      - parameter keyPath: the keyPath to compare with
      - parameter null: the arguments for the `==` operator
      */
-    public init<V>(_ keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, isEqualTo null: Void?) {
+    public init<V>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, isEqualTo null: Void?) {
         
         self.init(O.meta[keyPath: keyPath].keyPath, isEqualTo: null)
     }
@@ -480,11 +480,44 @@ extension Where where O: CoreStoreObject {
      - parameter keyPath: the keyPath to compare with
      - parameter null: the arguments for the `==` operator
      */
-    public init<D>(_ keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, isEqualTo null: Void?) {
+    public init<V: FieldRelationshipToOneType>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<V>>, isEqualTo null: Void?) {
         
         self.init(O.meta[keyPath: keyPath].keyPath, isEqualTo: null)
     }
     
+    /**
+     Initializes a `Where` clause that compares membership
+     
+     - parameter keyPath: the keyPath to compare with
+     - parameter list: the sequence to check membership of
+     */
+    public init<V, S: Sequence>(_ keyPath: KeyPath<O, FieldContainer<O>.Stored<V>>, isMemberOf list: S) where S.Iterator.Element == V {
+        
+        self.init(O.meta[keyPath: keyPath].keyPath, isMemberOf: list)
+    }
+    
+    /**
+     Initializes a `Where` clause that compares membership
+     
+     - parameter keyPath: the keyPath to compare with
+     - parameter list: the sequence to check membership of
+     */
+    public init<V: FieldRelationshipToOneType, S: Sequence>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<V>>, isMemberOf list: S) where S.Iterator.Element == V.DestinationObjectType {
+        
+        self.init(O.meta[keyPath: keyPath].keyPath, isMemberOf: list)
+    }
+    
+    /**
+     Initializes a `Where` clause that compares membership
+     
+     - parameter keyPath: the keyPath to compare with
+     - parameter list: the sequence to check membership of
+     */
+    public init<V: FieldRelationshipToOneType, S: Sequence>(_ keyPath: KeyPath<O, FieldContainer<O>.Relationship<V>>, isMemberOf list: S) where S.Iterator.Element: NSManagedObjectID {
+        
+        self.init(O.meta[keyPath: keyPath].keyPath, isMemberOf: list)
+    }
+    
     /**
      Initializes a `Where` clause that compares equality
      
@@ -507,6 +540,28 @@ extension Where where O: CoreStoreObject {
         self.init(O.meta[keyPath: keyPath].keyPath, isEqualTo: value)
     }
     
+    /**
+     Initializes a `Where` clause that compares equality to `nil`
+     
+     - parameter keyPath: the keyPath to compare with
+     - parameter null: the arguments for the `==` operator
+     */
+    public init<V>(_ keyPath: KeyPath<O, ValueContainer<O>.Optional<V>>, isEqualTo null: Void?) {
+        
+        self.init(O.meta[keyPath: keyPath].keyPath, isEqualTo: null)
+    }
+    
+    /**
+     Initializes a `Where` clause that compares equality to `nil`
+     
+     - parameter keyPath: the keyPath to compare with
+     - parameter null: the arguments for the `==` operator
+     */
+    public init<D>(_ keyPath: KeyPath<O, RelationshipContainer<O>.ToOne<D>>, isEqualTo null: Void?) {
+        
+        self.init(O.meta[keyPath: keyPath].keyPath, isEqualTo: null)
+    }
+    
     /**
      Initializes a `Where` clause that compares equality