Protocols with Associated Types, and How They Got That Way

Protocols with
Associated Types
and how they got that way
(maybe)

@alexisgallagher

Protocols with Associated Pain
1. Hurray, I'm using value types!
2. Oh, I can't subclass.
3. Hurray, I'm using protocols!
4. Hurray, I'm adopting Equatable!
5.

Plain protocols, work as expected:
protocol MyProto {
}
struct Foo : MyProto {
}
let protoVar:MyProto = Foo() // <-- No problem!

Protocols with associated types, do not:
protocol MyProto {
typealias MyAssocType // declare requirement
}
struct Foo : MyProto {
typealias MyAssocType = Int // meet requirement
}
let protoVar:MyProto = Foo() // <-- Nope!

Protocols requiring Self? Same story:
protocol MyEquatable {
typealias MySelf // Self is a special associated type ...
}
struct Foo : MyEquatable {
typealias MySelf = Foo // ... always equal to adopting type
}
let protoVar:MyEquatable = Foo() // <-- Nope!

Questions
1. How are PATs weird?
2. Why are PATs weird?
3. Is this the plan?
4. How to love them?

How PATs are weird
W1. Only usable as generic constraints

Weirdness 1: only usable as generic constraints
• This rule excludes PATs from literally every single use of
"protocols" as deﬁned in Objective-C

• Everywhere you wanted a protocol, you need a generic:
From: var delegate:Proto
To: class C<T:Proto> { var delegate:T } }

• Everywhere you wanted a protocol, you need a generic:
From: var delegates:[Proto]
To: class C<T:Proto> { var delegates:[T] } }
• Which still excludes dynamic dispatch … which might be
why you wanted a protocol to begin with!

How PATs are weird
W2. Docs describe them as "real" types

How PATs are weird
W3. The mysterious typealias

Weirdness 3: the mysterious typealias
typealias serves two different functions:
1. Outside PATs: provides the syntactic convenience of
meaningful names
2. Inside PATs, establishes a semantic requirement on types
adopting the PAT

• typealias deﬁnes a placeholder for an unknown type ...
• ... which can be used throughout the protocol deﬁnition
protocol Animal {
typealias Food
func eat(food:Food) { }
}
This sounds familiar...

typealias feels like a generic type parameter!
struct Animal<Food> {
}
protocol Animal {
typealias Food
}

Are PATs just generic protocols
with whacky syntax??
Does that explain everything?!

The problem associated types solve
Subtyping alone cannot capture rich type relations
protocol Food { }
struct Grass : Food { }
protocol Animal {
func eat(f:Food)
}
struct Cow : Animal {
func eat(f:Grass) { } // <- error, Cow must eat Food
}

The problem associated types solve
Subtyping alone cannot capture rich type relations
protocol Food { }
struct Grass : Food { }
protocol Animal {
typealias Food
func eat(f:Food)
}
struct Cow { }
extension Cow : Animal {
func eat(f:Food) { } // <- OK
}

But why not use generic protocol syntax?
/// imaginary generic protocol swift
protocol Animal<Food> {
func eat(food:Food)
}
extension Cow : Animal<Grass> {
func eat(f:Grass) { }
}

• Because from outside the protocol, consumers could only
see the associated type by parameterizing over it:
/// generic-protocol-swift
func feedAnimal<A:Animal<F>,F>(a:A) {
// I see an F, and oh yeah F is a type variable for food
}
• But Swift PATs provide direct named access to associated
type, like properties
func feedAnimal<A:Animal>(a:A) {
// I see the assoc type: A.Food
}

And this problem compounds when protocols:
• have many associated types
• which might themselves be constrained by protocols
• and we want to use them all at once

Generic Graph BFS in Java (v 1.3)
public class breadth_first_search {
public static <
GraphT extends VertexListGraph<Vertex, VertexIterator, ?> &
IncidenceGraph<Vertex, Edge, OutEdgeIterator, ?>,
Vertex,
Edge extends GraphEdge<Vertex>,
VertexIterator extends Collection<Vertex>,
OutEdgeIterator extends Collection<Edge>,
ColorMap extends ReadWritePropertyMap<Vertex, ColorValue>,
Visitor extends BFSVisitor<GraphT, Vertex, Edge>>
void go(GraphT g, Vertex s, ColorMap c, Visitor vis);
}

Generic Graph BFS in C++
template <class G, class C, class Vis>
void breadth_first_search(const G& g,
typename graph traits<G>::vertex s, C c, Vis vis);
// constraints:
// G models Vertex List Graph and Incidence Graph
// C models Read/Write Map
// map traits<C>::key == graph traits<G>::vertex
// map traits<C>::value models Color
// Vis models BFS Visitor

Generic Graph BFS in Haskell (Hugs 2002)
breadth_first_search ::
(VertexListGraph g v, IncidenceGraph g e v,
ReadWriteMap c v Color, BFSVisitor vis a g e v) =>
g ! v ! c ! vis ! a ! a

Two Worlds of Protocols
Without Self Requirement With Self Requirement
func precedes(other: Ordered) -> Bool func precedes(other: Self) -> Bool
Usable as a type
func sort(inout a: [Ordered])
Only usable as a generic constraint
func sort<T : Ordered>(inout a: [T])
Think“heterogeneous” Think“homogeneous”
Every model must deal with all others Models are free from interaction
Dynamic dispatch Static dispatch
Less optimizable More optimizable

Answers
How PATs are weird
• Lock you into generics and static dispatch
• typealias syntax plays two roles
• Associated type is as much like a required property as like a
type parameter

Answers
Why PATs are weird
• Rich, multi-type abstractions do not "ﬁt" in OOP subtyping
• Designed to address known issues with naive "generic
protocol" designs (complexity scales badly with more
associated types)

Answers
Yes, functioning as planned
• Seems informed by C++ concepts, Haskell type classes, SML
signatures, generics in C# and Java, abstract type members
in Scala, etc.
• Impact on OOP "protocol" pattern: collateral damage
• Existentials?

Answers
How to love them
• Call them PATs
• Embrace generics
• If you still need dynamic dispatch
• use enums to push runtime variation into values
• use type erasure to hide dynamic dispatch within a type
• wait for existentials?

Protocols with
Associated Types
and how they got that way
(but now we can just ask on swift-evolution, right?)

@alexisgallagher

Protocols with Associated Types, and How They Got That Way

More Related Content

What's hot (20)

Viewers also liked (15)

Similar to Protocols with Associated Types, and How They Got That Way (20)

Recently uploaded (20)

Protocols with Associated Types, and How They Got That Way