// Generated using Sourcery 1.0.0 — https://github.com/krzysztofzablocki/Sourcery
// DO NOT EDIT

// swiftlint:disable file_length
// swiftlint:disable function_parameter_count
// swiftlint:disable large_tuple
// swiftlint:disable line_length
// swiftlint:disable multiline_parameters

// MARK: - Family 1

public typealias Family1<Comp1> = Family<Requires1<Comp1>> where Comp1: Component

public protocol RequiringComponents1: FamilyRequirementsManaging where Components == (Comp1) {
    associatedtype Comp1: Component
}

public struct Requires1<Comp1>: FamilyRequirementsManaging where Comp1: Component {
    public let componentTypes: [Component.Type]

    public init(_ components: (Comp1.Type)) {
        componentTypes = [Comp1.self]
    }

    public static func components(nexus: Nexus, entityId: EntityIdentifier) -> (Comp1) {
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        return (comp1)
    }

    public static func entityAndComponents(nexus: Nexus, entityId: EntityIdentifier) -> (Entity, Comp1) {
        let entity = Entity(nexus: nexus, id: entityId)
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        return (entity, comp1)
    }

    public static func createMember(nexus: Nexus, components: (Comp1)) -> Entity {
        nexus.createEntity(with: components)
    }
}

extension Requires1: RequiringComponents1 { }

extension FamilyMemberBuilder where R: RequiringComponents1 {
    public static func buildBlock(_ comp1: R.Comp1) -> (R.Components) {
        (comp1)
    }
}

extension Requires1: FamilyEncoding where Comp1: Encodable {
    public static func encode(components: (Comp1), into container: inout KeyedEncodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws {
        try container.encode(components, forKey: strategy.codingKey(for: Comp1.self))
    }
}

extension Requires1: FamilyDecoding where Comp1: Decodable {
    public static func decode(componentsIn container: KeyedDecodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws -> (Comp1) {
        let comp1 = try container.decode(Comp1.self, forKey: strategy.codingKey(for: Comp1.self))
        return comp1
    }
}

extension Nexus {
    /// Create a family of entities (aka members) having 1 required components.
    ///
    /// A family is a collection of entities with uniform component types per entity.
    /// Entities that are be part of this family will have at least the 1 required components,
    /// but may have more components assigned.
    ///
    /// A family is just a view on (component) data, creating them is cheap.
    /// Use them to iterate efficiently over entities with the same components assigned.
    /// Families with the same requirements provide a view on the same collection of entities (aka members).
    /// A family conforms to the `LazySequenceProtocol` and therefore can be accessed like any other (lazy) sequence.
    ///
    /// **General usage**
    /// ```swift
    /// let family = nexus.family(requires: Comp1.self)
    /// // iterate each entity's components
    /// family.forEach { (comp1) in
    ///   ...
    /// }
    /// ```
    /// **Caveats**
    /// - Component types must be unique per family
    /// - Component type order is arbitrary
    ///
    /// - Parameters:
    ///   - comp1: Component type 1 required by members of this family.
    ///   - excludedComponents: All component types that must not be assigned to an entity in this family.
    /// - Returns: The family of entities having 1 required components each.
    public func family<Comp1>(
        requires comp1: Comp1.Type,
        excludesAll excludedComponents: Component.Type...
    ) -> Family1<Comp1> where Comp1: Component {
        Family1<Comp1>(
            nexus: self,
            requiresAll: (comp1),
            excludesAll: excludedComponents
        )
    }
}

// MARK: - Family 2

public typealias Family2<Comp1, Comp2> = Family<Requires2<Comp1, Comp2>> where Comp1: Component, Comp2: Component

public protocol RequiringComponents2: FamilyRequirementsManaging where Components == (Comp1, Comp2) {
    associatedtype Comp1: Component
    associatedtype Comp2: Component
}

public struct Requires2<Comp1, Comp2>: FamilyRequirementsManaging where Comp1: Component, Comp2: Component {
    public let componentTypes: [Component.Type]

    public init(_ components: (Comp1.Type, Comp2.Type)) {
        componentTypes = [Comp1.self, Comp2.self]
    }

    public static func components(nexus: Nexus, entityId: EntityIdentifier) -> (Comp1, Comp2) {
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        return (comp1, comp2)
    }

    public static func entityAndComponents(nexus: Nexus, entityId: EntityIdentifier) -> (Entity, Comp1, Comp2) {
        let entity = Entity(nexus: nexus, id: entityId)
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        return (entity, comp1, comp2)
    }

