deploy: 06a1bdf735

vendor/gopl.io/ch6/coloredpoint/main.go

@@ -0,0 +1,89 @@
+// Copyright © 2016 Alan A. A. Donovan & Brian W. Kernighan.
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+// See page 161.
+
+// Coloredpoint demonstrates struct embedding.
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+//!+decl
+import "image/color"
+
+type Point struct{ X, Y float64 }
+
+type ColoredPoint struct {
+	Point
+	Color color.RGBA
+}
+
+//!-decl
+
+func (p Point) Distance(q Point) float64 {
+	dX := q.X - p.X
+	dY := q.Y - p.Y
+	return math.Sqrt(dX*dX + dY*dY)
+}
+
+func (p *Point) ScaleBy(factor float64) {
+	p.X *= factor
+	p.Y *= factor
+}
+
+func main() {
+	//!+main
+	red := color.RGBA{255, 0, 0, 255}
+	blue := color.RGBA{0, 0, 255, 255}
+	var p = ColoredPoint{Point{1, 1}, red}
+	var q = ColoredPoint{Point{5, 4}, blue}
+	fmt.Println(p.Distance(q.Point)) // "5"
+	p.ScaleBy(2)
+	q.ScaleBy(2)
+	fmt.Println(p.Distance(q.Point)) // "10"
+	//!-main
+}
+
+/*
+//!+error
+	p.Distance(q) // compile error: cannot use q (ColoredPoint) as Point
+//!-error
+*/
+
+func init() {
+	//!+methodexpr
+	p := Point{1, 2}
+	q := Point{4, 6}
+
+	distance := Point.Distance   // method expression
+	fmt.Println(distance(p, q))  // "5"
+	fmt.Printf("%T\n", distance) // "func(Point, Point) float64"
+
+	scale := (*Point).ScaleBy
+	scale(&p, 2)
+	fmt.Println(p)            // "{2 4}"
+	fmt.Printf("%T\n", scale) // "func(*Point, float64)"
+	//!-methodexpr
+}
+
+func init() {
+	red := color.RGBA{255, 0, 0, 255}
+	blue := color.RGBA{0, 0, 255, 255}
+
+	//!+indirect
+	type ColoredPoint struct {
+		*Point
+		Color color.RGBA
+	}
+
+	p := ColoredPoint{&Point{1, 1}, red}
+	q := ColoredPoint{&Point{5, 4}, blue}
+	fmt.Println(p.Distance(*q.Point)) // "5"
+	q.Point = p.Point                 // p and q now share the same Point
+	p.ScaleBy(2)
+	fmt.Println(*p.Point, *q.Point) // "{2 2} {2 2}"
+	//!-indirect
+}

vendor/gopl.io/ch6/geometry/geometry.go

@@ -0,0 +1,42 @@
+// Copyright © 2016 Alan A. A. Donovan & Brian W. Kernighan.
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+// See page 156.
+
+// Package geometry defines simple types for plane geometry.
+//!+point
+package geometry
+
+import "math"
+
+type Point struct{ X, Y float64 }
+
+// traditional function
+func Distance(p, q Point) float64 {
+	return math.Hypot(q.X-p.X, q.Y-p.Y)
+}
+
+// same thing, but as a method of the Point type
+func (p Point) Distance(q Point) float64 {
+	return math.Hypot(q.X-p.X, q.Y-p.Y)
+}
+
+//!-point
+
+//!+path
+
+// A Path is a journey connecting the points with straight lines.
+type Path []Point
+
+// Distance returns the distance traveled along the path.
+func (path Path) Distance() float64 {
+	sum := 0.0
+	for i := range path {
+		if i > 0 {
+			sum += path[i-1].Distance(path[i])
+		}
+	}
+	return sum
+}
+
+//!-path

vendor/gopl.io/ch6/intset/intset.go

