/// A debt owed to a lender
protocol Debt {

        /// The amount borrowed
        var principal: Decimal { get }
        ...
}

The idea was to model debts abstractly, then make different types of debts that conform to the Debt protocol, for example:

/// A debt owed on a credit card
protocol CreditCardDebt: Debt {
        ...
}

Then I could store all my debts as an array on my User object:

struct User {

        /// The user's debts
        var debts: [Debt]
}

protocol Interest {
        ...
}

struct APR: Interest {
        ...
}

protocol Debt {

        associatedtype ConcreteInterestType: Interest

        var interest: ConcreteInterestType
        ...
}

protocol CreditCardDebt: Debt {
        var principal: Decimal
        var interest: APR // Rather than "var interest: Interest"
}

But that also means I can no longer declare var debts: [Debt] because Debt now has associatedtype requirements. And since I can't have a collection of debts, I can do basic stuff like iterating over a bunch of debts either.

For example, you can have an array of strings and numbers if you erase to AnyHashable:

var hashables = [AnyHashable]()
hashables.append("ABC")
hashables.append(123)

Or you could get even more abstract and erase to Any:

var things = [Any]()
things.append("ABC")
things.append(123)

And you can even iterate over the collection and access the original type:

for thing in things {
    if let string = thing as? String {
        print(string)
    }
    if let integer = thing as? Int {
        print(integer)
    }
}

Magic! All we need to do is create an array of AnyDebt to solve our initial problem and we're good to go!

/// A type-erased debt
struct AnyDebt: Debt {
    
        /// The amount
    let amount: Decimal
    
        /// The interest
    let interest: AnyInterest
    
        /// Initialize with a debt of type D
    init<D: Debt>(_ debt: D) {
        self.amount = debt.amount
        self.interest = AnyInterest(debt.interest)
    }
}

Since Debt has associated type requirements, we need a generic initializer to be able to instantiate an AnyDebt with any type conforming to Debt. We also need AnyInterest to avoid the generic AnyDebt<I: Interest>, which cannot be stored in an array with mixed types of Interest.

This essentially gives us a type in which the details of the original, specific type is “erased” to the lowest common denominator of any implementation of Debt.

And this is all well and good. We can now have an array of AnyDebt and iterate to our heart's content:

var debts: [AnyDebt]

for debt in debts {
        print(debt)
}

Hurray! We did it...

for debt in debts {
    if let creditCardDebt = debt as? CreditCardDebt {
        print(creditCardDebt)
    }
}

That's because our AnyDebt implementation offers no way to translate from AnyDebt back to CreditCardDebt. When we erase the type with the above approach, we're actually erasing it for good!

On top of that, remember how we could create an array of AnyHashable and add stuff to it on the fly?

var hashables = [AnyHashable]()
hashables.append("ABC")
hashables.append(123)

Our AnyDebt implementation is also limited such that we need to wrap each concrete type in AnyDebt before we can add to a collection (just like with AnyView in SwiftUI).

var debts = [AnyDebt]()
debts.append(AnyDebt(creditCardDebt))

So what gives?

Turns out, Swifts implementation of Any and AnyHashable has way way way more going on under the hood that allows this behavior. Doing type-erasure in a way that's especially useful is actually a non-insubstantial to massive undertaking that I ultimately decided I'd rather avoid.

In my original example, the thing I really wanted was to have an array of debts. And I can in fact still have this by having concrete debt types conform to the Debt protocol. We just need to get rid of the associatedtype declaration within Debt.

We can keep our Interest protocol, but require an additional type variable of type enum.

protocol Interest {
    
    var type: InterestType { get }
    
    var amount: Decimal { get }
    
    mutating func calculateInterest(from principal: Decimal, ...)
}

enum InterestType {
    case apr
        ...
}

Then we have concrete implementations of Interest like so:

struct APR: Interest {
    
    let type = InterestType.apr
    
    var amount: Decimal
    
    mutating func calculateInterest(from principal: Decimal) {
        self.amount = 100
    }
}

And we can even ensure our CreditCardDebt necessarily uses the APR type in our initializer:

struct CreditCardDebt {
    
    let amount: Decimal
    
    let interest: Interest
    
    init(amount: Decimal) {
        self.amount = amount
        self.interest = APR()
    }
}