why cant i return opaque types in my swift code? i am already returning a type conforming to that protocol [duplicate] - swift

Question

This question already has answers here:
What is the "some" keyword in Swift(UI)?
(14 answers)
Closed 1 year ago.
image
As showing in the image, i'm already using types such as MilkChocolate which conforms to the "Chocolate" protocal, and im trying to declare a function which returns a "some chocolate", which means return a type of chocolate depends on the input, but it gives me an error says
Function declares an opaque return type, but the return statements in its body do not have matching underlying types
this confused me by a lot and i think MiklChocolate is an underlying type for the Chocolate protocol
whats wrong?🤔
and my code should match this tutorial: https://docs.swift.org/swift-book/LanguageGuide/OpaqueTypes.html
PS: if you cant view the image, here's the code
protocol Chocolate {
associatedtype Content
var mass:Double {get}
}
struct Honey {}
struct Milk {}
struct Wine {}
class HoneyChocolate: Chocolate {
typealias Content = Honey
var mass = 1.0
}
class MilkChocolate: Chocolate {
typealias Content = Milk
var mass = 1.2
var mysteriousEffect = true
}
class WineChocolate: Chocolate {
typealias Content = Wine
var mass:Double = 999
}
func giveMeChocolate(of type:String) -> some Chocolate {
switch type {
case "honey":
return HoneyChocolate()
case "milk":
return MilkChocolate()
default:
return WineChocolate()
}
}

Answer 1

The problem occurs because Swift can't return different types of generic types. HoneyChocolate and WineChocolate are different types and that causes an issue.
A different way of achieving your goal is to return a class type of Chocolate.
First let's declare our enum flavors:
enum Flavor {
case Honey, Milk, Wine
}
then we will declare the superclass Chocolate:
class Chocolate {
var flavor: Flavor
var mass:Double
init(_ flavor: Flavor ,_ mass: Double) {
self.flavor = flavor
self.mass = mass
}
}
Now we can inherit this class:
class HoneyChocolate: Chocolate {
init() {
super.init(Flavor.Honey, 1.0)
}
}
class MilkChocolate: Chocolate {
init() {
super.init( Flavor.Milk, 1.2)
var mysteriousEffect = true
}
}
class WineChocolate: Chocolate {
init() {
super.init( Flavor.Wine, 999)
var mysteriousEffect = true
}
}
finally we can return our chocolates:
func giveMeChocolate(of type:Flavor) -> Chocolate {
switch type {
case Flavor.Honey:
return HoneyChocolate()
case Flavor.Milk:
return MilkChocolate()
default:
return WineChocolate()
}
}
Why some doesn't work
some allows you to return a generic type like and ONLY one type.
for example:
let's make a CandyChocolate class:
class CandyChocolate: Chocolate {
typealias Content = Candy
var mass = 1.0
var sweetness
init(sweetness: int) {
self.sweetness = sweetness
}
}
Now to return a some Chocolate we are allowed to return exactly one type of chocolate:
func giveMeChocolate(of type:String) -> some Chocolate {
switch type {
case "honey":
return CandyChocolate(sweetness: 5)
case "milk":
return CandyChocolate(sweetness: 3)
default:
return CandyChocolate(sweetness: 8)
}
}