    public static func createMember(nexus: Nexus, components: (Comp1, Comp2)) -> Entity {
        nexus.createEntity(with: components.0, components.1)
    }
}

extension Requires2: RequiringComponents2 { }

extension FamilyMemberBuilder where R: RequiringComponents2 {
    public static func buildBlock(_ comp1: R.Comp1, _ comp2: R.Comp2) -> (R.Components) {
        (comp1, comp2)
    }
}

extension Requires2: FamilyEncoding where Comp1: Encodable, Comp2: Encodable {
    public static func encode(components: (Comp1, Comp2), into container: inout KeyedEncodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws {
        try container.encode(components.0, forKey: strategy.codingKey(for: Comp1.self))
        try container.encode(components.1, forKey: strategy.codingKey(for: Comp2.self))
    }
}

extension Requires2: FamilyDecoding where Comp1: Decodable, Comp2: Decodable {
    public static func decode(componentsIn container: KeyedDecodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws -> (Comp1, Comp2) {
        let comp1 = try container.decode(Comp1.self, forKey: strategy.codingKey(for: Comp1.self))
        let comp2 = try container.decode(Comp2.self, forKey: strategy.codingKey(for: Comp2.self))
        return Components(comp1, comp2)
    }
}

extension Nexus {
    /// Create a family of entities (aka members) having 2 required components.
    ///
    /// A family is a collection of entities with uniform component types per entity.
    /// Entities that are be part of this family will have at least the 2 required components,
    /// but may have more components assigned.
    ///
    /// A family is just a view on (component) data, creating them is cheap.
    /// Use them to iterate efficiently over entities with the same components assigned.
    /// Families with the same requirements provide a view on the same collection of entities (aka members).
    /// A family conforms to the `LazySequenceProtocol` and therefore can be accessed like any other (lazy) sequence.
    ///
    /// **General usage**
    /// ```swift
    /// let family = nexus.family(requiresAll: Comp1.self, Comp2.self)
    /// // iterate each entity's components
    /// family.forEach { (comp1, comp2) in
    ///   ...
    /// }
    /// ```
    /// **Caveats**
    /// - Component types must be unique per family
    /// - Component type order is arbitrary
    ///
    /// - Parameters:
    ///   - comp1: Component type 1 required by members of this family.
    ///   - comp2: Component type 2 required by members of this family.
    ///   - excludedComponents: All component types that must not be assigned to an entity in this family.
    /// - Returns: The family of entities having 2 required components each.
    public func family<Comp1, Comp2>(
        requiresAll comp1: Comp1.Type, _ comp2: Comp2.Type,
        excludesAll excludedComponents: Component.Type...
    ) -> Family2<Comp1, Comp2> where Comp1: Component, Comp2: Component {
        Family2<Comp1, Comp2>(
            nexus: self,
            requiresAll: (comp1, comp2),
            excludesAll: excludedComponents
        )
    }
}

// MARK: - Family 3

public typealias Family3<Comp1, Comp2, Comp3> = Family<Requires3<Comp1, Comp2, Comp3>> where Comp1: Component, Comp2: Component, Comp3: Component

public protocol RequiringComponents3: FamilyRequirementsManaging where Components == (Comp1, Comp2, Comp3) {
    associatedtype Comp1: Component
    associatedtype Comp2: Component
    associatedtype Comp3: Component
}

public struct Requires3<Comp1, Comp2, Comp3>: FamilyRequirementsManaging where Comp1: Component, Comp2: Component, Comp3: Component {
    public let componentTypes: [Component.Type]

    public init(_ components: (Comp1.Type, Comp2.Type, Comp3.Type)) {
        componentTypes = [Comp1.self, Comp2.self, Comp3.self]
    }

    public static func components(nexus: Nexus, entityId: EntityIdentifier) -> (Comp1, Comp2, Comp3) {
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        return (comp1, comp2, comp3)
    }

    public static func entityAndComponents(nexus: Nexus, entityId: EntityIdentifier) -> (Entity, Comp1, Comp2, Comp3) {
        let entity = Entity(nexus: nexus, id: entityId)
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        return (entity, comp1, comp2, comp3)
    }

    public static func createMember(nexus: Nexus, components: (Comp1, Comp2, Comp3)) -> Entity {
        nexus.createEntity(with: components.0, components.1, components.2)
    }
}

extension Requires3: RequiringComponents3 { }

extension FamilyMemberBuilder where R: RequiringComponents3 {
    public static func buildBlock(_ comp1: R.Comp1, _ comp2: R.Comp2, _ comp3: R.Comp3) -> (R.Components) {
        (comp1, comp2, comp3)
    }
}

extension Requires3: FamilyEncoding where Comp1: Encodable, Comp2: Encodable, Comp3: Encodable {
    public static func encode(components: (Comp1, Comp2, Comp3), into container: inout KeyedEncodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws {
        try container.encode(components.0, forKey: strategy.codingKey(for: Comp1.self))
        try container.encode(components.1, forKey: strategy.codingKey(for: Comp2.self))
        try container.encode(components.2, forKey: strategy.codingKey(for: Comp3.self))
    }
}

extension Requires3: FamilyDecoding where Comp1: Decodable, Comp2: Decodable, Comp3: Decodable {
    public static func decode(componentsIn container: KeyedDecodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws -> (Comp1, Comp2, Comp3) {
        let comp1 = try container.decode(Comp1.self, forKey: strategy.codingKey(for: Comp1.self))
        let comp2 = try container.decode(Comp2.self, forKey: strategy.codingKey(for: Comp2.self))
        let comp3 = try container.decode(Comp3.self, forKey: strategy.codingKey(for: Comp3.self))
        return Components(comp1, comp2, comp3)
    }
}

extension Nexus {
    /// Create a family of entities (aka members) having 3 required components.
    ///
    /// A family is a collection of entities with uniform component types per entity.
    /// Entities that are be part of this family will have at least the 3 required components,
    /// but may have more components assigned.
    ///
    /// A family is just a view on (component) data, creating them is cheap.
    /// Use them to iterate efficiently over entities with the same components assigned.
    /// Families with the same requirements provide a view on the same collection of entities (aka members).
    /// A family conforms to the `LazySequenceProtocol` and therefore can be accessed like any other (lazy) sequence.
    ///
    /// **General usage**
    /// ```swift
    /// let family = nexus.family(requiresAll: Comp1.self, Comp2.self, Comp3.self)
    /// // iterate each entity's components
    /// family.forEach { (comp1, comp2, comp3) in
    ///   ...
    /// }
    /// ```
    /// **Caveats**
    /// - Component types must be unique per family
    /// - Component type order is arbitrary
    ///
    /// - Parameters:
    ///   - comp1: Component type 1 required by members of this family.
    ///   - comp2: Component type 2 required by members of this family.
    ///   - comp3: Component type 3 required by members of this family.
    ///   - excludedComponents: All component types that must not be assigned to an entity in this family.
    /// - Returns: The family of entities having 3 required components each.
    public func family<Comp1, Comp2, Comp3>(
        requiresAll comp1: Comp1.Type, _ comp2: Comp2.Type, _ comp3: Comp3.Type,
        excludesAll excludedComponents: Component.Type...
    ) -> Family3<Comp1, Comp2, Comp3> where Comp1: Component, Comp2: Component, Comp3: Component {
        Family3<Comp1, Comp2, Comp3>(
            nexus: self,
            requiresAll: (comp1, comp2, comp3),
            excludesAll: excludedComponents
        )
    }
}

// MARK: - Family 4

public typealias Family4<Comp1, Comp2, Comp3, Comp4> = Family<Requires4<Comp1, Comp2, Comp3, Comp4>> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component

public protocol RequiringComponents4: FamilyRequirementsManaging where Components == (Comp1, Comp2, Comp3, Comp4) {
    associatedtype Comp1: Component
    associatedtype Comp2: Component
    associatedtype Comp3: Component
    associatedtype Comp4: Component
}

public struct Requires4<Comp1, Comp2, Comp3, Comp4>: FamilyRequirementsManaging where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component {
    public let componentTypes: [Component.Type]

