Rename Identifiable to JSONAPIIdentifiable and add Swift Identifiable conformance to the same types

mattpolzin · mattpolzin · commit 3c8bdcaacf5f · 2020-05-29T14:20:44.000-07:00
diff --git a/Sources/JSONAPI/Resource/Relationship.swift b/Sources/JSONAPI/Resource/Relationship.swift
@@ -35,46 +35,46 @@ public struct MetaRelationship<MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>
 /// a JSON API "Resource Linkage."
 /// See https://jsonapi.org/format/#document-resource-object-linkage
 /// A convenient typealias might make your code much more legible: `One<ResourceObjectDescription>`
-public struct ToOneRelationship<Identifiable: JSONAPI.Identifiable, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>: RelationshipType, Equatable {
+public struct ToOneRelationship<Identifiable: JSONAPI.JSONAPIIdentifiable, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>: RelationshipType, Equatable {
 
-    public let id: Identifiable.Identifier
+    public let id: Identifiable.ID
 
     public let meta: MetaType
     public let links: LinksType
 
-    public init(id: Identifiable.Identifier, meta: MetaType, links: LinksType) {
+    public init(id: Identifiable.ID, meta: MetaType, links: LinksType) {
         self.id = id
         self.meta = meta
         self.links = links
     }
 }
 
 extension ToOneRelationship where MetaType == NoMetadata, LinksType == NoLinks {
-    public init(id: Identifiable.Identifier) {
+    public init(id: Identifiable.ID) {
         self.init(id: id, meta: .none, links: .none)
     }
 }
 
 extension ToOneRelationship {
-    public init<T: ResourceObjectType>(resourceObject: T, meta: MetaType, links: LinksType) where T.Id == Identifiable.Identifier {
+    public init<T: ResourceObjectType>(resourceObject: T, meta: MetaType, links: LinksType) where T.Id == Identifiable.ID {
         self.init(id: resourceObject.id, meta: meta, links: links)
     }
 }
 
 extension ToOneRelationship where MetaType == NoMetadata, LinksType == NoLinks {
-    public init<T: ResourceObjectType>(resourceObject: T) where T.Id == Identifiable.Identifier {
+    public init<T: ResourceObjectType>(resourceObject: T) where T.Id == Identifiable.ID {
         self.init(id: resourceObject.id, meta: .none, links: .none)
     }
 }
 
 extension ToOneRelationship where Identifiable: OptionalRelatable {
-    public init<T: ResourceObjectType>(resourceObject: T?, meta: MetaType, links: LinksType) where T.Id == Identifiable.Wrapped.Identifier {
+    public init<T: ResourceObjectType>(resourceObject: T?, meta: MetaType, links: LinksType) where T.Id == Identifiable.Wrapped.ID {
         self.init(id: resourceObject?.id, meta: meta, links: links)
     }
 }
 
 extension ToOneRelationship where Identifiable: OptionalRelatable, MetaType == NoMetadata, LinksType == NoLinks {
-    public init<T: ResourceObjectType>(resourceObject: T?) where T.Id == Identifiable.Wrapped.Identifier {
+    public init<T: ResourceObjectType>(resourceObject: T?) where T.Id == Identifiable.Wrapped.ID {
         self.init(id: resourceObject?.id, meta: .none, links: .none)
     }
 }
@@ -85,24 +85,24 @@ extension ToOneRelationship where Identifiable: OptionalRelatable, MetaType == N
 /// A convenient typealias might make your code much more legible: `Many<ResourceObjectDescription>`
 public struct ToManyRelationship<Relatable: JSONAPI.Relatable, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>: RelationshipType, Equatable {
 
-    public let ids: [Relatable.Identifier]
+    public let ids: [Relatable.ID]
 
     public let meta: MetaType
     public let links: LinksType
 
-    public init(ids: [Relatable.Identifier], meta: MetaType, links: LinksType) {
+    public init(ids: [Relatable.ID], meta: MetaType, links: LinksType) {
         self.ids = ids
         self.meta = meta
         self.links = links
     }
 
-    public init<T: JSONAPI.Identifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>], meta: MetaType, links: LinksType) where T.Identifier == Relatable.Identifier {
+    public init<T: JSONAPI.JSONAPIIdentifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>], meta: MetaType, links: LinksType) where T.ID == Relatable.ID {
         ids = pointers.map(\.id)
         self.meta = meta
         self.links = links
     }
 
-    public init<T: ResourceObjectType>(resourceObjects: [T], meta: MetaType, links: LinksType) where T.Id == Relatable.Identifier {
+    public init<T: ResourceObjectType>(resourceObjects: [T], meta: MetaType, links: LinksType) where T.Id == Relatable.ID {
         self.init(ids: resourceObjects.map(\.id), meta: meta, links: links)
     }
 
@@ -117,40 +117,40 @@ public struct ToManyRelationship<Relatable: JSONAPI.Relatable, MetaType: JSONAPI
 
 extension ToManyRelationship where MetaType == NoMetadata, LinksType == NoLinks {
 
-    public init(ids: [Relatable.Identifier]) {
+    public init(ids: [Relatable.ID]) {
         self.init(ids: ids, meta: .none, links: .none)
     }
 
-    public init<T: JSONAPI.Identifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>]) where T.Identifier == Relatable.Identifier {
+    public init<T: JSONAPI.JSONAPIIdentifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>]) where T.ID == Relatable.ID {
         self.init(pointers: pointers, meta: .none, links: .none)
     }
 
     public static var none: ToManyRelationship {
         return .none(withMeta: .none, links: .none)
     }
 
-    public init<T: ResourceObjectType>(resourceObjects: [T]) where T.Id == Relatable.Identifier {
+    public init<T: ResourceObjectType>(resourceObjects: [T]) where T.Id == Relatable.ID {
         self.init(resourceObjects: resourceObjects, meta: .none, links: .none)
     }
 }
 
-public protocol Identifiable: JSONTyped {
-    associatedtype Identifier: Equatable
+public protocol JSONAPIIdentifiable: JSONTyped {
+    associatedtype ID: Equatable
 }
 
 /// The Relatable protocol describes anything that
 /// has an IdType Identifier
-public protocol Relatable: Identifiable where Identifier: JSONAPI.IdType {
+public protocol Relatable: JSONAPIIdentifiable where ID: JSONAPI.IdType {
 }
 
 /// OptionalRelatable just describes an Optional
 /// with a Reltable Wrapped type.
-public protocol OptionalRelatable: Identifiable where Identifier == Wrapped.Identifier? {
+public protocol OptionalRelatable: JSONAPIIdentifiable where ID == Wrapped.ID? {
     associatedtype Wrapped: JSONAPI.Relatable
 }
 
-extension Optional: Identifiable, OptionalRelatable, JSONTyped where Wrapped: JSONAPI.Relatable {
-    public typealias Identifier = Wrapped.Identifier?
+extension Optional: JSONAPIIdentifiable, OptionalRelatable, JSONTyped where Wrapped: JSONAPI.Relatable {
+    public typealias ID = Wrapped.ID?
 
     public static var jsonType: String { return Wrapped.jsonType }
 }
@@ -196,7 +196,7 @@ extension MetaRelationship: Codable {
     }
 }
 
-extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {
+extension ToOneRelationship: Codable where Identifiable.ID: OptionalId {
     public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: ResourceLinkageCodingKeys.self)
 
@@ -219,7 +219,7 @@ extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {
         // type at which point we can store nil in `id`.
         let anyNil: Any? = nil
         if try container.decodeNil(forKey: .data) {
-            guard let val = anyNil as? Identifiable.Identifier else {
+            guard let val = anyNil as? Identifiable.ID else {
                 throw DecodingError.valueNotFound(
                     Self.self,
                     DecodingError.Context(
@@ -256,7 +256,7 @@ extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {
             )
         }
 
-        id = Identifiable.Identifier(rawValue: try identifier.decode(Identifiable.Identifier.RawType.self, forKey: .id))
+        id = Identifiable.ID(rawValue: try identifier.decode(Identifiable.ID.RawType.self, forKey: .id))
     }
 
     public func encode(to encoder: Encoder) throws {
@@ -273,7 +273,7 @@ extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {
         // If id is nil, instead of {id: , type: } we will just
         // encode `null`
         let anyNil: Any? = nil
-        let nilId = anyNil as? Identifiable.Identifier
+        let nilId = anyNil as? Identifiable.ID
         guard id != nilId else {
             try container.encodeNil(forKey: .data)
             return
@@ -314,7 +314,7 @@ extension ToManyRelationship: Codable {
                                                   path: context.codingPath)
         }
 
-        var newIds = [Relatable.Identifier]()
+        var newIds = [Relatable.ID]()
         while !identifiers.isAtEnd {
             let identifier = try identifiers.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self)
 
@@ -324,7 +324,7 @@ extension ToManyRelationship: Codable {
                 throw JSONAPICodingError.typeMismatch(expected: Relatable.jsonType, found: type, path: decoder.codingPath)
             }
 
-            newIds.append(Relatable.Identifier(rawValue: try identifier.decode(Relatable.Identifier.RawType.self, forKey: .id)))
+            newIds.append(Relatable.ID(rawValue: try identifier.decode(Relatable.ID.RawType.self, forKey: .id)))
         }
         ids = newIds
     }
diff --git a/Sources/JSONAPI/Resource/Resource Object/ResourceObject.swift b/Sources/JSONAPI/Resource/Resource Object/ResourceObject.swift
@@ -163,10 +163,13 @@ extension ResourceObject: Hashable where EntityRawIdType: RawIdType {
     }
 }
 
-extension ResourceObject: Identifiable, IdentifiableResourceObjectType, Relatable where EntityRawIdType: JSONAPI.RawIdType {
-    public typealias Identifier = ResourceObject.Id
+extension ResourceObject: JSONAPIIdentifiable, IdentifiableResourceObjectType, Relatable where EntityRawIdType: JSONAPI.RawIdType {
+    public typealias ID = ResourceObject.Id
 }
 
+@available(OSX 10.15, iOS 13, tvOS 13, watchOS 6, *)
+extension ResourceObject: Swift.Identifiable where EntityRawIdType: JSONAPI.RawIdType {}
+
 extension ResourceObject: CustomStringConvertible {
     public var description: String {
         return "ResourceObject<\(ResourceObject.jsonType)>(id: \(String(describing: id)), attributes: \(String(describing: attributes)), relationships: \(String(describing: relationships)))"
@@ -230,7 +233,7 @@ public extension ResourceObject where EntityRawIdType == Unidentified {
 
     /// Create a new `ResourceObject` from this one with the given Id.
     func identified<RawIdType: JSONAPI.RawIdType>(by id: RawIdType) -> ResourceObject<Description, MetaType, LinksType, RawIdType> {
-        return .init(id: ResourceObject<Description, MetaType, LinksType, RawIdType>.Identifier(rawValue: id), attributes: attributes, relationships: relationships, meta: meta, links: links)
+        return .init(id: ResourceObject<Description, MetaType, LinksType, RawIdType>.ID(rawValue: id), attributes: attributes, relationships: relationships, meta: meta, links: links)
     }
 }
 
@@ -294,14 +297,14 @@ public extension ResourceObjectProxy {
     /// Access to an Id of a `ToOneRelationship`.
     /// This allows you to write `resourceObject ~> \.other` instead
     /// of `resourceObject.relationships.other.id`.
-    static func ~><OtherEntity: Identifiable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>>) -> OtherEntity.Identifier {
+    static func ~><OtherEntity: JSONAPIIdentifiable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>>) -> OtherEntity.ID {
         return entity.relationships[keyPath: path].id
     }
 
     /// Access to an Id of an optional `ToOneRelationship`.
     /// This allows you to write `resourceObject ~> \.other` instead
     /// of `resourceObject.relationships.other?.id`.
-    static func ~><OtherEntity: OptionalRelatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>?>) -> OtherEntity.Identifier {
+    static func ~><OtherEntity: OptionalRelatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>?>) -> OtherEntity.ID {
         // Implementation Note: This signature applies to `ToOneRelationship<E?, _, _>?`
         // whereas the one below applies to `ToOneRelationship<E, _, _>?`
         return entity.relationships[keyPath: path]?.id
@@ -310,7 +313,7 @@ public extension ResourceObjectProxy {
     /// Access to an Id of an optional `ToOneRelationship`.
     /// This allows you to write `resourceObject ~> \.other` instead
     /// of `resourceObject.relationships.other?.id`.
-    static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>?>) -> OtherEntity.Identifier? {
+    static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>?>) -> OtherEntity.ID? {
         // Implementation Note: This signature applies to `ToOneRelationship<E, _, _>?`
         // whereas the one above applies to `ToOneRelationship<E?, _, _>?`
         return entity.relationships[keyPath: path]?.id
@@ -319,14 +322,14 @@ public extension ResourceObjectProxy {
     /// Access to all Ids of a `ToManyRelationship`.
     /// This allows you to write `resourceObject ~> \.others` instead
     /// of `resourceObject.relationships.others.ids`.
-    static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity, MType, LType>>) -> [OtherEntity.Identifier] {
+    static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity, MType, LType>>) -> [OtherEntity.ID] {
         return entity.relationships[keyPath: path].ids
     }
 
     /// Access to all Ids of an optional `ToManyRelationship`.
     /// This allows you to write `resourceObject ~> \.others` instead
     /// of `resourceObject.relationships.others?.ids`.
-    static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity, MType, LType>?>) -> [OtherEntity.Identifier]? {
+    static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity, MType, LType>?>) -> [OtherEntity.ID]? {
         return entity.relationships[keyPath: path]?.ids
     }
 }
diff --git a/Sources/JSONAPITesting/Relationship+Literal.swift b/Sources/JSONAPITesting/Relationship+Literal.swift
@@ -7,39 +7,39 @@
 
 import JSONAPI
 
-extension ToOneRelationship: ExpressibleByNilLiteral where Identifiable.Identifier: ExpressibleByNilLiteral, MetaType == NoMetadata, LinksType == NoLinks {
+extension ToOneRelationship: ExpressibleByNilLiteral where Identifiable.ID: ExpressibleByNilLiteral, MetaType == NoMetadata, LinksType == NoLinks {
     public init(nilLiteral: ()) {
 
-        self.init(id: Identifiable.Identifier(nilLiteral: ()))
+        self.init(id: Identifiable.ID(nilLiteral: ()))
     }
 }
 
-extension ToOneRelationship: ExpressibleByUnicodeScalarLiteral where Identifiable.Identifier: ExpressibleByUnicodeScalarLiteral, MetaType == NoMetadata, LinksType == NoLinks {
-    public typealias UnicodeScalarLiteralType =  Identifiable.Identifier.UnicodeScalarLiteralType
+extension ToOneRelationship: ExpressibleByUnicodeScalarLiteral where Identifiable.ID: ExpressibleByUnicodeScalarLiteral, MetaType == NoMetadata, LinksType == NoLinks {
+    public typealias UnicodeScalarLiteralType =  Identifiable.ID.UnicodeScalarLiteralType
 
     public init(unicodeScalarLiteral value: UnicodeScalarLiteralType) {
-        self.init(id: Identifiable.Identifier(unicodeScalarLiteral: value))
+        self.init(id: Identifiable.ID(unicodeScalarLiteral: value))
     }
 }
 
-extension ToOneRelationship: ExpressibleByExtendedGraphemeClusterLiteral where Identifiable.Identifier: ExpressibleByExtendedGraphemeClusterLiteral, MetaType == NoMetadata, LinksType == NoLinks {
-    public typealias ExtendedGraphemeClusterLiteralType =  Identifiable.Identifier.ExtendedGraphemeClusterLiteralType
+extension ToOneRelationship: ExpressibleByExtendedGraphemeClusterLiteral where Identifiable.ID: ExpressibleByExtendedGraphemeClusterLiteral, MetaType == NoMetadata, LinksType == NoLinks {
+    public typealias ExtendedGraphemeClusterLiteralType =  Identifiable.ID.ExtendedGraphemeClusterLiteralType
 
     public init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType) {
-        self.init(id: Identifiable.Identifier(extendedGraphemeClusterLiteral: value))
+        self.init(id: Identifiable.ID(extendedGraphemeClusterLiteral: value))
     }
 }
 
-extension ToOneRelationship: ExpressibleByStringLiteral where Identifiable.Identifier: ExpressibleByStringLiteral, MetaType == NoMetadata, LinksType == NoLinks {
-    public typealias StringLiteralType = Identifiable.Identifier.StringLiteralType
+extension ToOneRelationship: ExpressibleByStringLiteral where Identifiable.ID: ExpressibleByStringLiteral, MetaType == NoMetadata, LinksType == NoLinks {
+    public typealias StringLiteralType = Identifiable.ID.StringLiteralType
 
     public init(stringLiteral value: StringLiteralType) {
-        self.init(id: Identifiable.Identifier(stringLiteral: value))
+        self.init(id: Identifiable.ID(stringLiteral: value))
     }
 }
 
 extension ToManyRelationship: ExpressibleByArrayLiteral where MetaType == NoMetadata, LinksType == NoLinks {
-    public typealias ArrayLiteralElement = Relatable.Identifier
+    public typealias ArrayLiteralElement = Relatable.ID
 
     public init(arrayLiteral elements: ArrayLiteralElement...) {
         self.init(ids: elements)
diff --git a/Tests/JSONAPITests/NonJSONAPIRelatable/NonJSONAPIRelatableTests.swift b/Tests/JSONAPITests/NonJSONAPIRelatable/NonJSONAPIRelatableTests.swift
@@ -83,7 +83,7 @@ extension NonJSONAPIRelatableTests {
 	struct NonJSONAPIEntity: Relatable, JSONTyped {
 		static var jsonType: String { return "other" }
 
-		typealias Identifier = NonJSONAPIEntity.Id
+		typealias ID = NonJSONAPIEntity.Id
 
 		let id: Id
 
diff --git a/Tests/JSONAPITests/ResourceObject/ResourceObjectTests.swift b/Tests/JSONAPITests/ResourceObject/ResourceObjectTests.swift
@@ -91,7 +91,7 @@ class ResourceObjectTests: XCTestCase {
 		let _ = TestEntity9(id: .init(rawValue: "9"), attributes: .none, relationships: .init(meta: .init(meta: .init(x: "hello", y: 5), links: .none), optionalMeta: nil, one: entity1.pointer, nullableOne: nil, optionalOne: entity1.pointer, optionalNullableOne: nil, optionalMany: nil), meta: .none, links: .none)
 		let _ = TestEntity9(id: .init(rawValue: "9"), attributes: .none, relationships: .init(meta: .init(meta: .init(x: "hello", y: 5), links: .none), optionalMeta: nil, one: entity1.pointer, nullableOne: nil, optionalOne: nil, optionalNullableOne: .init(resourceObject: entity1, meta: .none, links: .none), optionalMany: nil), meta: .none, links: .none)
 		let _ = TestEntity9(id: .init(rawValue: "9"), attributes: .none, relationships: .init(meta: .init(meta: .init(x: "hello", y: 5), links: .none), optionalMeta: nil, one: entity1.pointer, nullableOne: nil, optionalOne: nil, optionalNullableOne: .init(resourceObject: entity1, meta: .none, links: .none), optionalMany: .init(resourceObjects: [], meta: .none, links: .none)), meta: .none, links: .none)
-		let e10id1 = TestEntity10.Identifier(rawValue: "hello")
+		let e10id1 = TestEntity10.ID(rawValue: "hello")
 		let e10id2 = TestEntity10.Id(rawValue: "world")
 		let e10id3: TestEntity10.Id = "!"
 		let _ = TestEntity10(id: .init(rawValue: "10"), attributes: .none, relationships: .init(selfRef: .init(id: e10id1), selfRefs: .init(ids: [e10id2, e10id3])), meta: .none, links: .none)
@@ -901,15 +901,15 @@ extension ResourceObjectTests {
 		typealias Attributes = NoAttributes
 
 		struct Relationships: JSONAPI.Relationships {
-			var metaRelationship: (TestEntityWithMetaRelationship) -> TestEntity1.Identifier {
+			var metaRelationship: (TestEntityWithMetaRelationship) -> TestEntity1.ID {
 				return { entity in
-					return TestEntity1.Identifier(rawValue: "hello")
+					return TestEntity1.ID(rawValue: "hello")
 				}
 			}
 
-            var toManyMetaRelationship: (TestEntityWithMetaRelationship) -> [TestEntity1.Identifier] {
+            var toManyMetaRelationship: (TestEntityWithMetaRelationship) -> [TestEntity1.ID] {
                 return { entity in
-                    return [TestEntity1.Identifier.id(from: "hello")]
+                    return [TestEntity1.ID.id(from: "hello")]
                 }
             }
 		}
diff --git a/Tests/JSONAPITests/SwiftIdentifiableTests.swift b/Tests/JSONAPITests/SwiftIdentifiableTests.swift

Original file line number	Diff line number	Diff line change
`@@ -35,46 +35,46 @@ public struct MetaRelationship<MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>`
`35`	`35`	`/// a JSON API "Resource Linkage."`
`36`	`36`	`/// See https://jsonapi.org/format/#document-resource-object-linkage`
`37`	`37`	/// A convenient typealias might make your code much more legible: `One<ResourceObjectDescription>`
`38`		`-public struct ToOneRelationship<Identifiable: JSONAPI.Identifiable, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>: RelationshipType, Equatable {`
	`38`	`+public struct ToOneRelationship<Identifiable: JSONAPI.JSONAPIIdentifiable, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>: RelationshipType, Equatable {`
`39`	`39`
`40`		`- public let id: Identifiable.Identifier`
	`40`	`+ public let id: Identifiable.ID`
`41`	`41`
`42`	`42`	`public let meta: MetaType`
`43`	`43`	`public let links: LinksType`
`44`	`44`
`45`		`- public init(id: Identifiable.Identifier, meta: MetaType, links: LinksType) {`
	`45`	`+ public init(id: Identifiable.ID, meta: MetaType, links: LinksType) {`
`46`	`46`	`self.id = id`
`47`	`47`	`self.meta = meta`
`48`	`48`	`self.links = links`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`extension ToOneRelationship where MetaType == NoMetadata, LinksType == NoLinks {`
`53`		`- public init(id: Identifiable.Identifier) {`
	`53`	`+ public init(id: Identifiable.ID) {`
`54`	`54`	`self.init(id: id, meta: .none, links: .none)`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`extension ToOneRelationship {`
`59`		`- public init<T: ResourceObjectType>(resourceObject: T, meta: MetaType, links: LinksType) where T.Id == Identifiable.Identifier {`
	`59`	`+ public init<T: ResourceObjectType>(resourceObject: T, meta: MetaType, links: LinksType) where T.Id == Identifiable.ID {`
`60`	`60`	`self.init(id: resourceObject.id, meta: meta, links: links)`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`extension ToOneRelationship where MetaType == NoMetadata, LinksType == NoLinks {`
`65`		`- public init<T: ResourceObjectType>(resourceObject: T) where T.Id == Identifiable.Identifier {`
	`65`	`+ public init<T: ResourceObjectType>(resourceObject: T) where T.Id == Identifiable.ID {`
`66`	`66`	`self.init(id: resourceObject.id, meta: .none, links: .none)`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`extension ToOneRelationship where Identifiable: OptionalRelatable {`
`71`		`- public init<T: ResourceObjectType>(resourceObject: T?, meta: MetaType, links: LinksType) where T.Id == Identifiable.Wrapped.Identifier {`
	`71`	`+ public init<T: ResourceObjectType>(resourceObject: T?, meta: MetaType, links: LinksType) where T.Id == Identifiable.Wrapped.ID {`
`72`	`72`	`self.init(id: resourceObject?.id, meta: meta, links: links)`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`extension ToOneRelationship where Identifiable: OptionalRelatable, MetaType == NoMetadata, LinksType == NoLinks {`
`77`		`- public init<T: ResourceObjectType>(resourceObject: T?) where T.Id == Identifiable.Wrapped.Identifier {`
	`77`	`+ public init<T: ResourceObjectType>(resourceObject: T?) where T.Id == Identifiable.Wrapped.ID {`
`78`	`78`	`self.init(id: resourceObject?.id, meta: .none, links: .none)`
`79`	`79`	`}`
`80`	`80`	`}`
`@@ -85,24 +85,24 @@ extension ToOneRelationship where Identifiable: OptionalRelatable, MetaType == N`
`85`	`85`	/// A convenient typealias might make your code much more legible: `Many<ResourceObjectDescription>`
`86`	`86`	`public struct ToManyRelationship<Relatable: JSONAPI.Relatable, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>: RelationshipType, Equatable {`
`87`	`87`
`88`		`- public let ids: [Relatable.Identifier]`
	`88`	`+ public let ids: [Relatable.ID]`
`89`	`89`
`90`	`90`	`public let meta: MetaType`
`91`	`91`	`public let links: LinksType`
`92`	`92`
`93`		`- public init(ids: [Relatable.Identifier], meta: MetaType, links: LinksType) {`
	`93`	`+ public init(ids: [Relatable.ID], meta: MetaType, links: LinksType) {`
`94`	`94`	`self.ids = ids`
`95`	`95`	`self.meta = meta`
`96`	`96`	`self.links = links`
`97`	`97`	`}`
`98`	`98`
`99`		`- public init<T: JSONAPI.Identifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>], meta: MetaType, links: LinksType) where T.Identifier == Relatable.Identifier {`
	`99`	`+ public init<T: JSONAPI.JSONAPIIdentifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>], meta: MetaType, links: LinksType) where T.ID == Relatable.ID {`
`100`	`100`	`ids = pointers.map(\.id)`
`101`	`101`	`self.meta = meta`
`102`	`102`	`self.links = links`
`103`	`103`	`}`
`104`	`104`
`105`		`- public init<T: ResourceObjectType>(resourceObjects: [T], meta: MetaType, links: LinksType) where T.Id == Relatable.Identifier {`
	`105`	`+ public init<T: ResourceObjectType>(resourceObjects: [T], meta: MetaType, links: LinksType) where T.Id == Relatable.ID {`
`106`	`106`	`self.init(ids: resourceObjects.map(\.id), meta: meta, links: links)`
`107`	`107`	`}`
`108`	`108`
`@@ -117,40 +117,40 @@ public struct ToManyRelationship<Relatable: JSONAPI.Relatable, MetaType: JSONAPI`
`117`	`117`
`118`	`118`	`extension ToManyRelationship where MetaType == NoMetadata, LinksType == NoLinks {`
`119`	`119`
`120`		`- public init(ids: [Relatable.Identifier]) {`
	`120`	`+ public init(ids: [Relatable.ID]) {`
`121`	`121`	`self.init(ids: ids, meta: .none, links: .none)`
`122`	`122`	`}`
`123`	`123`
`124`		`- public init<T: JSONAPI.Identifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>]) where T.Identifier == Relatable.Identifier {`
	`124`	`+ public init<T: JSONAPI.JSONAPIIdentifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>]) where T.ID == Relatable.ID {`
`125`	`125`	`self.init(pointers: pointers, meta: .none, links: .none)`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`public static var none: ToManyRelationship {`
`129`	`129`	`return .none(withMeta: .none, links: .none)`
`130`	`130`	`}`
`131`	`131`
`132`		`- public init<T: ResourceObjectType>(resourceObjects: [T]) where T.Id == Relatable.Identifier {`
	`132`	`+ public init<T: ResourceObjectType>(resourceObjects: [T]) where T.Id == Relatable.ID {`
`133`	`133`	`self.init(resourceObjects: resourceObjects, meta: .none, links: .none)`
`134`	`134`	`}`
`135`	`135`	`}`
`136`	`136`
`137`		`-public protocol Identifiable: JSONTyped {`
`138`		`- associatedtype Identifier: Equatable`
	`137`	`+public protocol JSONAPIIdentifiable: JSONTyped {`
	`138`	`+ associatedtype ID: Equatable`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`/// The Relatable protocol describes anything that`
`142`	`142`	`/// has an IdType Identifier`
`143`		`-public protocol Relatable: Identifiable where Identifier: JSONAPI.IdType {`
	`143`	`+public protocol Relatable: JSONAPIIdentifiable where ID: JSONAPI.IdType {`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`/// OptionalRelatable just describes an Optional`
`147`	`147`	`/// with a Reltable Wrapped type.`
`148`		`-public protocol OptionalRelatable: Identifiable where Identifier == Wrapped.Identifier? {`
	`148`	`+public protocol OptionalRelatable: JSONAPIIdentifiable where ID == Wrapped.ID? {`
`149`	`149`	`associatedtype Wrapped: JSONAPI.Relatable`
`150`	`150`	`}`
`151`	`151`
`152`		`-extension Optional: Identifiable, OptionalRelatable, JSONTyped where Wrapped: JSONAPI.Relatable {`
`153`		`- public typealias Identifier = Wrapped.Identifier?`
	`152`	`+extension Optional: JSONAPIIdentifiable, OptionalRelatable, JSONTyped where Wrapped: JSONAPI.Relatable {`
	`153`	`+ public typealias ID = Wrapped.ID?`
`154`	`154`
`155`	`155`	`public static var jsonType: String { return Wrapped.jsonType }`
`156`	`156`	`}`
`@@ -196,7 +196,7 @@ extension MetaRelationship: Codable {`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`199`		`-extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {`
	`199`	`+extension ToOneRelationship: Codable where Identifiable.ID: OptionalId {`
`200`	`200`	`public init(from decoder: Decoder) throws {`
`201`	`201`	`let container = try decoder.container(keyedBy: ResourceLinkageCodingKeys.self)`
`202`	`202`
`@@ -219,7 +219,7 @@ extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {`
`219`	`219`	// type at which point we can store nil in `id`.
`220`	`220`	`let anyNil: Any? = nil`
`221`	`221`	`if try container.decodeNil(forKey: .data) {`
`222`		`- guard let val = anyNil as? Identifiable.Identifier else {`
	`222`	`+ guard let val = anyNil as? Identifiable.ID else {`
`223`	`223`	`throw DecodingError.valueNotFound(`
`224`	`224`	`Self.self,`
`225`	`225`	`DecodingError.Context(`
`@@ -256,7 +256,7 @@ extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {`
`256`	`256`	`)`
`257`	`257`	`}`
`258`	`258`
`259`		`- id = Identifiable.Identifier(rawValue: try identifier.decode(Identifiable.Identifier.RawType.self, forKey: .id))`
	`259`	`+ id = Identifiable.ID(rawValue: try identifier.decode(Identifiable.ID.RawType.self, forKey: .id))`
`260`	`260`	`}`
`261`	`261`
`262`	`262`	`public func encode(to encoder: Encoder) throws {`
`@@ -273,7 +273,7 @@ extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {`
`273`	`273`	`// If id is nil, instead of {id: , type: } we will just`
`274`	`274`	// encode `null`
`275`	`275`	`let anyNil: Any? = nil`
`276`		`- let nilId = anyNil as? Identifiable.Identifier`
	`276`	`+ let nilId = anyNil as? Identifiable.ID`
`277`	`277`	`guard id != nilId else {`
`278`	`278`	`try container.encodeNil(forKey: .data)`
`279`	`279`	`return`
`@@ -314,7 +314,7 @@ extension ToManyRelationship: Codable {`
`314`	`314`	`path: context.codingPath)`
`315`	`315`	`}`
`316`	`316`
`317`		`- var newIds = [Relatable.Identifier]()`
	`317`	`+ var newIds = [Relatable.ID]()`
`318`	`318`	`while !identifiers.isAtEnd {`
`319`	`319`	`let identifier = try identifiers.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self)`
`320`	`320`
`@@ -324,7 +324,7 @@ extension ToManyRelationship: Codable {`
`324`	`324`	`throw JSONAPICodingError.typeMismatch(expected: Relatable.jsonType, found: type, path: decoder.codingPath)`
`325`	`325`	`}`
`326`	`326`
`327`		`- newIds.append(Relatable.Identifier(rawValue: try identifier.decode(Relatable.Identifier.RawType.self, forKey: .id)))`
	`327`	`+ newIds.append(Relatable.ID(rawValue: try identifier.decode(Relatable.ID.RawType.self, forKey: .id)))`
`328`	`328`	`}`
`329`	`329`	`ids = newIds`
`330`	`330`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,39 +7,39 @@`
`7`	`7`
`8`	`8`	`import JSONAPI`
`9`	`9`
`10`		`-extension ToOneRelationship: ExpressibleByNilLiteral where Identifiable.Identifier: ExpressibleByNilLiteral, MetaType == NoMetadata, LinksType == NoLinks {`
	`10`	`+extension ToOneRelationship: ExpressibleByNilLiteral where Identifiable.ID: ExpressibleByNilLiteral, MetaType == NoMetadata, LinksType == NoLinks {`
`11`	`11`	`public init(nilLiteral: ()) {`
`12`	`12`
`13`		`- self.init(id: Identifiable.Identifier(nilLiteral: ()))`
	`13`	`+ self.init(id: Identifiable.ID(nilLiteral: ()))`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
`17`		`-extension ToOneRelationship: ExpressibleByUnicodeScalarLiteral where Identifiable.Identifier: ExpressibleByUnicodeScalarLiteral, MetaType == NoMetadata, LinksType == NoLinks {`
`18`		`- public typealias UnicodeScalarLiteralType = Identifiable.Identifier.UnicodeScalarLiteralType`
	`17`	`+extension ToOneRelationship: ExpressibleByUnicodeScalarLiteral where Identifiable.ID: ExpressibleByUnicodeScalarLiteral, MetaType == NoMetadata, LinksType == NoLinks {`
	`18`	`+ public typealias UnicodeScalarLiteralType = Identifiable.ID.UnicodeScalarLiteralType`
`19`	`19`
`20`	`20`	`public init(unicodeScalarLiteral value: UnicodeScalarLiteralType) {`
`21`		`- self.init(id: Identifiable.Identifier(unicodeScalarLiteral: value))`
	`21`	`+ self.init(id: Identifiable.ID(unicodeScalarLiteral: value))`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`-extension ToOneRelationship: ExpressibleByExtendedGraphemeClusterLiteral where Identifiable.Identifier: ExpressibleByExtendedGraphemeClusterLiteral, MetaType == NoMetadata, LinksType == NoLinks {`
`26`		`- public typealias ExtendedGraphemeClusterLiteralType = Identifiable.Identifier.ExtendedGraphemeClusterLiteralType`
	`25`	`+extension ToOneRelationship: ExpressibleByExtendedGraphemeClusterLiteral where Identifiable.ID: ExpressibleByExtendedGraphemeClusterLiteral, MetaType == NoMetadata, LinksType == NoLinks {`
	`26`	`+ public typealias ExtendedGraphemeClusterLiteralType = Identifiable.ID.ExtendedGraphemeClusterLiteralType`
`27`	`27`
`28`	`28`	`public init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType) {`
`29`		`- self.init(id: Identifiable.Identifier(extendedGraphemeClusterLiteral: value))`
	`29`	`+ self.init(id: Identifiable.ID(extendedGraphemeClusterLiteral: value))`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`		`-extension ToOneRelationship: ExpressibleByStringLiteral where Identifiable.Identifier: ExpressibleByStringLiteral, MetaType == NoMetadata, LinksType == NoLinks {`
`34`		`- public typealias StringLiteralType = Identifiable.Identifier.StringLiteralType`
	`33`	`+extension ToOneRelationship: ExpressibleByStringLiteral where Identifiable.ID: ExpressibleByStringLiteral, MetaType == NoMetadata, LinksType == NoLinks {`
	`34`	`+ public typealias StringLiteralType = Identifiable.ID.StringLiteralType`
`35`	`35`
`36`	`36`	`public init(stringLiteral value: StringLiteralType) {`
`37`		`- self.init(id: Identifiable.Identifier(stringLiteral: value))`
	`37`	`+ self.init(id: Identifiable.ID(stringLiteral: value))`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`extension ToManyRelationship: ExpressibleByArrayLiteral where MetaType == NoMetadata, LinksType == NoLinks {`
`42`		`- public typealias ArrayLiteralElement = Relatable.Identifier`
	`42`	`+ public typealias ArrayLiteralElement = Relatable.ID`
`43`	`43`
`44`	`44`	`public init(arrayLiteral elements: ArrayLiteralElement...) {`
`45`	`45`	`self.init(ids: elements)`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ class ResourceObjectTests: XCTestCase {`
`91`	`91`	`let _ = TestEntity9(id: .init(rawValue: "9"), attributes: .none, relationships: .init(meta: .init(meta: .init(x: "hello", y: 5), links: .none), optionalMeta: nil, one: entity1.pointer, nullableOne: nil, optionalOne: entity1.pointer, optionalNullableOne: nil, optionalMany: nil), meta: .none, links: .none)`
`92`	`92`	`let _ = TestEntity9(id: .init(rawValue: "9"), attributes: .none, relationships: .init(meta: .init(meta: .init(x: "hello", y: 5), links: .none), optionalMeta: nil, one: entity1.pointer, nullableOne: nil, optionalOne: nil, optionalNullableOne: .init(resourceObject: entity1, meta: .none, links: .none), optionalMany: nil), meta: .none, links: .none)`
`93`	`93`	`let _ = TestEntity9(id: .init(rawValue: "9"), attributes: .none, relationships: .init(meta: .init(meta: .init(x: "hello", y: 5), links: .none), optionalMeta: nil, one: entity1.pointer, nullableOne: nil, optionalOne: nil, optionalNullableOne: .init(resourceObject: entity1, meta: .none, links: .none), optionalMany: .init(resourceObjects: [], meta: .none, links: .none)), meta: .none, links: .none)`
`94`		`- let e10id1 = TestEntity10.Identifier(rawValue: "hello")`
	`94`	`+ let e10id1 = TestEntity10.ID(rawValue: "hello")`
`95`	`95`	`let e10id2 = TestEntity10.Id(rawValue: "world")`
`96`	`96`	`let e10id3: TestEntity10.Id = "!"`
`97`	`97`	`let _ = TestEntity10(id: .init(rawValue: "10"), attributes: .none, relationships: .init(selfRef: .init(id: e10id1), selfRefs: .init(ids: [e10id2, e10id3])), meta: .none, links: .none)`
`@@ -901,15 +901,15 @@ extension ResourceObjectTests {`
`901`	`901`	`typealias Attributes = NoAttributes`
`902`	`902`
`903`	`903`	`struct Relationships: JSONAPI.Relationships {`
`904`		`- var metaRelationship: (TestEntityWithMetaRelationship) -> TestEntity1.Identifier {`
	`904`	`+ var metaRelationship: (TestEntityWithMetaRelationship) -> TestEntity1.ID {`
`905`	`905`	`return { entity in`
`906`		`- return TestEntity1.Identifier(rawValue: "hello")`
	`906`	`+ return TestEntity1.ID(rawValue: "hello")`
`907`	`907`	`}`
`908`	`908`	`}`
`909`	`909`
`910`		`- var toManyMetaRelationship: (TestEntityWithMetaRelationship) -> [TestEntity1.Identifier] {`
	`910`	`+ var toManyMetaRelationship: (TestEntityWithMetaRelationship) -> [TestEntity1.ID] {`
`911`	`911`	`return { entity in`
`912`		`- return [TestEntity1.Identifier.id(from: "hello")]`
	`912`	`+ return [TestEntity1.ID.id(from: "hello")]`
`913`	`913`	`}`
`914`	`914`	`}`
`915`	`915`	`}`