remove “And” from geometry Add/Subtract helper names

Author: toaster

geometry.go

@@ -49,8 +49,8 @@ func (p Position) Add(v Vector2) Position {
 	return Position{p.X + x, p.Y + y}
 }
 
-// AddXAndY returns a new Position by adding x and y to the current one.
-func (p Position) AddXAndY(x, y float32) Position {
+// AddXY returns a new Position by adding x and y to the current one.
+func (p Position) AddXY(x, y float32) Position {
 	return Position{p.X + x, p.Y + y}
 }
 
@@ -71,8 +71,8 @@ func (p Position) Subtract(v Vector2) Position {
 	return Position{p.X - x, p.Y - y}
 }
 
-// SubtractXAndY returns a new Position by subtracting x and y from the current one.
-func (p Position) SubtractXAndY(x, y float32) Position {
+// SubtractXY returns a new Position by subtracting x and y from the current one.
+func (p Position) SubtractXY(x, y float32) Position {
 	return Position{p.X - x, p.Y - y}
 }
 
@@ -94,8 +94,8 @@ func (s Size) Add(v Vector2) Size {
 	return Size{s.Width + w, s.Height + h}
 }
 
-// AddWidthAndHeight returns a new Size by adding width and height to the current one.
-func (s Size) AddWidthAndHeight(width, height float32) Size {
+// AddWidthHeight returns a new Size by adding width and height to the current one.
+func (s Size) AddWidthHeight(width, height float32) Size {
 	return Size{s.Width + width, s.Height + height}
 }
 
@@ -136,7 +136,7 @@ func (s Size) Subtract(v Vector2) Size {
 	return Size{s.Width - w, s.Height - h}
 }
 
-// SubtractWidthAndHeight returns a new Size by subtracting width and height from the current one.
-func (s Size) SubtractWidthAndHeight(width, height float32) Size {
+// SubtractWidthHeight returns a new Size by subtracting width and height from the current one.
+func (s Size) SubtractWidthHeight(width, height float32) Size {
 	return Size{s.Width - width, s.Height - height}
 }

geometry_benchmark_test.go

@@ -12,54 +12,54 @@ import (
 
 func BenchmarkPosition_Add(b *testing.B) {
 	b.Run("Add()", benchmarkPositionAdd)
-	b.Run("AddXAndY()", benchmarkPositionAddXAndY)
+	b.Run("AddXY()", benchmarkPositionAddXY)
 }
 
 func BenchmarkPosition_Subtract(b *testing.B) {
 	b.Run("Subtract()", benchmarkPositionSubtract)
-	b.Run("SubtractXAndY()", benchmarkPositionSubtractXAndY)
+	b.Run("SubtractXY()", benchmarkPositionSubtractXY)
 }
 
 func BenchmarkSize_Add(b *testing.B) {
 	b.Run("Add()", benchmarkSizeAdd)
-	b.Run("AddWidthAndHeight()", benchmarkSizeAddWidthAndHeight)
+	b.Run("AddWidthHeight()", benchmarkSizeAddWidthHeight)
 }
 
 func BenchmarkSize_Subtract(b *testing.B) {
 	b.Run("Subtract()", benchmarkSizeSubtract)
-	b.Run("SubtractWidthAndHeight()", benchmarkSizeSubtractWidthAndHeight)
+	b.Run("SubtractWidthHeight()", benchmarkSizeSubtractWidthHeight)
 }
 
-// This test prevents Position.Add to be simplified to `return p.AddXAndY(v.Components())`
+// This test prevents Position.Add to be simplified to `return p.AddXY(v.Components())`
 // because this slows down the speed by factor 10.
 func TestPosition_Add_Speed(t *testing.T) {
 	add := testing.Benchmark(benchmarkPositionAdd)
-	addXAndY := testing.Benchmark(benchmarkPositionAddXAndY)
-	assert.Less(t, add.NsPerOp()/addXAndY.NsPerOp(), int64(5))
+	addXY := testing.Benchmark(benchmarkPositionAddXY)
+	assert.Less(t, add.NsPerOp()/addXY.NsPerOp(), int64(5))
 }
 
-// This test prevents Position.Subtract to be simplified to `return p.SubtractXAndY(v.Components())`
+// This test prevents Position.Subtract to be simplified to `return p.SubtractXY(v.Components())`
 // because this slows down the speed by factor 10.
 func TestPosition_Subtract_Speed(t *testing.T) {
 	subtract := testing.Benchmark(benchmarkPositionSubtract)
-	subtractXAndY := testing.Benchmark(benchmarkPositionSubtractXAndY)
-	assert.Less(t, subtract.NsPerOp()/subtractXAndY.NsPerOp(), int64(5))
+	subtractXY := testing.Benchmark(benchmarkPositionSubtractXY)
+	assert.Less(t, subtract.NsPerOp()/subtractXY.NsPerOp(), int64(5))
 }
 
-// This test prevents Size.Add to be simplified to `return s.AddWidthAndHeight(v.Components())`
+// This test prevents Size.Add to be simplified to `return s.AddWidthHeight(v.Components())`
 // because this slows down the speed by factor 10.
 func TestSize_Add_Speed(t *testing.T) {
 	add := testing.Benchmark(benchmarkSizeAdd)
-	addWidthAndHeight := testing.Benchmark(benchmarkSizeAddWidthAndHeight)
-	assert.Less(t, add.NsPerOp()/addWidthAndHeight.NsPerOp(), int64(5))
+	addWidthHeight := testing.Benchmark(benchmarkSizeAddWidthHeight)
+	assert.Less(t, add.NsPerOp()/addWidthHeight.NsPerOp(), int64(5))
 }
 
-// This test prevents Size.Subtract to be simplified to `return s.SubtractWidthAndHeight(v.Components())`
+// This test prevents Size.Subtract to be simplified to `return s.SubtractWidthHeight(v.Components())`
 // because this slows down the speed by factor 10.
 func TestSize_Subtract_Speed(t *testing.T) {
 	subtract := testing.Benchmark(benchmarkSizeSubtract)
-	subtractWidthAndHeight := testing.Benchmark(benchmarkSizeSubtractWidthAndHeight)
-	assert.Less(t, subtract.NsPerOp()/subtractWidthAndHeight.NsPerOp(), int64(5))
+	subtractWidthHeight := testing.Benchmark(benchmarkSizeSubtractWidthHeight)
+	assert.Less(t, subtract.NsPerOp()/subtractWidthHeight.NsPerOp(), int64(5))
 }
 
 var benchmarkResult interface{}
@@ -72,10 +72,10 @@ func benchmarkPositionAdd(b *testing.B) {
 	benchmarkResult = pos
 }
 
-func benchmarkPositionAddXAndY(b *testing.B) {
+func benchmarkPositionAddXY(b *testing.B) {
 	pos := fyne.NewPos(10, 10)
 	for n := 0; n < b.N; n++ {
-		pos = pos.AddXAndY(float32(n), float32(n))
+		pos = pos.AddXY(float32(n), float32(n))
 	}
 	benchmarkResult = pos
 }
@@ -88,10 +88,10 @@ func benchmarkPositionSubtract(b *testing.B) {
 	benchmarkResult = pos
 }
 
-func benchmarkPositionSubtractXAndY(b *testing.B) {
+func benchmarkPositionSubtractXY(b *testing.B) {
 	pos := fyne.NewPos(10, 10)
 	for n := 0; n < b.N; n++ {
-		pos = pos.SubtractXAndY(float32(n), float32(n))
+		pos = pos.SubtractXY(float32(n), float32(n))
 	}
 	benchmarkResult = pos
 }
@@ -104,10 +104,10 @@ func benchmarkSizeAdd(b *testing.B) {
 	benchmarkResult = size
 }
 
-func benchmarkSizeAddWidthAndHeight(b *testing.B) {
+func benchmarkSizeAddWidthHeight(b *testing.B) {
 	size := fyne.NewSize(10, 10)
 	for n := 0; n < b.N; n++ {
-		size = size.AddWidthAndHeight(float32(n), float32(n))
+		size = size.AddWidthHeight(float32(n), float32(n))
 	}
 	benchmarkResult = size
 }
@@ -120,10 +120,10 @@ func benchmarkSizeSubtract(b *testing.B) {
 	benchmarkResult = size
 }
 
-func benchmarkSizeSubtractWidthAndHeight(b *testing.B) {
+func benchmarkSizeSubtractWidthHeight(b *testing.B) {
 	size := fyne.NewSize(10, 10)
 	for n := 0; n < b.N; n++ {
-		size = size.SubtractWidthAndHeight(float32(n), float32(n))
+		size = size.SubtractWidthHeight(float32(n), float32(n))
 	}
 	benchmarkResult = size
 }

geometry_test.go

@@ -37,10 +37,10 @@ func TestPosition_Add_Vector(t *testing.T) {
 	assert.Equal(t, float32(35), pos2.Y)
 }
 
-func TestPosition_AddXAndY(t *testing.T) {
+func TestPosition_AddXY(t *testing.T) {
 	pos1 := fyne.NewPos(10, 10)
 
-	pos2 := pos1.AddXAndY(25, 25)
+	pos2 := pos1.AddXY(25, 25)
 
 	assert.Equal(t, float32(35), pos2.X)
 	assert.Equal(t, float32(35), pos2.Y)
@@ -73,10 +73,10 @@ func TestPosition_Subtract(t *testing.T) {
 	assert.Equal(t, float32(15), pos3.Y)
 }
 
-func TestPosition_SubtractXAndY(t *testing.T) {
+func TestPosition_SubtractXY(t *testing.T) {
 	pos1 := fyne.NewPos(25, 25)
 
-	pos2 := pos1.SubtractXAndY(10, 10)
+	pos2 := pos1.SubtractXY(10, 10)
 
 	assert.Equal(t, float32(15), pos2.X)
 	assert.Equal(t, float32(15), pos2.Y)
@@ -112,10 +112,10 @@ func TestSize_Add_Vector(t *testing.T) {
 	assert.Equal(t, float32(35), size2.Height)
 }
 
-func TestSize_AddWidthAndHeight(t *testing.T) {
+func TestSize_AddWidthHeight(t *testing.T) {
 	size1 := fyne.NewSize(10, 10)
 
-	size2 := size1.AddWidthAndHeight(25, 25)
+	size2 := size1.AddWidthHeight(25, 25)
 
 	assert.Equal(t, float32(35), size2.Width)
 	assert.Equal(t, float32(35), size2.Height)
@@ -168,10 +168,10 @@ func TestSize_Subtract(t *testing.T) {
 	assert.Equal(t, float32(15), size3.Height)
 }
 
-func TestSize_SubtractWidthAndHeight(t *testing.T) {
+func TestSize_SubtractWidthHeight(t *testing.T) {
 	size1 := fyne.NewSize(25, 25)
 
-	size2 := size1.SubtractWidthAndHeight(10, 10)
+	size2 := size1.SubtractWidthHeight(10, 10)
 
 	assert.Equal(t, float32(15), size2.Width)
 	assert.Equal(t, float32(15), size2.Height)