A simple way for polymorphism and structured programming - Go interfaces

A simple way for polymorphism and structured
programming
Polymorphism in Go
Robert Zaremba
AgFlow
Wroclaw 2015-01-08

Me
ii
Studied MSc of Computer Science at University of Wroclaw
http://rz.scale-it.pl
Profession
CTO @ AgFlow
Coding professionally in Go, Python, Haskell
Co-organizer of Geneva Haskell Group
Hiring
We are doing a world commodities market analysis. Contact me if
you are looking for an interesting job.
Robert Zaremba (AgFlow) Simple polymorphism Wroclaw 2015-01-08 2 / 29

What is a Polymorphism?
OOP
In object-oriented programming, polymorphism refers to a
programming language’s ability to process objects differently
depending on their data type or class.
For example, given a base class shape, polymorphism enables the
programmer to define different area methods for any number of
derived classes, such as circles, rectangles and triangles.

Biology
Morph
Greek: form, shape.
Is a visual or behavioural difference between organisms of distinct
populations.
Polymorphism in biology occurs when two or more clearly different
phenotypes exist in the same population of a species.
In order to be classified as such, morphs must occupy the same
habitat at the same time and belong to a panmictic population (all
individuals are potential partners).

Biology
Morph
Greek: form, shape.
Is a visual or behavioural difference between organisms of distinct
populations.
Polymorphism in biology occurs when two or more clearly different
phenotypes exist in the same population of a species.
In order to be classified as such, morphs must occupy the same
habitat at the same time and belong to a panmictic population (all
individuals are potential partners).
Also
Molecular biologists use that term to describe certain point mutations
in the genotype.

Computer Science
Algebra revision
A structure-preserving map from one mathematical structure to
another.

Computer Science
Algebra revision
another.
Programming Languages and type theory revision
provision of a single interface to entities of diﬀerent types.

Computer Science
Algebra revision
another.
Programming Languages and type theory revision
provision of a single interface to entities of diﬀerent types.
Key feature:
A value is polymorphic if there is more than one type it
can have.

Polymorphism ≡ multiple types?
What does it mean that value can have more
then one type?

Parametric polymorphism
Type of a value contains one or more (unconstrained) type variables.
id: a -> a

id: a -> a
data pair a b = Pair a b

id: a -> a
data pair a b = Pair a b
type uniﬁcation!

Ad-hoc polymorphism
Ad-hoc polymorphism
A value is able to adopt any one of several types.
Eg. because it, or a value it uses, has been given a separate deﬁnition
for each of those types
function multiple dispatch (C, Julia, . . . )

