Generics and iteration type

emefde · 2023-06-09T08:04:34.351Z

Good morning all .

I watched a talk about generics from wwdc-22 and decided to recreate the whole thing as an exercise and just when I was about to finish I got this error when passing a func directly to a forEach. (feedAll)

Here's the code:

import Foundation

protocol FarmAnimal {
    associatedtype Food: AnimalFood
    func eat(food: Food)
    var typeOfFood: Food.Type { get }
}

protocol AnimalFood {
    associatedtype CropType: AnimalCrop where CropType.Food == Self
    static func grow() -> CropType
}

protocol AnimalCrop {
    associatedtype Food: AnimalFood where Food.CropType == Self
    func harvest() -> Food
}

struct AnimalFarm {
    func feed(_ animal: some FarmAnimal) {
        let crop = animal.typeOfFood.grow()
        let food = crop.harvest()
        animal.eat(food: food)
    }

    func feedAll(_ animals: [any FarmAnimal]) {
        // OK
        for animal in animals {
            feed(animal)
        }

        // OK
        animals.forEach {
            feed($0)
        }
        
        // Type 'any FarmAnimal' cannot conform to 'FarmAnimal'
        animals.forEach(feed)
    }
}

struct CowAnimal: FarmAnimal {

    var typeOfFood: HayFood.Type { HayFood.self }

    func eat(food: HayFood) {
        print("eat some food: \(food)")
    }
}

struct HayFood: AnimalFood {
    static func grow() -> HayCrop {
        HayCrop()
    }
}

struct HayCrop: AnimalCrop {
    func harvest() -> HayFood {
        HayFood()
    }
}

Could someone explain what's the difference here?

Val · 2023-06-09T08:40:52.068Z

Your feed function takes a generic FarmAnimal, while your feedAll function takes an array of existential FarmAnimals. By passing an existential to a generic function, Swift implicitly opens that existential for the scope of that function. The fact that this doesn’t work when passing the feed function into the forEach seems like bug to me. Check out the corresponding proposal for more details.

emefde · 2023-06-09T08:48:00.841Z

A bug was the first thing that came to mind but I thought that maybe I’m missing something here and forEach + closue + function call works a bit different than forEach + func as parameter

anon9791410 · 2023-06-09T09:33:46.635Z

Inconsistent ergonomics with implicitly opened existentials: key path closures vs. functions

Inspiration for my experimenting: I watched @hborla's excellent Embrace Swift generics from WWDC and thought it was lame that she had to use a for loop instead of
func feedAll(_ animals: [any Animal]) {
  animals.forEach(feed)
}

Inconsistent ergonomics with implicitly opened existentials: key path closures vs. functions Discussion

Given this… protocol P { associatedtype T } let sequence: some Sequence<any P> = [] …I can understand why, because of the need for potentially multiple function specializations, this first filter compiles, but the second does not. func function(_: some P) -> Bool { true } var filtered = sequence.filter { function($0) } filtered = sequence.filter(function) // Type 'any P' cannot conform to 'P' That wouldn't bug me so much, except that extension P { var property: Bool { true } } fi…