    public init(_ components: (Comp1.Type, Comp2.Type, Comp3.Type, Comp4.Type)) {
        componentTypes = [Comp1.self, Comp2.self, Comp3.self, Comp4.self]
    }

    public static func components(nexus: Nexus, entityId: EntityIdentifier) -> (Comp1, Comp2, Comp3, Comp4) {
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        return (comp1, comp2, comp3, comp4)
    }

    public static func entityAndComponents(nexus: Nexus, entityId: EntityIdentifier) -> (Entity, Comp1, Comp2, Comp3, Comp4) {
        let entity = Entity(nexus: nexus, id: entityId)
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        return (entity, comp1, comp2, comp3, comp4)
    }

    public static func createMember(nexus: Nexus, components: (Comp1, Comp2, Comp3, Comp4)) -> Entity {
        nexus.createEntity(with: components.0, components.1, components.2, components.3)
    }
}

extension Requires4: RequiringComponents4 { }

extension FamilyMemberBuilder where R: RequiringComponents4 {
    public static func buildBlock(_ comp1: R.Comp1, _ comp2: R.Comp2, _ comp3: R.Comp3, _ comp4: R.Comp4) -> (R.Components) {
        (comp1, comp2, comp3, comp4)
    }
}

extension Requires4: FamilyEncoding where Comp1: Encodable, Comp2: Encodable, Comp3: Encodable, Comp4: Encodable {
    public static func encode(components: (Comp1, Comp2, Comp3, Comp4), into container: inout KeyedEncodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws {
        try container.encode(components.0, forKey: strategy.codingKey(for: Comp1.self))
        try container.encode(components.1, forKey: strategy.codingKey(for: Comp2.self))
        try container.encode(components.2, forKey: strategy.codingKey(for: Comp3.self))
        try container.encode(components.3, forKey: strategy.codingKey(for: Comp4.self))
    }
}

extension Requires4: FamilyDecoding where Comp1: Decodable, Comp2: Decodable, Comp3: Decodable, Comp4: Decodable {
    public static func decode(componentsIn container: KeyedDecodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws -> (Comp1, Comp2, Comp3, Comp4) {
        let comp1 = try container.decode(Comp1.self, forKey: strategy.codingKey(for: Comp1.self))
        let comp2 = try container.decode(Comp2.self, forKey: strategy.codingKey(for: Comp2.self))
        let comp3 = try container.decode(Comp3.self, forKey: strategy.codingKey(for: Comp3.self))
        let comp4 = try container.decode(Comp4.self, forKey: strategy.codingKey(for: Comp4.self))
        return Components(comp1, comp2, comp3, comp4)
    }
}

extension Nexus {
    /// Create a family of entities (aka members) having 4 required components.
    ///
    /// A family is a collection of entities with uniform component types per entity.
    /// Entities that are be part of this family will have at least the 4 required components,
    /// but may have more components assigned.
    ///
    /// A family is just a view on (component) data, creating them is cheap.
    /// Use them to iterate efficiently over entities with the same components assigned.
    /// Families with the same requirements provide a view on the same collection of entities (aka members).
    /// A family conforms to the `LazySequenceProtocol` and therefore can be accessed like any other (lazy) sequence.
    ///
    /// **General usage**
    /// ```swift
    /// let family = nexus.family(requiresAll: Comp1.self, Comp2.self, Comp3.self, Comp4.self)
    /// // iterate each entity's components
    /// family.forEach { (comp1, comp2, comp3, comp4) in
    ///   ...
    /// }
    /// ```
    /// **Caveats**
    /// - Component types must be unique per family
    /// - Component type order is arbitrary
    ///
    /// - Parameters:
    ///   - comp1: Component type 1 required by members of this family.
    ///   - comp2: Component type 2 required by members of this family.
    ///   - comp3: Component type 3 required by members of this family.
    ///   - comp4: Component type 4 required by members of this family.
    ///   - excludedComponents: All component types that must not be assigned to an entity in this family.
    /// - Returns: The family of entities having 4 required components each.
    public func family<Comp1, Comp2, Comp3, Comp4>(
        requiresAll comp1: Comp1.Type, _ comp2: Comp2.Type, _ comp3: Comp3.Type, _ comp4: Comp4.Type,
        excludesAll excludedComponents: Component.Type...
    ) -> Family4<Comp1, Comp2, Comp3, Comp4> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component {
        Family4<Comp1, Comp2, Comp3, Comp4>(
            nexus: self,
            requiresAll: (comp1, comp2, comp3, comp4),
            excludesAll: excludedComponents
        )
    }
}

// MARK: - Family 5

public typealias Family5<Comp1, Comp2, Comp3, Comp4, Comp5> = Family<Requires5<Comp1, Comp2, Comp3, Comp4, Comp5>> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component

public protocol RequiringComponents5: FamilyRequirementsManaging where Components == (Comp1, Comp2, Comp3, Comp4, Comp5) {
    associatedtype Comp1: Component
    associatedtype Comp2: Component
    associatedtype Comp3: Component
    associatedtype Comp4: Component
    associatedtype Comp5: Component
}

public struct Requires5<Comp1, Comp2, Comp3, Comp4, Comp5>: FamilyRequirementsManaging where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component {
    public let componentTypes: [Component.Type]

