I'm in the process trying to learn and understand protocols with associated types in swift.

At the same time, I'm learning SwiftUI and taking a course on Udemy.

The app that we will building is a coffee order application. 

With that being said, I do not follow the tutorial to the "T" as I tried to structure the app differently, so I can learn to think on my own. The app is nothing too fancy.

The tutorial doesn't use generics and protocols to represent or structure data. It is just a tutorial to showcase SwiftUI.

I created a protocol called Coffee that has a CupSize associated type.

Each coffee Cappuccino, Espresso, and Brewed Coffee confirms to the Coffee protocol.

```
protocol Priceable {
  var cost: Double { get }
}

protocol Coffee {
  associatedtype CupSize
  var cupSize: CupSize { get }
  init(cupSize: CupSize)
}

enum EspressoCupSize {
  case small
}

struct Espresso: Coffee, Priceable {
  var cupSize = EspressoCupSize.small
  var cost: Double { return 3.00 }
}

enum BrewedCoffeeCupSize {
  case small
  case medium
  case large
}

struct BrewedCoffee: Coffee, Priceable {
  var cupSize: BrewedCoffeeCupSize
  var cost: Double {
    switch self.cupSize {
      case .small: return 1.00
      case .medium: return 2.00
      case .large: return 3.00
    }
  }
}

enum CappuccinoCupSize {
  case small
  case medium
  case large
}

struct Cappuccino: Coffee, Priceable {
  var cupSize: CappuccinoCupSize
  var cost: Double {
    switch self.cupSize {
      case .small: return 2.00
      case .medium: return 3.00
      case .large: return 4.00
    }
  }
}

```

Then, I created an Order struct and an OrderManager class.

Order struct has a generic and needs to be a Priceable item.
The idea of a generic priceable item is to support other items in the future in case I want to expand the app...not just coffee.

The idea behind OrderManager is to keep track all the orders and manage the CRUD operations of the orders (still need to implement delete, read, and update).

```
struct Order<Item: Priceable> {
  var name: String
  var item: Item
}

class OrderManager<Item> {
  private var orders: [Item] 

  init(orders: [Item]) {
    self.orders = orders
  }

  func add(_ order: Item) {
    self.orders.append(order)
  } 
}

```

My issue is using OrderManager.

```
let maryOrder = Order(name: "Mary", item: Espresso())
let sueOrder = Order(name: "Sue", item: BrewedCoffee(cupSize: .medium))

// Dummy Structure
struct Person {}

let orderManager = OrderManager(orders: [
  maryOrder,
  sueOrder,
  Person() // This works!!! Which is not what I want.
])

```

I want the generic type for OrderManager to be an Order, but since Order has its own generic type of Priceable, I cannot seem to find the correct answer or find the correct syntax.

Things I have tried to get OrderManager to work

```
class OrderManager<Order> {} // Does not work because Order needs a generic type
class OrderManager<Order<Priceable>> // Still does not work
class OrderManager<Item: Priceable, Order<Item> {} // Still does not work.
// and I tried other solutions, but I cannot get this to work
// Also, when I think I got the right syntax, I cannot add Mary and Sue's orders to
// OrderManager because Mary's item is Espresso and Sue's item is BrewedCoffee

```

How can I get OrderManager to accept only an array of orders?