Slides for my Lone Star Ruby Conf V presentat

1. Rou
gh
Cut
!
Google Go
for Ruby Hackers
Eleanor McHugh
http://slides.games-with-brains.net/

2. Go Ruby
compilation static AOT runtime mutable
memory garbage collected
syntax minimalist humanistic
strong dynamic
type
embedding inheritance
dispatch procedural invocation message passing
semantics statements expressions

3. minimalist

4. package
organisation import
var, const, type
declaration
func, interface, map, struct, chan
if ... else
switch ... case ... fallthrough ... default
select ... case
control flow for
for ... range
break, continue
go, goto, defer, return

5. boolean, numeric, array
value
structure, interface
reference pointer, slice, string, map, channel
invocation function, method, closure

6. package main
import “fmt”
const HELLO string = “hello”
var WORLD string = “world”
func main() {
fmt.Println(HELLO, WORLD)
}

7. package main
import “fmt”
const HELLO string = “hello”
var WORLD string = “world”
func main() {
fmt.Println(HELLO, WORLD)
}

8. package main
import “fmt”
const HELLO string = “hello”
var WORLD string = “world”
func main() {
fmt.Println(HELLO, WORLD)
}

9. package main
import “fmt”
const HELLO string = “hello”
var WORLD string = “world”
func main() {
fmt.Println(HELLO, WORLD)
}

10. type in Ruby

11. class Counter
attr_writer :count
def initialize
@count = 0
end
def Tick
@count += 1
end
end
class DoubleCounter < Counter
def Tick
super
@count += 1
end
end
n = new(DoubleCounter)
puts n.Tick
puts n.superclass.Tick

12. instance inherited
class class
expressed
type

13. class Counter
attr_writer :count
def initialize
@count = 0
end
def Tick
@count += 1
end
end
class DoubleCounter < Counter
def Tick
super
@count += 1
end
end
n = new(DoubleCounter)
puts n.Tick
puts n.superclass.Tick

14. instance inherited
class class
expressed
type

15. class Counter
attr_writer :count
def initialize
@count = 0
end
def Tick
@count += 1
end
end
class DoubleCounter < Counter
def Tick
super
@count += 1
end
end
n = new(DoubleCounter)
puts n.Tick
puts n.superclass.Tick

16. instance inherited
class class
expressed
type

17. class Counter
attr_writer :count
def initialize
@count = 0
end
def Tick
@count += 1
end
end
class DoubleCounter < Counter
def Tick
super
@count += 1
end
end
n = new(DoubleCounter)
puts n.Tick
puts n.superclass.Tick

18. class Counter
attr_writer :count
def initialize
@count = 0
end
def Tick
@count += 1
end
end
class DoubleCounter < Counter
def Tick
super
@count += 1
end
end
n = new(DoubleCounter)
puts n.Tick
puts n.superclass.Tick

19. class Counter
attr_writer :count
def initialize
@count = 0
end
def Tick
@count += 1
end
end
class DoubleCounter < Counter
def Tick
super
@count += 1
end
end
n = new(DoubleCounter)
puts n.Tick
puts n.superclass.Tick

20. instance inherited
class class
expressed
type
modules

21. superclass modules
class modules
message
instance

22. superclass modules
class modules
type asserted
instance

23. down a rabbit hole
instances are their own classes

24. down a rabbit hole
instances are their own classes
and all classes are mutable at runtime

25. down a rabbit hole
instances are their own classes
all classes are mutable at runtime
so inheritance pathways can be altered

26. down a rabbit hole
instances are their own classes
and all classes are mutable at runtime
so inheritance pathways can be altered
making Ruby very flexible

27. down a rabbit hole
instances are their own classes
and all classes are mutable at runtime
so inheritance pathways can be altered
making Ruby very flexible
at the cost of type uncertainty

28. down a rabbit hole
instances are their own classes
and all classes are mutable at runtime
so inheritance pathways can be altered
making Ruby very flexible
at the cost of type uncertainty
which really bugs computer scientists

29. type in Go

30. package Integer
type Int int
func (i *Int) Add(x int) {
*i += Int(x)
}

31. memory method
type
layout set

32. package Integer
type Int int
func (i *Int) Add(x int) {
*i += Int(x)
}

33. memory method
type
layout set

34. package Integer
type Int int
func (i *Int) Add(x int) {
*i += Int(x)
}

35. memory static method
layout type set

36. package Integer
type Int int
func (i *Int) Add(x int) {
*i += Int(x)
}

37. type Buffer []Int
func (b Buffer) Swap(i, j int) {
b[i], b[j] = b[j], b[i]
}
func (b Buffer) Clone() Buffer {
s := make(Buffer, len(b))
copy(s, b)
return s
}
func (b Buffer) Move(i, n int) {
if n > len(b) - i {
n = len(b) - i
}
segment_to_move := b[:i].Clone()
copy(b, b[i:i + n])
copy(b[n:i + n], segment_to_move)
}

