Opaque types with some keyword in Swift - Step-by-Step Execution

Concept Flow - Opaque types with some keyword

Define function returning some Protocol

↓

Function hides concrete type

↓

Caller gets value typed as Protocol

↓

Use returned value via Protocol interface

↓

Concrete type remains hidden

The function returns a value conforming to a protocol but hides the exact type using 'some'. The caller sees only the protocol interface.

Execution Sample

Swift

protocol Shape {
    func area() -> Double
}

func makeCircle() -> some Shape {
    struct Circle: Shape {
        var radius: Double
        func area() -> Double { 3.14 * radius * radius }
    }
    return Circle(radius: 5)
}

Defines a function returning an opaque type conforming to Shape protocol, hiding the concrete Circle type.

Execution Table

Step	Action	Evaluation	Result
1	Call makeCircle()	Create Circle(radius: 5)	Circle instance created
2	Return Circle as some Shape	Hide concrete type	Return value typed as some Shape
3	Caller receives value	Type is some Shape	Can call area() but not access Circle-specific properties
4	Call area() on returned value	Compute 3.14 * 5 * 5	Returns 78.5
5	End	No more steps	Execution stops

💡 Function returns opaque type; caller uses protocol interface without knowing concrete type

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
circle	nil	Circle(radius: 5)	Hidden as some Shape	some Shape value	some Shape value with area()=78.5

Key Moments - 2 Insights

Why can't the caller access Circle's radius property?

Because the function returns 'some Shape', the concrete Circle type is hidden. The caller only knows the value conforms to Shape, so only protocol methods like area() are accessible (see execution_table step 3).

Is the concrete type created each time the function is called?

Yes, each call creates a new Circle instance internally (execution_table step 1), but the caller only sees it as some Shape.

Visual Quiz - 3 Questions

Look at the execution table, what is the type of the value returned by makeCircle() at step 2?

A some Shape

B Circle

C Shape protocol

D Any

💡 Hint

See execution_table row 2: the concrete type is hidden and returned as some Shape.

At which step does the caller call the area() method on the returned value?

A Step 1

B Step 2

C Step 4

D Step 3

💡 Hint

Check execution_table row 4: area() is called on the opaque type.

If the function returned Shape instead of some Shape, what would change in the execution?

A Caller could access Circle's radius

B Caller would get a protocol existential instead of opaque type

C Function would return concrete Circle type

D No difference

💡 Hint

Opaque types hide concrete type; returning protocol type returns existential (concept explanation).

Concept Snapshot

Use 'some Protocol' to return an opaque type.
The concrete type is hidden from the caller.
Caller sees only the protocol interface.
Allows type safety with abstraction.
Example: func f() -> some Shape { ... }

Full Transcript

This example shows how a Swift function can return an opaque type using the 'some' keyword. The function makeCircle() creates a concrete Circle instance internally but returns it as 'some Shape', hiding the concrete type. The caller receives a value typed as some Shape and can call protocol methods like area(), but cannot access Circle-specific properties like radius. The execution table traces the steps: creating the Circle, returning it as some Shape, the caller receiving it, and calling area(). This helps beginners understand how opaque types provide abstraction while preserving type safety.