    public init(_ components: (Comp1.Type, Comp2.Type, Comp3.Type, Comp4.Type, Comp5.Type)) {
        componentTypes = [Comp1.self, Comp2.self, Comp3.self, Comp4.self, Comp5.self]
    }

    public static func components(nexus: Nexus, entityId: EntityIdentifier) -> (Comp1, Comp2, Comp3, Comp4, Comp5) {
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        let comp5: Comp5 = nexus.get(unsafeComponentFor: entityId)
        return (comp1, comp2, comp3, comp4, comp5)
    }

    public static func entityAndComponents(nexus: Nexus, entityId: EntityIdentifier) -> (Entity, Comp1, Comp2, Comp3, Comp4, Comp5) {
        let entity = Entity(nexus: nexus, id: entityId)
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        let comp5: Comp5 = nexus.get(unsafeComponentFor: entityId)
        return (entity, comp1, comp2, comp3, comp4, comp5)
    }

    public static func createMember(nexus: Nexus, components: (Comp1, Comp2, Comp3, Comp4, Comp5)) -> Entity {
        nexus.createEntity(with: components.0, components.1, components.2, components.3, components.4)
    }
}

extension Requires5: RequiringComponents5 { }

extension FamilyMemberBuilder where R: RequiringComponents5 {
    public static func buildBlock(_ comp1: R.Comp1, _ comp2: R.Comp2, _ comp3: R.Comp3, _ comp4: R.Comp4, _ comp5: R.Comp5) -> (R.Components) {
        (comp1, comp2, comp3, comp4, comp5)
    }
}

extension Requires5: FamilyEncoding where Comp1: Encodable, Comp2: Encodable, Comp3: Encodable, Comp4: Encodable, Comp5: Encodable {
    public static func encode(components: (Comp1, Comp2, Comp3, Comp4, Comp5), into container: inout KeyedEncodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws {
        try container.encode(components.0, forKey: strategy.codingKey(for: Comp1.self))
        try container.encode(components.1, forKey: strategy.codingKey(for: Comp2.self))
        try container.encode(components.2, forKey: strategy.codingKey(for: Comp3.self))
        try container.encode(components.3, forKey: strategy.codingKey(for: Comp4.self))
        try container.encode(components.4, forKey: strategy.codingKey(for: Comp5.self))
    }
}

extension Requires5: FamilyDecoding where Comp1: Decodable, Comp2: Decodable, Comp3: Decodable, Comp4: Decodable, Comp5: Decodable {
    public static func decode(componentsIn container: KeyedDecodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws -> (Comp1, Comp2, Comp3, Comp4, Comp5) {
        let comp1 = try container.decode(Comp1.self, forKey: strategy.codingKey(for: Comp1.self))
        let comp2 = try container.decode(Comp2.self, forKey: strategy.codingKey(for: Comp2.self))
        let comp3 = try container.decode(Comp3.self, forKey: strategy.codingKey(for: Comp3.self))
        let comp4 = try container.decode(Comp4.self, forKey: strategy.codingKey(for: Comp4.self))
        let comp5 = try container.decode(Comp5.self, forKey: strategy.codingKey(for: Comp5.self))
        return Components(comp1, comp2, comp3, comp4, comp5)
    }
}

extension Nexus {
    /// Create a family of entities (aka members) having 5 required components.
    ///
    /// A family is a collection of entities with uniform component types per entity.
    /// Entities that are be part of this family will have at least the 5 required components,
    /// but may have more components assigned.
    ///
    /// A family is just a view on (component) data, creating them is cheap.
    /// Use them to iterate efficiently over entities with the same components assigned.
    /// Families with the same requirements provide a view on the same collection of entities (aka members).
    /// A family conforms to the `LazySequenceProtocol` and therefore can be accessed like any other (lazy) sequence.
    ///
    /// **General usage**
    /// ```swift
    /// let family = nexus.family(requiresAll: Comp1.self, Comp2.self, Comp3.self, Comp4.self, Comp5.self)
    /// // iterate each entity's components
    /// family.forEach { (comp1, comp2, comp3, comp4, comp5) in
    ///   ...
    /// }
    /// ```
    /// **Caveats**
    /// - Component types must be unique per family
    /// - Component type order is arbitrary
    ///
    /// - Parameters:
    ///   - comp1: Component type 1 required by members of this family.
    ///   - comp2: Component type 2 required by members of this family.
    ///   - comp3: Component type 3 required by members of this family.
    ///   - comp4: Component type 4 required by members of this family.
    ///   - comp5: Component type 5 required by members of this family.
    ///   - excludedComponents: All component types that must not be assigned to an entity in this family.
    /// - Returns: The family of entities having 5 required components each.
    public func family<Comp1, Comp2, Comp3, Comp4, Comp5>(
        requiresAll comp1: Comp1.Type, _ comp2: Comp2.Type, _ comp3: Comp3.Type, _ comp4: Comp4.Type, _ comp5: Comp5.Type,
        excludesAll excludedComponents: Component.Type...
    ) -> Family5<Comp1, Comp2, Comp3, Comp4, Comp5> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component {
        Family5<Comp1, Comp2, Comp3, Comp4, Comp5>(
            nexus: self,
            requiresAll: (comp1, comp2, comp3, comp4, comp5),
            excludesAll: excludedComponents
        )
    }
}

// MARK: - Family 6

public typealias Family6<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6> = Family<Requires6<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6>> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component, Comp6: Component

public protocol RequiringComponents6: FamilyRequirementsManaging where Components == (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6) {
    associatedtype Comp1: Component
    associatedtype Comp2: Component
    associatedtype Comp3: Component
    associatedtype Comp4: Component
    associatedtype Comp5: Component
    associatedtype Comp6: Component
}

public struct Requires6<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6>: FamilyRequirementsManaging where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component, Comp6: Component {
    public let componentTypes: [Component.Type]