38. type Buffer []Int
func (b Buffer) Swap(i, j int) {
b[i], b[j] = b[j], b[i]
}
func (b Buffer) Clone() Buffer {
s := make(Buffer, len(b))
copy(s, b)
return s
}
func (b Buffer) Move(i, n int) {
if n > len(b) - i {
n = len(b) - i
}
segment_to_move := b[:i].Clone()
copy(b, b[i:i + n])
copy(b[n:i + n], segment_to_move)
}

39. type Buffer []Int
func (b Buffer) Swap(i, j int) {
b[i], b[j] = b[j], b[i]
}
func (b Buffer) Clone() Buffer {
s := make(Buffer, len(b))
copy(s, b)
return s
}
func (b Buffer) Move(i, n int) {
if n > len(b) - i {
n = len(b) - i
}
segment_to_move := b[:i].Clone()
copy(b, b[i:i + n])
copy(b[n:i + n], segment_to_move)
}

40. package main
import “fmt”
import "Integer"
func main() {
i := Integer.Buffer{0, 1, 2, 3, 4, 5} produces:
b := i.Clone() b[0:2] = [6 4]
b.Swap(1, 2)
b.Move(3, 2)
b[0].Add(3)
fmt.Printf(“b[0:2] = %vn”, b[:2])
}

41. package main
import “fmt”
import "Integer"
func main() {
i := Integer.Buffer{0, 1, 2, 3, 4, 5} produces:
b := i.Clone() b[0:2] = [6 4]
b.Swap(1, 2)
b.Move(3, 2)
b[0].Add(3)
fmt.Printf(“b[0:2] = %vn”, b[:2])
}

42. package main
import “fmt”
import "Integer"
func main() {
i := Integer.Buffer{0, 1, 2, 3, 4, 5} produces:
b := i.Clone() b[0:2] = [6 4]
b.Swap(1, 2)
b.Move(3, 2)
b[0].Add(3)
fmt.Printf(“b[0:2] = %vn”, b[:2])
}

43. package main
import “fmt”
import "Integer"
func main() {
i := Integer.Buffer{0, 1, 2, 3, 4, 5} produces:
b := i.Clone() b[0:2] = [6 4]
b.Swap(1, 2)
b.Move(3, 2)
b[0].Add(3)
fmt.Printf(“b[0:2] = %vn”, b[:2])
}

44. package main
import “fmt”
import "Integer"
func main() {
i := Integer.Buffer{0, 1, 2, 3, 4, 5} produces:
b := i.Clone() b[0:2] = [6 4]
b.Swap(1, 2)
b.Move(3, 2)
b[0].Add(3)
fmt.Printf(“b[0:2] = %vn”, b[:2])
}

45. package Vector
import . "Integer"
type Vector struct {
Buffer
}
func (v *Vector) Clone() *Vector {
return &Vector{v.Buffer.Clone()}
}
func (v *Vector) Slice(i, j int) Buffer {
return v.Buffer[i:j]
}

46. package Vector
import . "Integer"
type Vector struct {
Buffer
}
func (v *Vector) Clone() *Vector {
return &Vector{v.Buffer.Clone()}
}
func (v *Vector) Slice(i, j int) Buffer {
return v.Buffer[i:j]
}

47. package Vector
import . "Integer"
type Vector struct {
Buffer
}
func (v *Vector) Clone() *Vector {
return &Vector{v.Buffer.Clone()}
}
func (v *Vector) Slice(i, j int) Buffer {
return v.Buffer[i:j]
}

48. package Vector
import . "Integer"
type Vector struct {
Buffer
}
func (v *Vector) Clone() *Vector {
return &Vector{v.Buffer.Clone()}
}
func (v *Vector) Slice(i, j int) Buffer {
return v.Buffer[i:j]
}

49. package Vector
import . "Integer"
type Vector struct {
Buffer
}
func (v *Vector) Clone() *Vector {
return &Vector{v.Buffer.Clone()}
}
func (v *Vector) Slice(i, j int) Buffer {
return v.Buffer[i:j]
}

50. memory method
layout set
static
type
embedded
types

51. now the clever bit

52. type Adder interface {
Add(j int)
Subtract(j int)
Result() interface{}
Reset()
}

53. type Adder interface {
Add(j int)
Subtract(j int)
Result() interface{}
Reset()
}

54. type Adder interface {
Add(j int)
Subtract(j int)
Result() interface{}
Reset()
}

55. type IAdder int
func (i IAdder) Add(j int) {
i[0] += i[j]
}
func (i IAdder) Subtract(j int) {
i[0] -= i[j]
}
func (i IAdder) Result() interface{} {
return i[0]
}
func (i IAdder) Reset() {
i[0] = *new(int)
}
func (i IAdder) Increment() {
i[0]++
}

56. type IAdder int
func (i IAdder) Add(j int) {
i[0] += i[j]
}
func (i IAdder) Subtract(j int) {
i[0] -= i[j]
}
func (i IAdder) Result() interface{} {
return i[0]
}
func (i IAdder) Reset() {
i[0] = *new(int)
}
func (i IAdder) Increment() {
i[0]++
}

