swift type erasure understanding, Cannot convert value of type 'AnyMapper<Payload, [Post]>' to expected element type 'AnyMapper<Payload, User>

struct Payload {}
struct User {}
struct Post {}

protocol Mapper {
    associatedtype PayloadType
    associatedtype ResultType
    
    func map(_ payload: PayloadType) -> ResultType
}

class AnyMapper<P, R>: Mapper {
    private var _mapClouser: (P) -> R
    
    init<M: Mapper>(_ mapper: M) where M.PayloadType == P, M.ResultType == R {
        _mapClouser = mapper.map(_:)
    }
    
    func map(_ payload: P) -> R {
        _mapClouser(payload)
    }
}

class UserMapper: Mapper {
    func map(_ payload: Payload) -> User {
        return User()
    }
}

class PostsMapper: Mapper {
    func map(_ payload: Payload) -> [Post] {
        return [Post(), Post(), Post()]
    }
}

let userMapper = AnyMapper(UserMapper())
let postsMapper = AnyMapper(PostsMapper())

var array: [AnyMapper] = [userMapper, postsMapper] <<< Error: Cannot convert value of type 'AnyMapper<Payload, [Post]>' to expected element type 'AnyMapper<Payload, User>'

I tried to put 2 objects into array, but I get this error: Cannot convert value of type 'AnyMapper&lt;Payload, [Post]&gt;' to expected element type 'AnyMapper&lt;Payload, User&gt;'

Can someone explain to me how to fix it?

[Post] and User are not the same type. You don't need an erasing type to put them into the same array.

var array: [any Mapper] = [UserMapper(), PostsMapper()]

AnyMapper by itself is not a type. It is a type constructor. Essentially, it is a “function” that

• runs at compile time,
• takes types as arguments named P and R, and
• returns a type.

So for example if you say AnyMapper<Payload, User>, that's a compile-time function call to the type constructor AnyMapper, passing the arguments Payload and User. It returns a type, which we just refer to using the same syntax, AnyMapper<Payload, User>.

Often, Swift can deduce the argument types, so although you don't pass them explicitly, Swift passes them for you.

That's what's happening on these two lines:

let userMapper = AnyMapper(UserMapper())
let postsMapper = AnyMapper(PostsMapper())

Each of those lines “calls“ AnyMapper after deducing the P and R arguments. We can make the P and R arguments explicit, and also make the returned types explicit, like this:

let userMapper: AnyMapper<Payload, User> = AnyMapper<Payload, User>(UserMapper())
let postsMapper: AnyMapper<Payload, [Post]> = AnyMapper<Payload, [Post]>(PostsMapper())

So now we can see that you're creating two objects of two different types.

You next write this:

var array: [AnyMapper] = [userMapper, postsMapper]

Since you're not explicitly passing type arguments to AnyMapper, you're asking Swift to deduce the arguments. It does so by looking at the first element of the array literal, userMapper. Based on that, it deduces P = Payload and R = User, so it acts like you wrote this:

var array: [AnyMapper<Payload, User>] = [userMapper, postsMapper]

But postsMapper is not an AnyMapper<Payload, User>, so Swift can't compile that statement.

What all this means is that AnyMapper erases only the wrapped Mapper's specific type, but not its PayloadType and ResultType associated types.

It's not clear why you would want to put userMapper and postsMapper in the same array anyway. They have different result types, so you wouldn't be able to treat their results generically. Perhaps if you explain why you think you need to put them both in a single array, we can give you better guidance.