    public init(_ components: (Comp1.Type, Comp2.Type, Comp3.Type, Comp4.Type, Comp5.Type, Comp6.Type)) {
        componentTypes = [Comp1.self, Comp2.self, Comp3.self, Comp4.self, Comp5.self, Comp6.self]
    }

    public static func components(nexus: Nexus, entityId: EntityIdentifier) -> (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6) {
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        let comp5: Comp5 = nexus.get(unsafeComponentFor: entityId)
        let comp6: Comp6 = nexus.get(unsafeComponentFor: entityId)
        return (comp1, comp2, comp3, comp4, comp5, comp6)
    }

    public static func entityAndComponents(nexus: Nexus, entityId: EntityIdentifier) -> (Entity, Comp1, Comp2, Comp3, Comp4, Comp5, Comp6) {
        let entity = Entity(nexus: nexus, id: entityId)
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        let comp5: Comp5 = nexus.get(unsafeComponentFor: entityId)
        let comp6: Comp6 = nexus.get(unsafeComponentFor: entityId)
        return (entity, comp1, comp2, comp3, comp4, comp5, comp6)
    }

    public static func createMember(nexus: Nexus, components: (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6)) -> Entity {
        nexus.createEntity(with: components.0, components.1, components.2, components.3, components.4, components.5)
    }
}

extension Requires6: RequiringComponents6 { }

extension FamilyMemberBuilder where R: RequiringComponents6 {
    public static func buildBlock(_ comp1: R.Comp1, _ comp2: R.Comp2, _ comp3: R.Comp3, _ comp4: R.Comp4, _ comp5: R.Comp5, _ comp6: R.Comp6) -> (R.Components) {
        (comp1, comp2, comp3, comp4, comp5, comp6)
    }
}

extension Requires6: FamilyEncoding where Comp1: Encodable, Comp2: Encodable, Comp3: Encodable, Comp4: Encodable, Comp5: Encodable, Comp6: Encodable {
    public static func encode(components: (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6), into container: inout KeyedEncodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws {
        try container.encode(components.0, forKey: strategy.codingKey(for: Comp1.self))
        try container.encode(components.1, forKey: strategy.codingKey(for: Comp2.self))
        try container.encode(components.2, forKey: strategy.codingKey(for: Comp3.self))
        try container.encode(components.3, forKey: strategy.codingKey(for: Comp4.self))
        try container.encode(components.4, forKey: strategy.codingKey(for: Comp5.self))
        try container.encode(components.5, forKey: strategy.codingKey(for: Comp6.self))
    }
}

extension Requires6: FamilyDecoding where Comp1: Decodable, Comp2: Decodable, Comp3: Decodable, Comp4: Decodable, Comp5: Decodable, Comp6: Decodable {
    public static func decode(componentsIn container: KeyedDecodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws -> (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6) {
        let comp1 = try container.decode(Comp1.self, forKey: strategy.codingKey(for: Comp1.self))
        let comp2 = try container.decode(Comp2.self, forKey: strategy.codingKey(for: Comp2.self))
        let comp3 = try container.decode(Comp3.self, forKey: strategy.codingKey(for: Comp3.self))
        let comp4 = try container.decode(Comp4.self, forKey: strategy.codingKey(for: Comp4.self))
        let comp5 = try container.decode(Comp5.self, forKey: strategy.codingKey(for: Comp5.self))
        let comp6 = try container.decode(Comp6.self, forKey: strategy.codingKey(for: Comp6.self))
        return Components(comp1, comp2, comp3, comp4, comp5, comp6)
    }
}

extension Nexus {
    /// Create a family of entities (aka members) having 6 required components.
    ///
    /// A family is a collection of entities with uniform component types per entity.
    /// Entities that are be part of this family will have at least the 6 required components,
    /// but may have more components assigned.
    ///
    /// A family is just a view on (component) data, creating them is cheap.
    /// Use them to iterate efficiently over entities with the same components assigned.
    /// Families with the same requirements provide a view on the same collection of entities (aka members).
    /// A family conforms to the `LazySequenceProtocol` and therefore can be accessed like any other (lazy) sequence.
    ///
    /// **General usage**
    /// ```swift
    /// let family = nexus.family(requiresAll: Comp1.self, Comp2.self, Comp3.self, Comp4.self, Comp5.self, Comp6.self)
    /// // iterate each entity's components
    /// family.forEach { (comp1, comp2, comp3, comp4, comp5, comp6) in
    ///   ...
    /// }
    /// ```
    /// **Caveats**
    /// - Component types must be unique per family
    /// - Component type order is arbitrary
    ///
    /// - Parameters:
    ///   - comp1: Component type 1 required by members of this family.
    ///   - comp2: Component type 2 required by members of this family.
    ///   - comp3: Component type 3 required by members of this family.
    ///   - comp4: Component type 4 required by members of this family.
    ///   - comp5: Component type 5 required by members of this family.
    ///   - comp6: Component type 6 required by members of this family.
    ///   - excludedComponents: All component types that must not be assigned to an entity in this family.
    /// - Returns: The family of entities having 6 required components each.
    public func family<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6>(
        requiresAll comp1: Comp1.Type, _ comp2: Comp2.Type, _ comp3: Comp3.Type, _ comp4: Comp4.Type, _ comp5: Comp5.Type, _ comp6: Comp6.Type,
        excludesAll excludedComponents: Component.Type...
    ) -> Family6<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component, Comp6: Component {
        Family6<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6>(
            nexus: self,
            requiresAll: (comp1, comp2, comp3, comp4, comp5, comp6),
            excludesAll: excludedComponents
        )
    }
}

// MARK: - Family 7

public typealias Family7<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7> = Family<Requires7<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7>> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component, Comp6: Component, Comp7: Component

public protocol RequiringComponents7: FamilyRequirementsManaging where Components == (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7) {
    associatedtype Comp1: Component
    associatedtype Comp2: Component
    associatedtype Comp3: Component
    associatedtype Comp4: Component
    associatedtype Comp5: Component
    associatedtype Comp6: Component
    associatedtype Comp7: Component
}

public struct Requires7<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7>: FamilyRequirementsManaging where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component, Comp6: Component, Comp7: Component {
    public let componentTypes: [Component.Type]

