0protocol Greetable { func greet() -> String } struct Person: Greetable { var name: String func greet() -> String { return "Hello, \(name)!" } } var greeter: any Greetable greeter = Person(name: "Alice") print(greeter.greet())
| Step | Action | Variable State | Output |
|---|---|---|---|
| 1 | Define protocol Greetable with greet() | No variables yet | |
| 2 | Declare variable 'greeter' of type 'any Greetable' | greeter = uninitialized | |
| 3 | Assign 'Person(name: \"Alice\")' to 'greeter' | greeter = Person(name: "Alice") | |
| 4 | Call 'greeter.greet()' | greeter = Person(name: "Alice") | "Hello, Alice!" printed |
| 5 | End of program | greeter = Person(name: "Alice") | Program ends |
| Variable | Start | After Assignment | Final |
|---|---|---|---|
| greeter | uninitialized | Person(name: "Alice") | Person(name: "Alice") |
Existential types hold any instance conforming to a protocol. Use 'any ProtocolName' to declare such variables. Allows dynamic dispatch of protocol methods. Example: var x: any Greetable = Person() Use to work with heterogeneous types safely.
any keyword indicate in Swift when used with a protocol type?any in Swiftany keyword is used to mark a type as existential, meaning it can hold any value that conforms to a given protocol.any. It does not create new protocols, restrict to one type, or convert protocols to classes.any means existential type [OK]any means 'any conforming type' [OK]any creates a new protocolany with type restrictionany converts protocols to classesDrawable using existential types?any ProtocolName. So here, it is any Drawable.any, so it is not explicit existential. var shape: Drawable & any and var shape: Drawable<any> have incorrect syntax. Only var shape: any Drawable uses the correct syntax.any Protocol [OK]any before protocol name for existential types [OK]any keywordany after protocol nameprotocol Greetable {
func greet() -> String
}
struct Person: Greetable {
func greet() -> String { "Hello" }
}
let greeter: any Greetable = Person()
print(greeter.greet())Greetable requires a greet() method returning a String. The struct Person implements this method returning "Hello".greeter is declared as any Greetable and assigned a Person instance. Calling greeter.greet() calls the implemented method and returns "Hello".protocol Runnable {
func run()
}
struct Dog: Runnable {
func run() { print("Dog runs") }
}
var runner: Runnable = Dog()
runner.run()any keyword explicitly. The declaration var runner: Runnable is invalid; it should be var runner: any Runnable.any is the error.any keyword before Runnable in variable declaration. -> Option Aany keyword [OK]any before protocol for existential variables [OK]any keywordCodable protocol and returns its JSON string representation. Which is the correct way to declare the function parameter using existential types?any Codable declares an existential type parameter that can accept any value conforming to Codable. This matches the question requirement.any, which is invalid syntax for existential types. func encodeToJSON(value: T) -> String uses generics, which is valid but not existential. func encodeToJSON(value: Codable & any) -> String has incorrect syntax. func encodeToJSON(value: any Codable) -> String is correct.any Protocol [OK]any before protocol for existential function parameters [OK]any keywordPass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.