57. type IAdder int
func (i IAdder) Add(j int) {
i[0] += i[j]
}
func (i IAdder) Subtract(j int) {
i[0] -= i[j]
}
func (i IAdder) Result() interface{} {
return i[0]
}
func (i IAdder) Reset() {
i[0] = *new(int)
}
func (i IAdder) Increment() {
i[0]++
}

58. type IAdder int
func (i IAdder) Add(j int) {
i[0] += i[j]
}
func (i IAdder) Subtract(j int) {
i[0] -= i[j]
}
func (i IAdder) Result() interface{} {
return i[0]
}
func (i IAdder) Reset() {
i[0] = *new(int)
}
func (i IAdder) Increment() {
i[0]++
}

59. type IAdder int
func (i IAdder) Add(j int) {
i[0] += i[j]
}
func (i IAdder) Subtract(j int) {
i[0] -= i[j]
}
func (i IAdder) Result() interface{} {
return i[0]
}
func (i IAdder) Reset() {
i[0] = *new(int)
}
func (i IAdder) Increment() {
i[0]++
}

60. type FAdder []float32
func (f FAdder) Add(j int) {
f[0] += f[j]
}
func (f FAdder) Subtract(j int) {
f[0] -= f[j]
}
func (f FAdder) Result() interface{} {
return f[0]
}
func (f FAdder) Reset() {
f[0] = 0
}

61. type FAdder []float32
func (f FAdder) Add(j int) {
f[0] += f[j]
}
func (f FAdder) Subtract(j int) {
f[0] -= f[j]
}
func (f FAdder) Result() interface{} {
return f[0]
}
func (f FAdder) Reset() {
f[0] = 0
}

62. type FAdder []float32
func (f FAdder) Add(j int) {
f[0] += f[j]
}
func (f FAdder) Subtract(j int) {
f[0] -= f[j]
}
func (f FAdder) Result() interface{} {
return f[0]
}
func (f FAdder) Reset() {
f[0] = 0
}

63. func TestAdder(t *testing.T) {
var a Adder
a = IAdder{0, 1, 2}
a.Add(1)
if i.Result().(int) != 1 {
t.Fatalf("IAdder::Add(1) %v != %v", a.Result(), 1)
}
a.Subtract(2)
if a.Result().(int) != -1 {
t.Fatalf("IAdder::Subtract(2) %v != %v", a.Result(), -1)
}
a = FAdder{0.0, 1.0, 2.0}
a.Add(1)
if a.Result().(float32) != 1.0 {
t.Fatalf("FAdder::Add(1) %v != %v", a.Result(), 1.0)
}
}

64. func TestAdder(t *testing.T) {
var a Adder
a = IAdder{0, 1, 2}
a.Add(1)
if i.Result().(int) != 1 {
t.Fatalf("IAdder::Add(1) %v != %v", a.Result(), 1)
}
a.Subtract(2)
if a.Result().(int) != -1 {
t.Fatalf("IAdder::Subtract(2) %v != %v", a.Result(), -1)
}
a = FAdder{0.0, 1.0, 2.0}
a.Add(1)
if a.Result().(float32) != 1.0 {
t.Fatalf("FAdder::Add(1) %v != %v", a.Result(), 1.0)
}
}

65. func TestAdder(t *testing.T) {
var a Adder
a = IAdder{0, 1, 2}
a.Add(1)
if i.Result().(int) != 1 {
t.Fatalf("IAdder::Add(1) %v != %v", a.Result(), 1)
}
a.Subtract(2)
if a.Result().(int) != -1 {
t.Fatalf("IAdder::Subtract(2) %v != %v", a.Result(), -1)
}
a = FAdder{0.0, 1.0, 2.0}
a.Add(1)
if a.Result().(float32) != 1.0 {
t.Fatalf("FAdder::Add(1) %v != %v", a.Result(), 1.0)
}
}

66. func TestAdder(t *testing.T) {
var a Adder
a = IAdder{0, 1, 2}
a.Add(1)
if i.Result().(int) != 1 {
t.Fatalf("IAdder::Add(1) %v != %v", a.Result(), 1)
}
a.Subtract(2)
if a.Result().(int) != -1 {
t.Fatalf("IAdder::Subtract(2) %v != %v", a.Result(), -1)
}
a = FAdder{0.0, 1.0, 2.0}
a.Add(1)
if a.Result().(float32) != 1.0 {
t.Fatalf("FAdder::Add(1) %v != %v", a.Result(), 1.0)
}
}

67. func TestAdder(t *testing.T) {
var a Adder
a = IAdder{0, 1, 2}
a.Add(1)
if i.Result().(int) != 1 {
t.Fatalf("IAdder::Add(1) %v != %v", a.Result(), 1)
}
a.Subtract(2)
if a.Result().(int) != -1 {
t.Fatalf("IAdder::Subtract(2) %v != %v", a.Result(), -1)
}
a = FAdder{0.0, 1.0, 2.0}
a.Add(1)
if a.Result().(float32) != 1.0 {
t.Fatalf("FAdder::Add(1) %v != %v", a.Result(), 1.0)
}
}

