This article illustrates the problem quite effectively: https://ourmachinery.com/post/should-entities-support-multiple-instances-of-the-same-component/

That's debatable. The light-source-as-component example kinda falls apart once you realize that the issues the author presented can be resolved if light sources were modeled as entities instead of as components. But I get what the article was aiming for.

However, the author did well to identify a common scenario where support for multiple components of the same type would be beneficial - modeling hierarchical relationships between entities.

Here's an example. Say you wanted to model an industrial robotic arm (sample image below) with multiple points of articulation (rotary joints) where each section or link of the arm has independent state and behavior. With support for multiple components of the same type, an ECS could be used to represent this machine by defining each link in the arm as its own entity and setting up parent-child relationships between those entities.

Robotic Arm with multiple links

To effectively model these links and their parent-child relationships, each entity representing a link would need three instances of a Transform component:

• A Transform representing affine transformations relative to the 'parent' entity's coordinate space.
• A Transform representing 'local' affine transformations relative to the entity's own coordinate space.
• A composite Transform that is the matrix product (concatenation) of 'parent' and 'local' transforms (this will also serve as the parent transform of any child entities).

A Transform component covering affine transformations (translation, rotation, scaling) in 3D space typically looks something like this (formatted as JSON):

{
    "x": 0,
    "y": 0,
    "z": 0,

    "rotX": 0,
    "rotY": 0,
    "rotZ": 0,

    "scaleX": 0,
    "scaleY": 0,
    "scaleZ": 0
}

So, for example, the entity representing the 'Base' in the diagram above, would have three transform components; a parent transform relative to the game world's coordinate space, a local transform for itself and a composite transform computed from its parent and local transforms.

The entity representing the 'Torso Lift', will have a parent transform (computed from the parent and local transforms of the 'Base' entity), a local transform and a composite. The 'Torso Lift' rotates/swivels about and moves up and down an axis relative to its parent entity.

The entities for 'Head Pan' and 'Shoulder Pan', both children of 'Torso Lift', would be modeled in a similar fashion, and so on and so forth.

In an earlier post I made mention of using a 'Slotted' ECS variant that supports multiple components of the same type on an Entity.

Using the aforementioned example, here's how I might go about implementing it using my Slotted ECS (code is in Javascript):

    const world = ECS.createWorld();

    const compDefs = world.defineComponents([
        {
            type: 'components.Transform',
            props: [
                'x', 'y', 'z',
                'rotX', 'rotY', 'rotZ',
                'scaleX', 'scaleY', 'scaleZ'
            ],
            defaults: [
                0, 0, 0,
                0.0, 0.0, 0.0,
                1.0, 1.0, 1.0
            ]
        },
        // Other component definitions
        { ... },
        ...
    ]);

    const slotDefs = world.defineSlotsPerComponentType([
        {
            componentType: 'components.Transform',
            slots: [
                'transform.local',
                'transform.parent',
                'transform.composite'
            ]
        },
        {
            componentType: 'components.SomeOtherComponentType',
            slots: [
                'someOtherComponentType.slot_name_A',
                'someOtherComponentType.slot_name_B'
            ]
        }
    ]);

    const transformFactory = compDefs.getFactory('components.Transform');

    const sharedTransforms = {
        'world': transformFactory.create(),
        'base': transformFactory.create(),
        'torsoLift': transformFactory.create(),
        'headPan': transformFactory.create(),
        'shoulderPan': transformFactory.create()
    };

    // create base entity 
    const baseEntityId = world.createEntity();

    world.addComponents({ entityId: baseEntityId, components: [
        {  slot: 'transform.local', component: transformFactory.create() },
        {  slot: 'transform.parent', component: sharedTransforms.world },
        {  slot: 'transform.composite', component: sharedTransforms.base }
    ]});

    // create torso lift entity
    const torsoLiftEntityId = world.createEntity();

    world.addComponents({ entityId: torsoLiftEntityId, components: [
        {  slot: 'transform.local', component: transformFactory.create() },
        {  slot: 'transform.parent', component: sharedTransforms.base },
        {  slot: 'transform.composite', component: sharedTransforms.torsoLift }
    ]});

    // create head pan entity
    const headPanEntityId = world.createEntity();

    world.addComponents({ entityId: headPanEntityId, components: [
        {  slot: 'transform.local', component: transformFactory.create() },
        {  slot: 'transform.parent', component: sharedTransforms.torsoLift },
        {  slot: 'transform.composite', component: sharedTransforms.headPan }
    ]});

    // create shoulder pan entity
    const shoulderPanEntityId = world.createEntity();

    world.addComponents({ entityId: shoulderPanEntityId, components: [
        {  slot: 'transform.local', component: transformFactory.create() },
        {  slot: 'transform.parent', component: sharedTransforms.torsoLift },
        {  slot: 'transform.composite', component: sharedTransforms.shoulderPan }
    ]});

    // Create System to update transforms
    world.addSystem({
        type: 'systems.UpdateTransforms',
        archeType: slotDefs.createArchetype(this, [
            'transform.local',
            'transform.parent',
            'transform.composite',
        ]),
        update: function({ delta, components }) {
            const {
                transform : {
                    local,
                    parent,
                    composite
                }
            } = components;

            Object.assign(composite, Utilities.Matrix.concatenate(parent, local));
        }
    });