    public init(_ components: (Comp1.Type, Comp2.Type, Comp3.Type, Comp4.Type, Comp5.Type, Comp6.Type, Comp7.Type)) {
        componentTypes = [Comp1.self, Comp2.self, Comp3.self, Comp4.self, Comp5.self, Comp6.self, Comp7.self]
    }

    public static func components(nexus: Nexus, entityId: EntityIdentifier) -> (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7) {
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        let comp5: Comp5 = nexus.get(unsafeComponentFor: entityId)
        let comp6: Comp6 = nexus.get(unsafeComponentFor: entityId)
        let comp7: Comp7 = nexus.get(unsafeComponentFor: entityId)
        return (comp1, comp2, comp3, comp4, comp5, comp6, comp7)
    }

    public static func entityAndComponents(nexus: Nexus, entityId: EntityIdentifier) -> (Entity, Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7) {
        let entity = Entity(nexus: nexus, id: entityId)
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        let comp5: Comp5 = nexus.get(unsafeComponentFor: entityId)
        let comp6: Comp6 = nexus.get(unsafeComponentFor: entityId)
        let comp7: Comp7 = nexus.get(unsafeComponentFor: entityId)
        return (entity, comp1, comp2, comp3, comp4, comp5, comp6, comp7)
    }

    public static func createMember(nexus: Nexus, components: (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7)) -> Entity {
        nexus.createEntity(with: components.0, components.1, components.2, components.3, components.4, components.5, components.6)
    }
}

extension Requires7: RequiringComponents7 { }

extension FamilyMemberBuilder where R: RequiringComponents7 {
    public static func buildBlock(_ comp1: R.Comp1, _ comp2: R.Comp2, _ comp3: R.Comp3, _ comp4: R.Comp4, _ comp5: R.Comp5, _ comp6: R.Comp6, _ comp7: R.Comp7) -> (R.Components) {
        (comp1, comp2, comp3, comp4, comp5, comp6, comp7)
    }
}

extension Requires7: FamilyEncoding where Comp1: Encodable, Comp2: Encodable, Comp3: Encodable, Comp4: Encodable, Comp5: Encodable, Comp6: Encodable, Comp7: Encodable {
    public static func encode(components: (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7), into container: inout KeyedEncodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws {
        try container.encode(components.0, forKey: strategy.codingKey(for: Comp1.self))
        try container.encode(components.1, forKey: strategy.codingKey(for: Comp2.self))
        try container.encode(components.2, forKey: strategy.codingKey(for: Comp3.self))
        try container.encode(components.3, forKey: strategy.codingKey(for: Comp4.self))
        try container.encode(components.4, forKey: strategy.codingKey(for: Comp5.self))
        try container.encode(components.5, forKey: strategy.codingKey(for: Comp6.self))
        try container.encode(components.6, forKey: strategy.codingKey(for: Comp7.self))
    }
}

extension Requires7: FamilyDecoding where Comp1: Decodable, Comp2: Decodable, Comp3: Decodable, Comp4: Decodable, Comp5: Decodable, Comp6: Decodable, Comp7: Decodable {
    public static func decode(componentsIn container: KeyedDecodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws -> (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7) {
        let comp1 = try container.decode(Comp1.self, forKey: strategy.codingKey(for: Comp1.self))
        let comp2 = try container.decode(Comp2.self, forKey: strategy.codingKey(for: Comp2.self))
        let comp3 = try container.decode(Comp3.self, forKey: strategy.codingKey(for: Comp3.self))
        let comp4 = try container.decode(Comp4.self, forKey: strategy.codingKey(for: Comp4.self))
        let comp5 = try container.decode(Comp5.self, forKey: strategy.codingKey(for: Comp5.self))
        let comp6 = try container.decode(Comp6.self, forKey: strategy.codingKey(for: Comp6.self))
        let comp7 = try container.decode(Comp7.self, forKey: strategy.codingKey(for: Comp7.self))
        return Components(comp1, comp2, comp3, comp4, comp5, comp6, comp7)
    }
}

extension Nexus {
    /// Create a family of entities (aka members) having 7 required components.
    ///
    /// A family is a collection of entities with uniform component types per entity.
    /// Entities that are be part of this family will have at least the 7 required components,
    /// but may have more components assigned.
    ///
    /// A family is just a view on (component) data, creating them is cheap.
    /// Use them to iterate efficiently over entities with the same components assigned.
    /// Families with the same requirements provide a view on the same collection of entities (aka members).
    /// A family conforms to the `LazySequenceProtocol` and therefore can be accessed like any other (lazy) sequence.
    ///
    /// **General usage**
    /// ```swift
    /// let family = nexus.family(requiresAll: Comp1.self, Comp2.self, Comp3.self, Comp4.self, Comp5.self, Comp6.self, Comp7.self)
    /// // iterate each entity's components
    /// family.forEach { (comp1, comp2, comp3, comp4, comp5, comp6, comp7) in
    ///   ...
    /// }
    /// ```
    /// **Caveats**
    /// - Component types must be unique per family
    /// - Component type order is arbitrary
    ///
    /// - Parameters:
    ///   - comp1: Component type 1 required by members of this family.
    ///   - comp2: Component type 2 required by members of this family.
    ///   - comp3: Component type 3 required by members of this family.
    ///   - comp4: Component type 4 required by members of this family.
    ///   - comp5: Component type 5 required by members of this family.
    ///   - comp6: Component type 6 required by members of this family.
    ///   - comp7: Component type 7 required by members of this family.
    ///   - excludedComponents: All component types that must not be assigned to an entity in this family.
    /// - Returns: The family of entities having 7 required components each.
    public func family<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7>(
        requiresAll comp1: Comp1.Type, _ comp2: Comp2.Type, _ comp3: Comp3.Type, _ comp4: Comp4.Type, _ comp5: Comp5.Type, _ comp6: Comp6.Type, _ comp7: Comp7.Type,
        excludesAll excludedComponents: Component.Type...
    ) -> Family7<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component, Comp6: Component, Comp7: Component {
        Family7<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7>(
            nexus: self,
            requiresAll: (comp1, comp2, comp3, comp4, comp5, comp6, comp7),
            excludesAll: excludedComponents
        )
    }
}

// MARK: - Family 8

public typealias Family8<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8> = Family<Requires8<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8>> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component, Comp6: Component, Comp7: Component, Comp8: Component

public protocol RequiringComponents8: FamilyRequirementsManaging where Components == (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8) {
    associatedtype Comp1: Component
    associatedtype Comp2: Component
    associatedtype Comp3: Component
    associatedtype Comp4: Component
    associatedtype Comp5: Component
    associatedtype Comp6: Component
    associatedtype Comp7: Component
    associatedtype Comp8: Component
}

public struct Requires8<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8>: FamilyRequirementsManaging where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component, Comp6: Component, Comp7: Component, Comp8: Component {
    public let componentTypes: [Component.Type]