68. func TestAdder(t *testing.T) {
var a Adder
a = IAdder{0, 1, 2}
a.Add(1)
if i.Result().(int) != 1 {
t.Fatalf("IAdder::Add(1) %v != %v", a.Result(), 1)
}
a.Subtract(2)
if a.Result().(int) != -1 {
t.Fatalf("IAdder::Subtract(2) %v != %v", a.Result(), -1)
}
a = FAdder{0.0, 1.0, 2.0}
a.Add(1)
if a.Result().(float32) != 1.0 {
t.Fatalf("FAdder::Add(1) %v != %v", a.Result(), 1.0)
}
}

69. func TestAdder(t *testing.T) {
var a Adder
a = IAdder{0, 1, 2}
a.Add(1)
if i.Result().(int) != 1 {
t.Fatalf("IAdder::Add(1) %v != %v", a.Result(), 1)
}
a.Subtract(2)
if a.Result().(int) != -1 {
t.Fatalf("IAdder::Subtract(2) %v != %v", a.Result(), -1)
}
a = FAdder{0.0, 1.0, 2.0}
a.Add(1)
if a.Result().(float32) != 1.0 {
t.Fatalf("FAdder::Add(1) %v != %v", a.Result(), 1.0)
}
}

70. down a rabbit hole
an object has known static type

71. down a rabbit hole
an object has known static type
this fixed type is determined at linking

72. down a rabbit hole
an object has known static type
this fixed type is determined at linking
no new types can be created at runtime

73. down a rabbit hole
an object has known static type
this fixed type is determined at linking
no new types can be created at runtime
so dynamism is bounded to a fixed set

74. down a rabbit hole
an object has known static type
this fixed type is determined at linking
no new types can be created at runtime
so dynamism is bounded to this fixed set
and computer scientists are happier

75. testing

76. func (b Buffer) Eq(o Buffer) (r bool) {
if len(b) == len(o) {
for i := len(b) - 1; i > 0; i-- {
if b[i] != o[i] {
return
}
}
r = true
}
return
}

77. func (b Buffer) Eq(o Buffer) (r bool) {
if len(b) == len(o) {
for i := len(b) - 1; i > 0; i-- {
if b[i] != o[i] {
return
}
}
r = true
}
return
}

78. func (b Buffer) Eq(o Buffer) (r bool) {
if len(b) == len(o) {
for i := len(b) - 1; i > 0; i-- {
if b[i] != o[i] {
return
}
}
r = true
}
return
}

79. func (b Buffer) Eq(o Buffer) (r bool) {
if len(b) == len(o) {
for i := len(b) - 1; i > 0; i-- {
if b[i] != o[i] {
return
}
}
r = true
}
return
}

80. func (b Buffer) Eq(o Buffer) (r bool) {
if len(b) == len(o) {
for i := len(b) - 1; i > 0; i-- {
if b[i] != o[i] {
return
}
}
r = true
}
return
}

81. func (b Buffer) Eq(o Buffer) (r bool) {
if len(b) == len(o) {
for i := len(b) - 1; i > 0; i-- {
if b[i] != o[i] {
return
}
}
r = true
}
return
}

82. func (b Buffer) Eq(o Buffer) (r bool) {
if len(b) == len(o) {
for i := len(b) - 1; i > 0; i-- {
if b[i] != o[i] {
return
}
}
r = true
}
return
}

83. package Vector
import "testing"
func TestVectorSwap(t *testing.T) {
i := Vector{Buffer{0, 1, 2, 3, 4, 5}}
v := i.Clone()
v.Swap(1, 2)
r := Vector{Buffer{0, 2, 1, 3, 4, 5}}
switch {
case !v.Eq(r.Buffer): fallthrough
case !v.Buffer.Eq(r.Buffer): t.Fatalf("b[0:5] = %v", v)
}
}

84. package Vector
import "testing"
func TestVectorSwap(t *testing.T) {
i := Vector{Buffer{0, 1, 2, 3, 4, 5}}
v := i.Clone()
v.Swap(1, 2)
r := Vector{Buffer{0, 2, 1, 3, 4, 5}}
switch {
case !v.Eq(r.Buffer): fallthrough
case !v.Buffer.Eq(r.Buffer): t.Fatalf("b[0:5] = %v", v)
}
}

85. package Vector
import "testing"
func TestVectorSwap(t *testing.T) {
i := Vector{Buffer{0, 1, 2, 3, 4, 5}}
v := i.Clone()
v.Swap(1, 2)
r := Vector{Buffer{0, 2, 1, 3, 4, 5}}
switch {
case !v.Eq(r.Buffer): fallthrough
case !v.Buffer.Eq(r.Buffer): t.Fatalf("b[0:5] = %v", v)
}
}

