Implement generic method in swift - swift

Question

I am implementing Protocol Oriented approach in Swift as codes below. The concept seems fun but I hope you get the idea. The problem for me is how to implement a generic function for that repeated printing tasks. Thank you in advances.
protocol Food {
var name: String { get }
}
struct Grass: Food {
var name: String { return "Grass" }
var calcium: Float!
}
struct Rice: Food {
var name: String { return "Rice" }
var calories: Float!
}
struct Insect: Food {
var name: String { return "Insect" }
var fiber: Float!
}
protocol Eat {
associatedtype food: Food
var name: String { get }
var itsFood: food { get }
}
struct Cow: Eat {
typealias food = Grass
var name: String { return "Cow" }
var itsFood: food {return food(calcium: 100)}
}
struct People: Eat {
typealias food = Rice
var name: String { return "People" }
var itsFood: food {return food(calories: 1000)}
}
struct Reptile: Eat {
typealias food = Insect
var name: String { return "Reptile" }
var itsFood: food {return food(fiber: 300)}
}
let cow = Cow()
print(cow.name)
print(cow.itsFood.name)
print(cow.itsFood.calcium)
let people = People()
print(people.name)
print(people.itsFood.name)
print(people.itsFood.calories)
let reptile = Reptile()
print(reptile.name)
print(reptile.itsFood.name)
print(reptile.itsFood.fiber)

Answer 1

If I understood correctly, you want a way to write a function that prints out an Eat conformer's name, food name, and the food's nutritional value.
Your current Food protocol has not got enough information on the food's nutritional value (calcium, calories, fiber). You should edit your protocol:
protocol Food {
var name: String { get }
var nutritionalValueName: String { get }
var nutritionalValue: Float! { get }
}
And implement the 2 new properties in the Food conformers. Here's an example:
struct Grass: Food {
var name: String { return "Grass" }
var calcium: Float!
var nutritionalValue: Float! { return calcium }
var nutritionalValueName: String { return "Calcium" }
}
Now, you can write a function. Note that since Eat has an associated type, it cannot be used as a parameter type directly, you need to introduce a generic parameter T and constrain it to Eat:
func printEat<T: Eat>(eat: T) {
print(eat.name)
print(eat.itsFood.name)
print("\(eat.itsFood.nutritionalValueName): \(eat.itsFood.nutritionalValue!)")
}
The function body is pretty self-explanatory.
You can call it like this:
printEat(eat: Cow())
printEat(eat: People())
printEat(eat: Reptile())
Output:
Cow
Grass
Calcium: 100.0
People
Rice
Calories: 1000.0
Reptile
Insect
Fiber: 300.0

Answer 2

I would use something like below to be able to use basic functions in one place. You would need super classes for common task functions, protocols would not be enough for that.
class Food {
var name: String? { return nil }
var calcium: Float?
var calories: Float?
var fiber: Float?
}
class Grass: Food {
override var name: String? { return "Grass" }
init(_ calcium: Float) {
super.init()
self.calcium = calcium
}
}
class Rice: Food {
override var name: String? { return "Rice" }
init(_ calories: Float) {
super.init()
self.calories = calories
}
}
class Insect: Food {
override var name: String? { return "Insect" }
init(_ fiber: Float) {
super.init()
self.fiber = fiber
}
}
protocol Eat {
var name: String? { get }
var itsFood: Food? { get }
func printInfo()
}
class Animal: Eat {
var name: String? { return "Cow" }
var itsFood: Food? { return Food() }
func printInfo() {
print(name ?? "")
print(itsFood?.name ?? "")
print(itsFood?.calcium ?? 0)
}
}
class Cow: Animal {
override var name: String? { return "Cow" }
override var itsFood: Grass {return Grass(100) }
}
class People: Animal {
override var name: String? { return "People" }
override var itsFood: Food {return Rice(1000)}
}
class Reptile: Animal {
override var name: String? { return "Reptile" }
override var itsFood: Food {return Insect(300)}
}
let cow = Cow()
cow.printInfo()

Answer 3

Check out this :
struct Fruit {
let fruitName : String
let color : String
init(_ name: String,_ color: String) {
self.fruitName = name
self.color = color
}
}
let fruit1 = Fruit("Apple", "Red")
let fruit2 = Fruit("Grapes", "Green")
let fruitStack = Stack<Fruit>()
fruitStack.push(fruit1)
fruitStack.push(fruit2)
let fruitFfromStack = fruitStack.pop()
print("Fruit popped from Stack, Name : \(String(describing: fruitFfromStack?.fruitName)) ,Color : \(String(describing: fruitFfromStack?.color))")
let fruitFfromStack1 = fruitStack.pop()
print("Fruit popped from Stack, Name : \(String(describing: fruitFfromStack1?.fruitName)) ,Color : \(String(describing: fruitFfromStack1?.color))")
https://reactcodes.blogspot.com/2019/01/generic-stack-implementation-with.html