Calculating Enum Raw Values from another Enum case statement

Leaning about raw values and associated values I wanted to combine two types of Enums to illustrate how they work when type specific i.e. declaring raw values for one Enum, while relying on compiler inference for the string values.

Modifying the example from Passan when calculating American currency with raw values I wanted to instead add the dictionary of values to a switch statement linked to family members, this would be a String Enum and so I could combine an example of both type Double and type String in one small block of code, but I can't seem to make the return work:

enum Coin: Double {
    case copper = 0.01
    case pound = 1.00
    case fiver = 5.00
    case reddy = 50.00
}

enum FamilyPurses: String {
    case father
    case mother
    case firstBorn
    case secondBorn
    case newArrival

    func allowance() -> [Coin] {
        switch self {
        case .father: return  [Coin.reddy, .reddy, .reddy, .fiver]
        case .mother: return  [Coin.reddy, .fiver, .pound]
        case .firstBorn: return [Coin.pound, .copper, .copper]
        case .secondBorn: return [Coin.copper, .copper]
        case .newArrival: return [Coin.copper]
        }
    }
}

func sum(having money: [Coin]) -> Double {
    var total: Double = 0

    for ammount in FamilyPurses.firstBorn.allowance() {
        total += ammount.rawValue
    }
    return total
}

let test = sum(having: FamilyPurses.firstBorn)

The code does not compile. I think I am having trouble at the beginning of the sum function as the video example links from an instance, while I am looking to delve into an Enum.

The code is meant to show all of what raw values are: Type specific, compiler inference at declaration and minimal use of Enum declaration.

Thanks in advance!