Ad-hoc polymorphism
Ad-hoc polymorphism
function multiple dispatch build in a language (eg building
operators overloading: +, -, *, ...

Ad-hoc polymorphism
Ad-hoc polymorphism
type classes

Ad-hoc polymorphism
Ad-hoc polymorphism
type classes
traits

Ad-hoc polymorphism
Ad-hoc polymorphism
type classes
traits
lambda calculus with parametric polymorphism

Subtyping
Well known inheritance.

Subtyping
Hate
What was ﬁrst: a chicken or an egg?

Subtyping
Hate
class Animal abstract String talk(); abstract
move(int, int)
Only Animals can talk? All animals can talk? What about voice
producing?

Subtyping
Hate
move(int, int)
producing?
http://www.scala-lang.org/api/current/#scala.
collection.Map — problem with inheritance hierarchy

Subtyping
Hate
move(int, int)
producing?
trait Map[A, +B] extends Iterable[(A, B)] with
GenMap[A, B] with MapLike[A, B, Map[A, B]]

Subtyping
Hate
move(int, int)
producing?
trait Iterable[+A] extends Traversable[A] with
GenIterable[A] with GenericTraversableTemplate[A,
Iterable] with IterableLike[A, Iterable[A]]

Subtyping
Hate
move(int, int)
producing?
trait Iterable[+A] extends Traversable[A] with
GenIterable[A] with GenericTraversableTemplate[A,
Iterable] with IterableLike[A, Iterable[A]]
Traversable, GenIterable, . . . “state of the art”? WTF??

Subtyping

Subtyping
Interfaces come to rescue!

Subtyping
And Scalas implicits
1 implicit def intToX(i: Int) = new X(i)

Subtyping
And Scalas implicits
1 implicit def intToX(i: Int) = new X(i)
Really?
1 def newTask = Action { implicit request =>
2 taskForm.bindFromRequest.fold(
3 errors => BadRequest(views.html.index(Task.all(), errors)),
4 label => {
5 Task.create(label)
6 Redirect(routes.Application.tasks())
7 }
8 )
9 }

Go programming language
Go is simple
Go is a super simple programming language
C-like
no inheritance
just functions
GC - a lot of heavy work has been done
awesome concurrency
static typed
https://golang.org/ref/spec 75 pages
compare to C++ spec: 1368 pages
zen of Go

Go programming language
Scope
We will not talk about awesome concurrency
We will talk about dynamic interfaces.

Go Interfaces
What is an interface in Go
Interfaces in Go
A simple, limited form of ad-hoc polymorphism. They provide a way
to specify the behavior of an object: if something can do this, then it
can be used here.

Go Interfaces
Interfaces in Go
can be used here.
Type overview:
pragmatic type system

Go Interfaces
Interfaces in Go
can be used here.
Type overview:
pragmatic type system
trade-oﬀ between scope bound OOP and super-hiper-fancy hard
type systems (hard Haskell, wtf Scala, having almost everything
C++).

Go Interfaces
1 package main
2 import (
3 "fmt"
4 "math"
5 )
6
7 type Vertex struct {
8 X, Y float64
9 }
10
11 func (v *Vertex) Abs() float64 {
12 return math.Sqrt(v.X*v.X + v.Y*v.Y)
13 }
14
15 func main() {
16 v := &Vertex{3, 4}
17 fmt.Println(v.Abs())
18 }

Go Interfaces
1 type Abser interface {
2 Abs() float64
3 }
4 type MyFloat float64
5 func (f MyFloat) Abs() float64 {
6 if f < 0 {
7 return float64(-f)
8 }
9 return float64(f)
10 }
11 func main() {
12 var a Abser
13 f := MyFloat(-math.Sqrt2)
14 v := Vertex{3, 4}
15 a = f // a MyFloat implements Abser
16 a = &v // a *Vertex implements Abser
17 // In the following line, v is a Vertex (not *Vertex)
18 // and does NOT implement Abser.
19 a = v

Go Interfaces
Interfaces are implicit
A type implements an interface by implementing the methods. There
is no ”implements” keyword.
Implicit interfaces decouple implementation packages from the
packages that deﬁne the interfaces: neither depends on the other.
Unlike Haskell you don’t need to explicitly implement type classes.

Go Interfaces
Minimalism and compose-ability
Like in haskell you are encourage to declare minimum meaningful
interfaces and compose them.
1 type Reader interface {
2 Read(b []byte) (n int, err error)
3 }
4
5 type Writer interface {
6 Write(b []byte) (n int, err error)
7 }
8
9 type ReadWriter interface {
10 Reader
11 Writer
12 }

Go Interfaces
Alternative implementations
Like in Haskell you need to wrap types if you want to provide more
then one implementation of some interface.
1 type VertexManhattan {
2 Vertex
3 }
4
5 func (v *VertexManhattan) Abs() float64 {
6 return MyFloat(v.X).Abs() + MyFloat(v.Y).Abs()
7 }

Go Interfaces
Minimalism and API clarity
Ideally all your packages should expose interface values.
All your package functions should take interfaces instead of struct
types.
Interface upgrades
There is a powerful feature - interface updates. From the minimum
implementation you can check more powerful object features by
checking which other interfaces are implemented from a minimum
type.

Go dynamic Interfaces
dynamic type
Go types can be cast to wider or even unrelated interfaces if their
dynamic types support it.
Duck duck typing!

The io package deﬁnes two auxiliary types, io.WriterTo and
io.ReaderFrom which io.Readers and io.Writers (respectively) may
optionally implement.
1 func Copy(dst Writer, src Reader) (written int64, err error) {
2 // If the reader has a WriteTo method, use it to
3 // do the copy. Avoids an allocation and a copy.
4 if wt, ok := src.(WriterTo); ok {
5 return wt.WriteTo(dst)
6 }
7 // Similarly, if the writer has a ReadFrom method,
8 // use it to do the copy.
9 if rt, ok := dst.(ReaderFrom); ok {
10 return rt.ReadFrom(src)
11 }
12 ...

1 buf := make([]byte, 32*1024)
2 for {
3 nr, er := src.Read(buf)
4 if nr > 0 {
5 nw, ew := dst.Write(buf[0:nr])
6 if nw > 0 {
7 written += int64(nw)
8 }

Go interfaces trap
1 type StatusLogger struct {
2 http.ResponseWriter
3 StatusCode int
4 }
5
6 func (s *StatusLogger) WriteHeader(code int) {
7 s.StatusCode = code
8 s.ResponseWriter.WriteHeader(code)
9 }
StatusLogger only implements http.ResponseWriter, even so
the underlying object may implement rich functionality.
it doesn’t implement any interface upgrades. Using it you will
not provide all performance characteristics (eg. through
ReaderFrom) even the underlying response writer will provide
them.

Go interfaces trap
3 StatusCode int
4 }
5
9 }
It is impossible to write a general-purpose proxy type.
All proxy interfaces will hide possible interface updates

Go interfaces trap
3 StatusCode int
4 }
5
9 }
Solution: you will need to manually implement a new structure
which will satisfy a richer interface, as shown in the example below.

Writing a proxy object
Wrapping a ResponseWriter
A Writer wrapper from Goji web framework.
1 // WrapWriter wraps an http.ResponseWriter into a proxy that
2 // allows you to hook into various parts of the response process.
3 func WrapWriter(w http.ResponseWriter) WriterProxy {
4 _, cn := w.(http.CloseNotifier)
5 _, fl := w.(http.Flusher)
6 _, hj := w.(http.Hijacker)
7 _, rf := w.(io.ReaderFrom)
8 bw := basicWriter{ResponseWriter: w}
9 if cn && fl && hj && rf {
10 return &fancyWriter{bw}
11 }
12 return &bw
13 }

Basic writer in action
1 func (b *basicWriter) Write(buf []byte) (int, error) {
2 b.WriteHeader(http.StatusOK)
3 n, err := b.ResponseWriter.Write(buf)
4 if b.tee != nil {
5 _, err2 := b.tee.Write(buf[:n])
6 // Prefer errors generated by the proxied writer.
7 if err == nil {
8 err = err2
9 }
10 }
11 b.bytes += n
12 return n, err
13 }

Fancy writer in Action
1 type fancyWriter struct {
2 basicWriter
3 }
4 func (f *fancyWriter) CloseNotify() <-chan bool {
5 cn := f.basicWriter.ResponseWriter.(http.CloseNotifier)
6 return cn.CloseNotify()
7 }
8 func (f *fancyWriter) Flush() {
9 ...}
10 func (f *fancyWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
11 ...}
12 func (f *fancyWriter) ReadFrom(r io.Reader) (int64, error) {
13 if f.basicWriter.tee != nil {
14 return io.Copy(&f.basicWriter, r)
15 }
16 rf := f.basicWriter.ResponseWriter.(io.ReaderFrom)
17 f.basicWriter.maybeWriteHeader()
18 return rf.ReadFrom(r)
19 }

Go interfaces limitations
No parametric polymorphism and limited Ad-hoc polymorphism.
In 99% of cases you won’t need it!

Workaround: go generate

Workaround: go generate
A real solution may come as soon as people will ﬁnd an easy
polymorphic type system which will integrate well with go interfaces.
By now go generate is making a good job for this corner cases.

Summary
A simple type system based on dynamic interfaces
provides a powerful tool for software architects which
will help design and maintain software systems.
Idea for OOP:
Unless you want to extend / wrap some object it may
be interesting to use only abstract inheritance in OOP.

A simple way for polymorphism and structured programming - Go interfaces

More Related Content

Similar to A simple way for polymorphism and structured programming - Go interfaces

Recently uploaded

A simple way for polymorphism and structured programming - Go interfaces