@@ -0,0 +1,73 @@
+// Copyright © 2016 Alan A. A. Donovan & Brian W. Kernighan.
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+// See page 165.
+
+// Package intset provides a set of integers based on a bit vector.
+package intset
+
+import (
+	"bytes"
+	"fmt"
+)
+
+//!+intset
+
+// An IntSet is a set of small non-negative integers.
+// Its zero value represents the empty set.
+type IntSet struct {
+	words []uint64
+}
+
+// Has reports whether the set contains the non-negative value x.
+func (s *IntSet) Has(x int) bool {
+	word, bit := x/64, uint(x%64)
+	return word < len(s.words) && s.words[word]&(1<<bit) != 0
+}
+
+// Add adds the non-negative value x to the set.
+func (s *IntSet) Add(x int) {
+	word, bit := x/64, uint(x%64)
+	for word >= len(s.words) {
+		s.words = append(s.words, 0)
+	}
+	s.words[word] |= 1 << bit
+}
+
+// UnionWith sets s to the union of s and t.
+func (s *IntSet) UnionWith(t *IntSet) {
+	for i, tword := range t.words {
+		if i < len(s.words) {
+			s.words[i] |= tword
+		} else {
+			s.words = append(s.words, tword)
+		}
+	}
+}
+
+//!-intset
+
+//!+string
+
+// String returns the set as a string of the form "{1 2 3}".
+func (s *IntSet) String() string {
+	var buf bytes.Buffer
+	buf.WriteByte('{')
+	for i, word := range s.words {
+		if word == 0 {
+			continue
+		}
+		for j := 0; j < 64; j++ {
+			if word&(1<<uint(j)) != 0 {
+				if buf.Len() > len("{") {
+					buf.WriteByte(' ')
+				}
+				fmt.Fprintf(&buf, "%d", 64*i+j)
+			}
+		}
+	}
+	buf.WriteByte('}')
+	return buf.String()
+}
+
+//!-string

vendor/gopl.io/ch6/intset/intset_test.go

@@ -0,0 +1,50 @@
+// Copyright © 2016 Alan A. A. Donovan & Brian W. Kernighan.
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+package intset
+
+import "fmt"
+
+func Example_one() {
+	//!+main
+	var x, y IntSet
+	x.Add(1)
+	x.Add(144)
+	x.Add(9)
+	fmt.Println(x.String()) // "{1 9 144}"
+
+	y.Add(9)
+	y.Add(42)
+	fmt.Println(y.String()) // "{9 42}"
+
+	x.UnionWith(&y)
+	fmt.Println(x.String()) // "{1 9 42 144}"
+
+	fmt.Println(x.Has(9), x.Has(123)) // "true false"
+	//!-main
+
+	// Output:
+	// {1 9 144}
+	// {9 42}
+	// {1 9 42 144}
+	// true false
+}
+
+func Example_two() {
+	var x IntSet
+	x.Add(1)
+	x.Add(144)
+	x.Add(9)
+	x.Add(42)
+
+	//!+note
+	fmt.Println(&x)         // "{1 9 42 144}"
+	fmt.Println(x.String()) // "{1 9 42 144}"
+	fmt.Println(x)          // "{[4398046511618 0 65536]}"
+	//!-note
+
+	// Output:
+	// {1 9 42 144}
+	// {1 9 42 144}
+	// {[4398046511618 0 65536]}
+}

vendor/gopl.io/ch6/urlvalues/main.go

@@ -0,0 +1,53 @@
+// Copyright © 2016 Alan A. A. Donovan & Brian W. Kernighan.
+// License: https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+// See page 160.
+
+// The urlvalues command demonstrates a map type with methods.
+package main
+
+/*
+//!+values
+package url
+
+// Values maps a string key to a list of values.
+type Values map[string][]string
+
+// Get returns the first value associated with the given key,
+// or "" if there are none.
+func (v Values) Get(key string) string {
+	if vs := v[key]; len(vs) > 0 {
+		return vs[0]
+	}
+	return ""
+}
+
+// Add adds the value to key.
+// It appends to any existing values associated with key.
+func (v Values) Add(key, value string) {
+	v[key] = append(v[key], value)
+}
+//!-values
+*/
+
+import (
+	"fmt"
+	"net/url"
+)
+
+func main() {
+	//!+main
+	m := url.Values{"lang": {"en"}} // direct construction
+	m.Add("item", "1")
+	m.Add("item", "2")
+
+	fmt.Println(m.Get("lang")) // "en"
+	fmt.Println(m.Get("q"))    // ""
+	fmt.Println(m.Get("item")) // "1"      (first value)
+	fmt.Println(m["item"])     // "[1 2]"  (direct map access)
+
+	m = nil
+	fmt.Println(m.Get("item")) // ""
+	m.Add("item", "3")         // panic: assignment to entry in nil map
+	//!-main
+}