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

user_8417400 0
Viewed 108

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()
    }
}
swift
1 Answers

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)
    }
}
user_96070720
Related