understanding

Size: px

Start display at page:

Download "understanding"

Shawn Jessie Davidson
5 years ago
Views:

1 understanding

2 thanks

3 welcome every single one of you

4 agenda what is nil? what is nil in Go? what does nil mean? is nil useful?

5 nil? you misspelled null

6 how I learn words

7 how I learn words

8 etymology nil Latin nihil meaning nothing null Latin ne + ullus meaning not any none Old English ne + ān meaning not one

9 names for the number zero in English - zero null duck nada zip naught aught - cipher love nil zilch the letter o nought ought source: wikipedia

10 nil is (a) zero

11 interlude a bit of history

13 I call it my billion-dollar mistake. It was the invention of the null reference in At that time, I was designing the first comprehensive type system for references in an object oriented language. - Sir C.A.R. Hoare

14 panic: runtime error: invalid memory address or nil pointer dereference

15 Uncaught TypeError: undefined is not a function

17 nil leads to panic

18 panic leads to fear by danpawley on Flickr

19 fear leads to by korymatthew on Flickr

20 λ functional programming

21 Functional Go? Thanks, but no - francesc at dotgo.eu 2015

22 there are many ways, nil is the Go way

23 </interlude>

24 zero values what are they?

25 zero values bool false pointers nil numbers 0 slices nil string "" maps nil channels nil functions nil interfaces nil

26 zero values for struct types type Person struct { AgeYears int Name string Friend []Person } var p Person // Person{0, "", nil}

27 the type of nil

28 ... unless the value is the predeclared identifier nil, which has no type - Go language specification

29 untyped zero a := false a := "" a := 0 // a := int(0) a := 0.0 // a := float64(0) a := nil // use of untyped nil

30 nil is a predeclared identifier representing the zero value for a pointer, channel, func, interface, map, or slice type. - Go documentation for builtin package

31 nil is a predeclared identifier representing the zero value for a pointer, channel, func, interface, map, or slice type. - Go documentation for builtin package

32 twenty-five* keywords break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var * plus the five secret ones, obviously

33 predefined vs keyword // YOLO var nil = errors.new( \_(ツ)_/ ) * For extra evilness: place at the end of doc.go

34 zero values what do they mean?

35 kinds of nil pointers slices maps channels functions interfaces

36 kinds of nil pointers slices maps channels functions interfaces

37 pointers in Go - they point to a position in memory - similar to C or C++, but - no pointer arithmetic memory safety - garbage collection

38 nil pointer - points to nil a.k.a. nothing - zero value of pointers

39 kinds of nil pointers slices maps channels functions interfaces

40 slice internals []byte ptr *elem len int cap int

41 a slice with five elements []byte ptr len 5 cap 5 [5]byte s := make([]byte, 5)

42 nil slice []byte ptr nil len 0 cap 0 var s []byte

43 kinds of nil pointers slices maps channels functions interfaces

44 channels, maps, and functions ptr *something

45 channels, maps, and functions ptr implementation * implementations might not be cloud shaped

46 channels, maps, and functions ptr nil

47 kinds of nil pointers slices maps channels functions interfaces

48 (type, value)

49 var s fmt.stringer // Stringer (nil, nil) fmt.println(s == nil) // true

50 (nil, nil) equals nil

51 var p *Person // nil of type *Person var s fmt.stringer = p // Stringer (*Person, nil) fmt.println(s == nil) // false

52 (*Person, nil) doesn t equal nil

53 when is nil not nil?

54 when is nil not nil? func do() error { var err *doerror return err } // error (*doerror, nil) // nil of type *doerror func main() { err := do() fmt.println(err == nil) } // error (*doerror, nil) // false

55 do not declare concrete error vars