    public init(_ components: (Comp1.Type, Comp2.Type, Comp3.Type, Comp4.Type, Comp5.Type, Comp6.Type, Comp7.Type, Comp8.Type)) {
        componentTypes = [Comp1.self, Comp2.self, Comp3.self, Comp4.self, Comp5.self, Comp6.self, Comp7.self, Comp8.self]
    }

    public static func components(nexus: Nexus, entityId: EntityIdentifier) -> (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8) {
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        let comp5: Comp5 = nexus.get(unsafeComponentFor: entityId)
        let comp6: Comp6 = nexus.get(unsafeComponentFor: entityId)
        let comp7: Comp7 = nexus.get(unsafeComponentFor: entityId)
        let comp8: Comp8 = nexus.get(unsafeComponentFor: entityId)
        return (comp1, comp2, comp3, comp4, comp5, comp6, comp7, comp8)
    }

    public static func entityAndComponents(nexus: Nexus, entityId: EntityIdentifier) -> (Entity, Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8) {
        let entity = Entity(nexus: nexus, id: entityId)
        let comp1: Comp1 = nexus.get(unsafeComponentFor: entityId)
        let comp2: Comp2 = nexus.get(unsafeComponentFor: entityId)
        let comp3: Comp3 = nexus.get(unsafeComponentFor: entityId)
        let comp4: Comp4 = nexus.get(unsafeComponentFor: entityId)
        let comp5: Comp5 = nexus.get(unsafeComponentFor: entityId)
        let comp6: Comp6 = nexus.get(unsafeComponentFor: entityId)
        let comp7: Comp7 = nexus.get(unsafeComponentFor: entityId)
        let comp8: Comp8 = nexus.get(unsafeComponentFor: entityId)
        return (entity, comp1, comp2, comp3, comp4, comp5, comp6, comp7, comp8)
    }