86. package Vector
import "testing"
func TestVectorSwap(t *testing.T) {
i := Vector{Buffer{0, 1, 2, 3, 4, 5}}
v := i.Clone()
v.Swap(1, 2)
r := Vector{Buffer{0, 2, 1, 3, 4, 5}}
switch {
case !v.Eq(r.Buffer): fallthrough
case !v.Buffer.Eq(r.Buffer): t.Fatalf("b[0:5] = %v", v)
}
}

87. package Vector
import "testing"
func TestVectorSwap(t *testing.T) {
i := Vector{Buffer{0, 1, 2, 3, 4, 5}}
v := i.Clone()
v.Swap(1, 2)
r := Vector{Buffer{0, 2, 1, 3, 4, 5}}
switch {
case !v.Eq(r.Buffer): fallthrough
case !v.Buffer.Eq(r.Buffer): t.Fatalf("b[0:5] = %v", v)
}
}

88. package Vector
import "testing"
func TestVectorSwap(t *testing.T) {
i := Vector{Buffer{0, 1, 2, 3, 4, 5}}
v := i.Clone()
v.Swap(1, 2)
r := Vector{Buffer{0, 2, 1, 3, 4, 5}}
switch {
case !v.Eq(r.Buffer): fallthrough
case !v.Buffer.Eq(r.Buffer): t.Fatalf("b[0:5] = %v", v)
}
}

89. package Vector
import "testing"
func TestVectorSwap(t *testing.T) {
i := Vector{Buffer{0, 1, 2, 3, 4, 5}}
v := i.Clone()
v.Swap(1, 2)
r := Vector{Buffer{0, 2, 1, 3, 4, 5}}
switch {
case !v.Eq(r.Buffer): fallthrough
case !v.Buffer.Eq(r.Buffer): t.Fatalf("b[0:5] = %v", v)
}
}

90. package Vector
import "testing"
func TestVectorSwap(t *testing.T) {
i := Vector{Buffer{0, 1, 2, 3, 4, 5}}
v := i.Clone()
v.Swap(1, 2)
r := Vector{Buffer{0, 2, 1, 3, 4, 5}}
switch {
case !v.Eq(r.Buffer): fallthrough
case !v.Buffer.Eq(r.Buffer): t.Fatalf("b[0:5] = %v", v)
}
}

91. include $(GOROOT)/src/Make.inc
TARG=integer
GOFILES=
integer.go
vector.go
include $(GOROOT)/src/Make.pkg

92. package Vector
import "testing"
import "vector"
func BenchmarkVectorClone6(b *testing.B) {
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
for i := 0; i < b.N; i++ {
_ = v.Clone()
}
}
func BenchmarkVectorSwap(b *testing.B) {
b.StopTimer()
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
b.StartTimer()
for i := 0; i < b.N; i++ {
v.Swap(1, 2)
}
}

93. package Vector
import "testing"
import "vector"
func BenchmarkVectorClone6(b *testing.B) {
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
for i := 0; i < b.N; i++ {
_ = v.Clone()
}
}
func BenchmarkVectorSwap(b *testing.B) {
b.StopTimer()
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
b.StartTimer()
for i := 0; i < b.N; i++ {
v.Swap(1, 2)
}
}

94. package Vector
import "testing"
import "vector"
func BenchmarkVectorClone6(b *testing.B) {
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
for i := 0; i < b.N; i++ {
_ = v.Clone()
}
}
func BenchmarkVectorSwap(b *testing.B) {
b.StopTimer()
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
b.StartTimer()
for i := 0; i < b.N; i++ {
v.Swap(1, 2)
}
}

95. package Vector
import "testing"
import "vector"
func BenchmarkVectorClone6(b *testing.B) {
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
for i := 0; i < b.N; i++ {
_ = v.Clone()
}
}
func BenchmarkVectorSwap(b *testing.B) {
b.StopTimer()
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
b.StartTimer()
for i := 0; i < b.N; i++ {
v.Swap(1, 2)
}
}

96. package Vector
import "testing"
import "vector"
func BenchmarkVectorClone6(b *testing.B) {
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
for i := 0; i < b.N; i++ {
_ = v.Clone()
}
}
func BenchmarkVectorSwap(b *testing.B) {
b.StopTimer()
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
b.StartTimer()
for i := 0; i < b.N; i++ {
v.Swap(1, 2)
}
}

97. package Vector
import "testing"
import "vector"
func BenchmarkVectorClone6(b *testing.B) {
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
for i := 0; i < b.N; i++ {
_ = v.Clone()
}
}
func BenchmarkVectorSwap(b *testing.B) {
b.StopTimer()
v := Vector{Buffer{0, 1, 2, 3, 4, 5}}
b.StartTimer()
for i := 0; i < b.N; i++ {
v.Swap(1, 2)
}
}