56 nil is not nil func do() *doerror { // nil of type *doerror return nil } func main() { err := do() fmt.println(err == nil) } // nil of type *doerror // true

57 nil is not nil func do() *doerror { return nil } // nil of type *doerror func wrapdo() error { return do() } // error (*doerror, nil) // nil of type *doerror func main() { err := wrapdo() fmt.println(err == nil) } // error (*doerror, nil) // false

58 do not return concrete error types

59 nil is not nil * for some kinds of nil

60 kinds of nil pointers point to nothing slices have no backing array maps are not initialized channels are not initialized functions are not initialized interfaces have no value assigned, not even a nil pointer

61 Make the zero value useful - Rob Pike in his Go Proverbs

62 how are these useful? pointers slices maps channels functions interfaces

63 how are these useful? pointers slices maps channels functions interfaces

64 pointers var p *int p == nil // true *p // panic: invalid memory address or nil pointer dereference

65 coding time

66 implement Sum type tree struct { v int l *tree r *tree } func (t *tree) Sum() int

67 a first solution func (t *tree) Sum() int { sum := t.v 6 if t.l!= nil { sum += t.l.sum() } if t.r!= nil { sum += t.r.sum() } return sum }

68 issues Code repetition: if v!= nil { v.m() } Panic when t is nil var t *tree sum := t.sum() // panic: invalid memory address or nil pointer dereference

69 pointer receivers type person struct {} func sayhi(p *person) { fmt.println( hi ) } func (p *person) sayhi() { fmt.println( hi ) } var p *person p.sayhi() // hi

70 nil receivers are useful 零

71 nil receivers are useful: Sum func (t *tree) Sum() int { if t == nil { return 0 } return t.v + t.l.sum() + t.r.sum() }

72 nil receivers are useful: String func (t *tree) String() string { if t == nil { return "" } return fmt.sprint(t.l, t.v, t.r) }

73 nil receivers are useful: Find func (t *tree) Find(v int) bool { if t == nil { return false } return t.v == v t.l.find(v) t.r.find(v) }

74 keep nil useful if possible, if not NewX()

75 how are these useful? pointers slices maps channels functions interfaces

76 nil slices var s []slice len(s) // 0 cap(s) // 0 for range s // iterates zero times s[i] // panic: index out of range

77 append on nil slices var s []int for i := 0; i < 10; i++ { fmt.printf("len: %2d cap: %2d\n", len(s), cap(s)) s = append(s, i) }

78 $ go run slices.go len: len: len: len: len: len: len: len: len: len: cap: 0 cap: 1 cap: 2 cap: 4 cap: 4 cap: 8 cap: 8 cap: 8 cap: 8 cap: 16 [] s is nil! [0] allocation [0 1] reallocation [0 1 2] reallocation [ ] [ ] reallocation [ ] [ ] [ ] [ ] reallocation

79 use nil slices they re often fast enough

80 how are these useful? pointers slices maps channels functions interfaces

81 nil maps var m map[t]u len(m) // 0 for range m // iterates zero times v, ok := m[i] // zero(u), false m[i] = x // panic: assignment to entry in nil map

82 using maps func NewGet(url string, headers map[string]string) (*http.request, error) { req, err := http.newrequest(http.methodget, url, nil) if err!= nil { return nil, err } for k, v := range headers { req.header.set(k, v) } return req, nil }

83 using maps NewGet( " map[string]string{ "USER_AGENT": "golang/gopher", }, )

84 $ go run request.go GET / HTTP/1.1 Host: google.com User_agent: golang/gopher

85 using empty maps NewGet(" map[string]string{})

86 $ go run request.go GET / HTTP/1.1 Host: google.com

87 using empty maps NewGet(" map[string]string{})

88 nil maps are valid empty maps NewGet(" nil)

89 $ go run request.go GET / HTTP/1.1 Host: google.com

90 use nil maps as read-only empty maps

91 how are these useful? pointers slices maps channels functions interfaces

92 nil channels var c chan t <- c // blocks forever c <- x // blocks forever close(c) // panic: close of nil channel

93 coding time

94 b a func merge(out chan<- int, a, b <-chan int) out

95 a naive solution func merge(out chan<- int, a, b <-chan int) { for { select { case v := <-a: out <- v case v := <-b: out <- v } } }

96 $ go run naive.go

97 closed channels var c chan t v, ok <- c // zero(t), false c <- x // panic: send on closed channel close(c) // panic: close of nil channel

98 a naive solution func merge(out chan<- int, a, b <-chan int) { for { select { case v := <-a: out <- v case v := <-b: out <- v } } }

99 checking for closed chans case v, ok := <-a: if!ok { aclosed = true continue } out <- v // analogous code for case b

100 checking for closed chans func merge(out chan<- int, a, b <-chan int) { var aclosed, bclosed bool for!aclosed!bclosed { select { case v, ok := <-a: if!ok { aclosed = true; continue } out <- v case v, ok := <-b: if!ok { bclosed = true; continue } out <- v } } }

101 $ go run checkforclosed.go fatal error: all goroutines are asleep - deadlock! goroutine 1 [chan receive]: main.main() /Users/campoy/src/github.com/campoy/talks/nil/talk/code/chans. go:97 +0x15a exit status 2

102 and closing channel out func merge(out chan<- int, a, b <-chan int) { var aclosed, bclosed bool for!aclosed!bclosed { select { case v, ok := <-a: if!ok { aclosed = true; continue } out <- v case v, ok := <-b: if!ok { bclosed = true; continue } out <- v } } close(out) }

103 and closing channel out func merge(out chan<- int, a, b <-chan int) { var aclosed, bclosed bool for!aclosed!bclosed { select { case v, ok := <-a: if!ok { aclosed = true; continue } out <- v case v, ok := <-b: if!ok { bclosed = true; continue } out <- v } } close(out) }

104 $ go run closingout.go

105 ship it! Fancy Gopher by Renee French

106 by hzeller on Flickr

107 let s log case v, ok := <-a: if!ok { aclosed = true fmt.println("a is now closed") continue } out <- v // analogous code for case b

108 $ go run withlogs.go b is now closed b is now closed 1 b is now closed b is now closed 1 a is now closed

109 let s log var aclosed, bclosed bool for!aclosed!bclosed { select { case v, ok := <-a: if!ok { aclosed = true; continue } out <- v case v, ok := <-b: if!ok { bclosed = true; continue } out <- v } } close(out)

110 can we switch off a chan?

111 nil channels var c chan t <- c // blocks forever c <- x // blocks forever close(c) // panic: close of nil channel

112 switching off a channel case v, ok := <-a: if!ok { aclosed = true fmt.println("a is now closed") continue } out <- v // analogous code for case b

113 switching off a channel case v, ok := <-a: if!ok { a = nil fmt.println("a is now closed") continue } out <- v // analogous code for case b

114 switching off a channel; no logs func merge(out chan<- int, a, b <-chan int) { for a!= nil b!= nil { select { case v, ok := <-a: if!ok { a = nil; continue } out <- v case v, ok := <-b: if!ok { b = nil; continue } out <- v } } close(out) }

115 $ go run closingout.go

116 fancy party time! Fancy Gopher by Renee French

117 use nil chans to disable a select case

118 how are these useful? pointers slices maps channels functions interfaces

119 nil funcs Go has first-class functions functions can be used as struct fields they need a zero value; logically it is nil type Foo struct { f func() error }

120 nil funcs for default values lazy initialization of variables nil can also imply default behavior func NewServer(logger func(string, interface{})) { if logger == nil { logger = log.printf } logger("initializing %s", os.getenv("hostname")) }

121 how are these useful? pointers slices maps channels functions interfaces

122 interfaces The nil interface is used as a signal if err!= nil { }

123 why does nil *Person not equal nil interface? 零

124 summer type Summer interface { func Sum() int }

125 summer var t *tree var s Summer = t fmt.println(t == nil, s.sum()) // true 0

126 summer type ints []int func (i ints) Sum() int { s := 0 for _, v := range i { s += v } return s }

127 summer var i ints var s Summer = i fmt.println(i == nil, s.sum()) // true 0

128 nil values can satisfy interfaces 零

129 nil values and default values func dosum(s Summer) int { if s == nil { return 0 } return s.sum() }

130 nil values and default values var t *tree dosum(t) // (*tree, nil) var i ints dosum(i) // (ints, nil) dosum(nil) // (nil, nil)

131 nil values and default values http.listenandserve("localhost:8080", nil)

132 use nil interfaces to signal default 零

133

134 nil is useful

135 nil is useful pointers methods can be called on nil receivers slices perfectly valid zero values maps perfect as read-only values channels essential for some concurrency patterns functions needed for completeness interfaces the most used signal in Go (err!= nil)

136 nil is an important part Go 零

137 let s not avoid nil

138 let s embrace nil golang.org/s/nil

Go Cheat Sheet. Operators. Go in a Nutshell. Declarations. Basic Syntax. Hello World. Functions. Comparison. Arithmetic. Credits

Go Cheat Sheet. Operators. Go in a Nutshell. Declarations. Basic Syntax. Hello World. Functions. Comparison. Arithmetic. Credits Credits Go Cheat Sheet Most example code taken from A Tour of Go, which is an excellent introduction to Go. If you're new to Go, do that tour. Seriously. Original HTML Cheat Sheet by Ariel Mashraki (a8m):