    public static func createMember(nexus: Nexus, components: (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8)) -> Entity {
        nexus.createEntity(with: components.0, components.1, components.2, components.3, components.4, components.5, components.6, components.7)
    }
}

extension Requires8: RequiringComponents8 { }

extension FamilyMemberBuilder where R: RequiringComponents8 {
    public static func buildBlock(_ comp1: R.Comp1, _ comp2: R.Comp2, _ comp3: R.Comp3, _ comp4: R.Comp4, _ comp5: R.Comp5, _ comp6: R.Comp6, _ comp7: R.Comp7, _ comp8: R.Comp8) -> (R.Components) {
        (comp1, comp2, comp3, comp4, comp5, comp6, comp7, comp8)
    }
}

extension Requires8: FamilyEncoding where Comp1: Encodable, Comp2: Encodable, Comp3: Encodable, Comp4: Encodable, Comp5: Encodable, Comp6: Encodable, Comp7: Encodable, Comp8: Encodable {
    public static func encode(components: (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8), into container: inout KeyedEncodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws {
        try container.encode(components.0, forKey: strategy.codingKey(for: Comp1.self))
        try container.encode(components.1, forKey: strategy.codingKey(for: Comp2.self))
        try container.encode(components.2, forKey: strategy.codingKey(for: Comp3.self))
        try container.encode(components.3, forKey: strategy.codingKey(for: Comp4.self))
        try container.encode(components.4, forKey: strategy.codingKey(for: Comp5.self))
        try container.encode(components.5, forKey: strategy.codingKey(for: Comp6.self))
        try container.encode(components.6, forKey: strategy.codingKey(for: Comp7.self))
        try container.encode(components.7, forKey: strategy.codingKey(for: Comp8.self))
    }
}

extension Requires8: FamilyDecoding where Comp1: Decodable, Comp2: Decodable, Comp3: Decodable, Comp4: Decodable, Comp5: Decodable, Comp6: Decodable, Comp7: Decodable, Comp8: Decodable {
    public static func decode(componentsIn container: KeyedDecodingContainer<DynamicCodingKey>, using strategy: CodingStrategy) throws -> (Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8) {
        let comp1 = try container.decode(Comp1.self, forKey: strategy.codingKey(for: Comp1.self))
        let comp2 = try container.decode(Comp2.self, forKey: strategy.codingKey(for: Comp2.self))
        let comp3 = try container.decode(Comp3.self, forKey: strategy.codingKey(for: Comp3.self))
        let comp4 = try container.decode(Comp4.self, forKey: strategy.codingKey(for: Comp4.self))
        let comp5 = try container.decode(Comp5.self, forKey: strategy.codingKey(for: Comp5.self))
        let comp6 = try container.decode(Comp6.self, forKey: strategy.codingKey(for: Comp6.self))
        let comp7 = try container.decode(Comp7.self, forKey: strategy.codingKey(for: Comp7.self))
        let comp8 = try container.decode(Comp8.self, forKey: strategy.codingKey(for: Comp8.self))
        return Components(comp1, comp2, comp3, comp4, comp5, comp6, comp7, comp8)
    }
}

extension Nexus {
    /// Create a family of entities (aka members) having 8 required components.
    ///
    /// A family is a collection of entities with uniform component types per entity.
    /// Entities that are be part of this family will have at least the 8 required components,
    /// but may have more components assigned.
    ///
    /// A family is just a view on (component) data, creating them is cheap.
    /// Use them to iterate efficiently over entities with the same components assigned.
    /// Families with the same requirements provide a view on the same collection of entities (aka members).
    /// A family conforms to the `LazySequenceProtocol` and therefore can be accessed like any other (lazy) sequence.
    ///
    /// **General usage**
    /// ```swift
    /// let family = nexus.family(requiresAll: Comp1.self, Comp2.self, Comp3.self, Comp4.self, Comp5.self, Comp6.self, Comp7.self, Comp8.self)
    /// // iterate each entity's components
    /// family.forEach { (comp1, comp2, comp3, comp4, comp5, comp6, comp7, comp8) in
    ///   ...
    /// }
    /// ```
    /// **Caveats**
    /// - Component types must be unique per family
    /// - Component type order is arbitrary
    ///
    /// - Parameters:
    ///   - comp1: Component type 1 required by members of this family.
    ///   - comp2: Component type 2 required by members of this family.
    ///   - comp3: Component type 3 required by members of this family.
    ///   - comp4: Component type 4 required by members of this family.
    ///   - comp5: Component type 5 required by members of this family.
    ///   - comp6: Component type 6 required by members of this family.
    ///   - comp7: Component type 7 required by members of this family.
    ///   - comp8: Component type 8 required by members of this family.
    ///   - excludedComponents: All component types that must not be assigned to an entity in this family.
    /// - Returns: The family of entities having 8 required components each.
    public func family<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8>(
        requiresAll comp1: Comp1.Type, _ comp2: Comp2.Type, _ comp3: Comp3.Type, _ comp4: Comp4.Type, _ comp5: Comp5.Type, _ comp6: Comp6.Type, _ comp7: Comp7.Type, _ comp8: Comp8.Type,
        excludesAll excludedComponents: Component.Type...
    ) -> Family8<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8> where Comp1: Component, Comp2: Component, Comp3: Component, Comp4: Component, Comp5: Component, Comp6: Component, Comp7: Component, Comp8: Component {
        Family8<Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8>(
            nexus: self,
            requiresAll: (comp1, comp2, comp3, comp4, comp5, comp6, comp7, comp8),
            excludesAll: excludedComponents
        )
    }
}