98. $ gotest -bench="Benchmark"
rm -f _test/scripts.a
6g -o _gotest_.6 integer.go vector.go nominal_typing_test.go
embedded_typing_benchmark_test.go embedded_typing_test.go
rm -f _test/scripts.a
gopack grc _test/scripts.a _gotest_.6
PASS
integer.BenchmarkVectorSwap 200000000 8 ns/op
integer.BenchmarkVectorClone6 10000000 300 ns/op

99. $ gotest -bench="Benchmark"
rm -f _test/scripts.a
6g -o _gotest_.6 integer.go vector.go nominal_typing_test.go
embedded_typing_benchmark_test.go embedded_typing_test.go
rm -f _test/scripts.a
gopack grc _test/scripts.a _gotest_.6
PASS
integer.BenchmarkVectorSwap 200000000 8 ns/op
integer.BenchmarkVectorClone6 10000000 300 ns/op

100. $ gotest -bench="Benchmark"
rm -f _test/scripts.a
6g -o _gotest_.6 integer.go vector.go nominal_typing_test.go
embedded_typing_benchmark_test.go embedded_typing_test.go
rm -f _test/scripts.a
gopack grc _test/scripts.a _gotest_.6
PASS
integer.BenchmarkVectorSwap 200000000 8 ns/op
integer.BenchmarkVectorClone6 10000000 300 ns/op

101. $ gotest -bench="Benchmark"
rm -f _test/scripts.a
6g -o _gotest_.6 integer.go vector.go nominal_typing_test.go
embedded_typing_benchmark_test.go embedded_typing_test.go
rm -f _test/scripts.a
gopack grc _test/scripts.a _gotest_.6
PASS
integer.BenchmarkVectorSwap 200000000 8 ns/op
integer.BenchmarkVectorClone6 10000000 300 ns/op

102. $ gotest -bench="Benchmark"
rm -f _test/scripts.a
6g -o _gotest_.6 integer.go vector.go nominal_typing_test.go
embedded_typing_benchmark_test.go embedded_typing_test.go
rm -f _test/scripts.a
gopack grc _test/scripts.a _gotest_.6
PASS
integer.BenchmarkVectorSwap 200000000 8 ns/op
integer.BenchmarkVectorClone6 10000000 300 ns/op

103. Go is reflected

104. package generalise
import "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := reflect.ValueOf(i); v.Kind() {
case reflect.Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = reflect.MakeSlice(v.Type(), l, l).Interface()
case reflect.Map: n = reflect.MakeMap(v.Type()).Interface()
}
return
}

105. package generalise
import "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := reflect.ValueOf(i); v.Kind() {
case reflect.Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = reflect.MakeSlice(v.Type(), l, l).Interface()
case reflect.Map: n = reflect.MakeMap(v.Type()).Interface()
}
return
}

106. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

107. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

108. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

109. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

110. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

111. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

112. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

113. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

114. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

115. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

116. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

117. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

118. package generalise
import . "reflect"
func Allocate(i interface{}, limit... int) (n interface{}) {
switch v := ValueOf(i); v.Kind() {
case Slice: l := v.Cap()
if len(limit) > 0 {
l = limit[0]
}
n = MakeSlice(v.Type(), l, l).Interface()
case Map: n = MakeMap(v.Type()).Interface()
}
return
}

119. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

120. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

121. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

122. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

123. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

124. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

125. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

126. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

127. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

128. func throwsPanic(f func()) (b bool) {
defer func() {
if x := recover(); x != nil {
b = true
}
}()
f()
return
}

129. func TestAllocate(t *testing.T) {
var s2 []int
s1 := []int{0, 1, 2}
m := map[int] int{1: 1, 2: 2, 3: 3}
switch {
case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }):
t.Fatal("Unable to allocate new slice")
case len(s2) != 1 || cap(s2) != 1:
t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2)
case throwsPanic(func() { Allocate(m) }):
t.Fatal("Unable to allocate new map")
}
}

130. func TestAllocate(t *testing.T) {
var s2 []int
s1 := []int{0, 1, 2}
m := map[int] int{1: 1, 2: 2, 3: 3}
switch {
case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }):
t.Fatal("Unable to allocate new slice")
case len(s2) != 1 || cap(s2) != 1:
t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2)
case throwsPanic(func() { Allocate(m) }):
t.Fatal("Unable to allocate new map")
}
}

131. func TestAllocate(t *testing.T) {
var s2 []int
s1 := []int{0, 1, 2}
m := map[int] int{1: 1, 2: 2, 3: 3}
switch {
case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }):
t.Fatal("Unable to allocate new slice")
case len(s2) != 1 || cap(s2) != 1:
t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2)
case throwsPanic(func() { Allocate(m) }):
t.Fatal("Unable to allocate new map")
}
}

132. func TestAllocate(t *testing.T) {
var s2 []int
s1 := []int{0, 1, 2}
m := map[int] int{1: 1, 2: 2, 3: 3}
switch {
case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }):
t.Fatal("Unable to allocate new slice")
case len(s2) != 1 || cap(s2) != 1:
t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2)
case throwsPanic(func() { Allocate(m) }):
t.Fatal("Unable to allocate new map")
}
}

