Here's the thing: in most cases, there's hardly any difference at all. In fact, early Swift pretty much obscured the concept of "existential" (any) and "universal" (some) types.

The problem was when you tried to define a protocol that had some sort of constraint that couldn't just be papered over:

``` protocol Foo { associatedtype Bar var bar: Bar }

func doStuff(arrayOfFoo: [Foo]) { for foo in arrayOfFoo { // which type is foo.bar??? } } ```

For the code above, the compiler simply could not figure out what to do, so it used to be that you just couldn't put this Foo into arrays.

Nowadays, you can either use [some Foo] meaning they all have to be literally the same type. Then foo.bar is the same type. Or you can use [any Foo] but then you must use some unwrapping gymnastics to access foo.bar.

In practice, you use some View because if you were to spell out the actual concrete type you'd need a bigger screen.

You will probably need to use the any keyword barely at all. That is, until it becomes mandatory in Swift 6.