133. func TestAllocate(t *testing.T) {
var s2 []int
s1 := []int{0, 1, 2}
m := map[int] int{1: 1, 2: 2, 3: 3}
switch {
case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }):
t.Fatal("Unable to allocate new slice")
case len(s2) != 1 || cap(s2) != 1:
t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2)
case throwsPanic(func() { Allocate(m) }):
t.Fatal("Unable to allocate new map")
}
}

134. func TestAllocate(t *testing.T) {
var s2 []int
s1 := []int{0, 1, 2}
m := map[int] int{1: 1, 2: 2, 3: 3}
switch {
case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }):
t.Fatal("Unable to allocate new slice")
case len(s2) != 1 || cap(s2) != 1:
t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2)
case throwsPanic(func() { Allocate(m) }):
t.Fatal("Unable to allocate new map")
}
}

135. func TestAllocate(t *testing.T) {
var s2 []int
s1 := []int{0, 1, 2}
m := map[int] int{1: 1, 2: 2, 3: 3}
switch {
case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }):
t.Fatal("Unable to allocate new slice")
case len(s2) != 1 || cap(s2) != 1:
t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2)
case throwsPanic(func() { Allocate(m) }):
t.Fatal("Unable to allocate new map")
}
}

136. func TestAllocate(t *testing.T) {
var s2 []int
s1 := []int{0, 1, 2}
m := map[int] int{1: 1, 2: 2, 3: 3}
switch {
case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }):
t.Fatal("Unable to allocate new slice")
case len(s2) != 1 || cap(s2) != 1:
t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2)
case throwsPanic(func() { Allocate(m) }):
t.Fatal("Unable to allocate new map")
}
}

137. func TestAllocate(t *testing.T) {
var s2 []int
s1 := []int{0, 1, 2}
m := map[int] int{1: 1, 2: 2, 3: 3}
switch {
case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }):
t.Fatal("Unable to allocate new slice")
case len(s2) != 1 || cap(s2) != 1:
t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2)
case throwsPanic(func() { Allocate(m) }):
t.Fatal("Unable to allocate new map")
}
}

138. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

139. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

140. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

141. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

142. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

143. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

144. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

145. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

146. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

147. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

148. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

149. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

150. func Duplicate(i interface{}) (clone interface{}) {
if clone = Allocate(i); clone != nil {
switch clone := ValueOf(clone); clone.Kind() {
case Slice: Copy(clone, ValueOf(i))
case Map: m := ValueOf(i)
for _, k := range m.Keys() {
clone.SetMapIndex(k, m.MapIndex(k))
}
}
}
return
}

151. a systems language

152. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

153. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

154. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

155. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

156. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

157. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

158. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

159. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

160. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

161. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

162. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

163. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

164. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

165. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

166. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

167. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

168. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

169. package raw
import . "reflect"
import "unsafe"
var _BYTE_SLICE Type = Typeof([]byte(nil))
type MemoryBlock interface {
ByteSlice() []byte
}
func valueHeader(v Value) (header *SliceHeader) {
if v.IsValid() {
s := int(v.Type().Size())
header = &SliceHeader{ v.UnsafeAddr(), s, s }
}
return
}

170. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

171. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

172. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

173. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

174. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

175. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

176. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

177. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

178. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

179. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

180. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

181. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

182. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

183. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

184. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

185. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

186. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

187. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

188. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

189. func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) {
switch value := Indirect(ValueOf(i)); value.Kind() {
case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr()))
t := value.Type().Elem()
Size = int(t.Size())
Align = t.Align()
case Interface: Header, Size, Align = SliceHeader(value.Elem())
}
return
}
func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) {
if oldHeader != nil {
s := float64(oldESize) / float64(newESize)
h = &SliceHeader{ Data: oldHeader.Data }
h.Len = int(float64(oldHeader.Len) * s)
h.Cap = int(float64(oldHeader.Cap) * s)
}
return
}

190. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

191. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

192. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

193. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

194. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

195. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

196. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

197. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

198. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

199. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

200. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

201. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

202. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

203. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

204. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

205. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

206. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

207. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

208. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

209. func ByteSlice(i interface{}) []byte {
switch i := i.(type) {
case []byte: return i
case MemoryBlock: return i.ByteSlice()
}
var header *SliceHeader
switch v := ValueOf(i); value.Kind() {
case Interface, Ptr: header = valueHeader(v.Elem())
case Slice: h, s, _ := SliceHeader(i)
header = Scale(h, s, 1)
case String: s := v.Get()
h := *(*StringHeader)(unsafe.Pointer(&s))
header = &SliceHeader{ h.Data, h.Len, h.Len }
default: header = valueHeader(v)
}
return unsafe.Unreflect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)
}

210. concurrent

211. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func() {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-c) 0110011101011010
}
}()
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

212. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func() {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-c) 0110011101011010
}
}()
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

213. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func() {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-c) 0110011101011010
}
}()
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

214. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func() {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-c) 0110011101011010
}
}()
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

215. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func() {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-c) 0110011101011010
}
}()
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

216. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func() {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-c) 0110011101011010
}
}()
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

217. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func() {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-c) 0110011101011010
}
}()
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

218. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func(in chan int) {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-in) 0110011101011010
}
}(c)
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

219. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func(in chan int) {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-in) 0110011101011010
}
}(c)
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

220. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func(in chan int) {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-in) 0110011101011010
}
}(c)
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

221. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func(in chan int) {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-in) 0110011101011010
}
}(c)
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

222. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func(in chan int) {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-in) 0110011101011010
}
}(c)
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

223. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func(in chan int) {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-in) 0110011101011010
}
}(c)
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

224. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func(in chan int) {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-in) 0110011101011010
}
}(c)
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

225. package main
import "fmt"
func main() {
var c chan int
c = make(chan int)
limit := 16
go func(in chan int) {
for i := limit; i > 0; i-- { produces:
fmt.Print(<-in) 0110011101011010
}
}(c)
for i := limit; i > 0; i-- {
select {
case c <- 0:
case c <- 1:
}
}
}

226. func main() {
var c chan int
c = make(chan int, 16)
go func() {
for i := 16; i > 0; i-- {
fmt.Print(<-c)
} produces:
}()
0110011101011010
go func() {
select {
case c <- 0:
case c <- 1:
}
}()
for {}
}

227. func main() {
var c chan int
c = make(chan int, 16)
go func() {
for i := 16; i > 0; i-- {
fmt.Print(<-c)
} produces:
}()
0110011101011010
go func() {
select {
case c <- 0:
case c <- 1:
}
}()
for {}
}

228. func main() {
var c chan int
c = make(chan int, 16)
go func() {
for i := 16; i > 0; i-- {
fmt.Print(<-c)
} produces:
}()
0110011101011010
go func() {
select {
case c <- 0:
case c <- 1:
}
}()
for {}
}

229. func main() {
var c chan int
c = make(chan int, 16)
go func() {
for i := 16; i > 0; i-- {
fmt.Print(<-c)
} produces:
}()
0110011101011010
go func() {
select {
case c <- 0:
case c <- 1:
}
}()
for {}
}

230. package generalise
type SignalSource func(status chan bool)
func Wait(s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
<-done
}
func WaitAll(count int, s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
for i := 0; i < count; i++ {
<- done
}
}

231. package generalise
type SignalSource func(status chan bool)
func Wait(s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
<-done
}
func WaitAll(count int, s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
for i := 0; i < count; i++ {
<- done
}
}

232. package generalise
type SignalSource func(status chan bool)
func Wait(s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
<-done
}
func WaitAll(count int, s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
for i := 0; i < count; i++ {
<- done
}
}

233. package generalise
type SignalSource func(status chan bool)
func Wait(s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
<-done
}
func WaitAll(count int, s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
for i := 0; i < count; i++ {
<- done
}
}

234. package generalise
type SignalSource func(status chan bool)
func Wait(s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
<-done
}
func WaitAll(count int, s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
for i := 0; i < count; i++ {
<- done
}
}

235. package generalise
type SignalSource func(status chan bool)
func Wait(s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
<-done
}
func WaitAll(count int, s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
for i := 0; i < count; i++ {
<- done
}
}

236. package generalise
type SignalSource func(status chan bool)
func Wait(s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
<-done
}
func WaitAll(count int, s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
for i := 0; i < count; i++ {
<- done
}
}

237. package generalise
type SignalSource func(status chan bool)
func Wait(s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
<-done
}
func WaitAll(count int, s SignalSource) {
done := make(chan bool)
defer close(done)
go s(done)
for i := 0; i < count; i++ {
<- done
}
}

238. type Iteration func(k, x interface{}) bool
func (i Iteration) apply(k, v interface{}, c chan bool) {
go func() {
c <-i(k, v)
}()
}
func (f Iteration) Each(c interface{}) {
switch c := ValueOf(c); c.Kind() {
case Slice: WaitAll(c.Len(), SignalSource(func(done chan bool) {
for i := 0; i < c.Len(); i++ {
f.apply(i, c.Elem(i).Interface(), done) }}))
case Map: WaitAll(c.Len(), SignalSource(func(done chan bool) {
for _, k := range c.Keys() {
f.apply(k, c.Elem(k).Interface(), done) }}))
}
}

239. type Iteration func(k, x interface{}) bool
func (i Iteration) apply(k, v interface{}, c chan bool) {
go func() {
c <-i(k, v)
}()
}
func (f Iteration) Each(c interface{}) {
switch c := ValueOf(c); c.Kind() {
case Slice: WaitAll(c.Len(), SignalSource(func(done chan bool) {
for i := 0; i < c.Len(); i++ {
f.apply(i, c.Elem(i).Interface(), done) }}))
case Map: WaitAll(c.Len(), SignalSource(func(done chan bool) {
for _, k := range c.Keys() {
f.apply(k, c.Elem(k).Interface(), done) }}))
}
}