diff --git a/complex128.go b/complex128.go
index ff148a9..18128ae 100644
--- a/complex128.go
+++ b/complex128.go
@@ -139,7 +139,7 @@ func (s *C128Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -152,6 +152,7 @@ func (s C128Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -187,6 +188,7 @@ func (s C128Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -223,6 +225,7 @@ func (s C128Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -255,6 +258,7 @@ func (s C128Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case C128Slice:				copy(s[offset:], container)
 	case []complex128:			copy(s[offset:], container)
+	default:					panic(container)
 	}
 }
 
@@ -525,7 +529,7 @@ func (s *C128Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -538,6 +542,7 @@ func (s C128Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -561,6 +566,8 @@ func (s C128Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -593,6 +600,8 @@ func (s C128Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/complex64.go b/complex64.go
index a2f6ed5..a50e406 100644
--- a/complex64.go
+++ b/complex64.go
@@ -139,7 +139,7 @@ func (s *C64Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -152,6 +152,7 @@ func (s C64Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -187,6 +188,7 @@ func (s C64Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -223,6 +225,7 @@ func (s C64Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -254,7 +257,8 @@ func (s C64Slice) BlockClear(start, count int) {
 func (s C64Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case C64Slice:			copy(s[offset:], container)
-	case []complex64:			copy(s[offset:], container)
+	case []complex64:		copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -553,7 +557,7 @@ func (s *C64Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -566,6 +570,7 @@ func (s C64Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -589,6 +594,8 @@ func (s C64Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -621,6 +628,8 @@ func (s C64Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/error.go b/error.go
index 02bbf60..4df4dfe 100644
--- a/error.go
+++ b/error.go
@@ -99,7 +99,7 @@ func (s *ESlice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	s.release_references(p, len(a) - p)
 	*s = a[:p]
@@ -113,6 +113,7 @@ func (s ESlice) Each(f interface{}) {
 	case func(interface{}):						for _, v := range s { f(v) }
 	case func(int, interface{}):				for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):		for i, v := range s { f(i, v) }
+	default:									panic(f)
 	}
 }
 
@@ -148,6 +149,7 @@ func (s ESlice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -184,6 +186,7 @@ func (s ESlice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -216,6 +219,7 @@ func (s ESlice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case ESlice:				copy(s[offset:], container)
 	case []error:				copy(s[offset:], container)
+	default:					panic(container)
 	}
 }
 
@@ -525,7 +529,7 @@ func (s *ESlice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	s.release_references(p, len(a) - p)
 	*s = a[:p]
@@ -539,6 +543,7 @@ func (s ESlice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -562,6 +567,8 @@ func (s ESlice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -594,6 +601,8 @@ func (s ESlice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/float32.go b/float32.go
index fe7d28b..d790c66 100644
--- a/float32.go
+++ b/float32.go
@@ -139,7 +139,7 @@ func (s *F32Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -152,6 +152,7 @@ func (s F32Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -187,6 +188,7 @@ func (s F32Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -223,6 +225,7 @@ func (s F32Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -255,6 +258,7 @@ func (s F32Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case F32Slice:			copy(s[offset:], container)
 	case []float32:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -553,7 +557,7 @@ func (s *F32Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -566,6 +570,7 @@ func (s F32Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -589,6 +594,8 @@ func (s F32Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -621,6 +628,8 @@ func (s F32Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/float64.go b/float64.go
index 1b2015e..15b6005 100644
--- a/float64.go
+++ b/float64.go
@@ -139,7 +139,7 @@ func (s *F64Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -152,6 +152,7 @@ func (s F64Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -187,6 +188,7 @@ func (s F64Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -223,6 +225,7 @@ func (s F64Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -255,6 +258,7 @@ func (s F64Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case F64Slice:			copy(s[offset:], container)
 	case []float64:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -553,7 +557,7 @@ func (s *F64Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -566,6 +570,7 @@ func (s F64Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -589,6 +594,8 @@ func (s F64Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -621,6 +628,8 @@ func (s F64Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/int.go b/int.go
index e2fe2cf..e7a004b 100644
--- a/int.go
+++ b/int.go
@@ -146,7 +146,7 @@ func (s *ISlice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -159,6 +159,7 @@ func (s ISlice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -194,6 +195,7 @@ func (s ISlice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -230,6 +232,7 @@ func (s ISlice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -262,6 +265,7 @@ func (s ISlice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case ISlice:			copy(s[offset:], container)
 	case []int:				copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -560,7 +564,7 @@ func (s *ISlice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -573,6 +577,7 @@ func (s ISlice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -596,6 +601,8 @@ func (s ISlice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -627,6 +634,8 @@ func (s ISlice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/int16.go b/int16.go
index 8f692e6..e2bd3cc 100644
--- a/int16.go
+++ b/int16.go
@@ -146,7 +146,7 @@ func (s *I16Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -159,6 +159,7 @@ func (s I16Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -194,6 +195,7 @@ func (s I16Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -230,6 +232,7 @@ func (s I16Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -262,6 +265,7 @@ func (s I16Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case I16Slice:			copy(s[offset:], container)
 	case []int16:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -560,7 +564,7 @@ func (s *I16Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -573,6 +577,7 @@ func (s I16Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -596,6 +601,8 @@ func (s I16Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -627,6 +634,8 @@ func (s I16Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/int16_test.go b/int16_test.go
index 58afab8..7dc5c85 100644
--- a/int16_test.go
+++ b/int16_test.go
@@ -606,15 +606,15 @@ func TestI16SliceReverseEach(t *testing.T) {
 	})
 
 	count = 9
-	I16Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(i int) {
-		if i != int(count) {
+	I16Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(i int16) {
+		if i != count {
 			t.Fatalf("3: element %v erroneously reported as %v", count, i)
 		}
 		count--
 	})
 
-	I16Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(index int, i int) {
-		if i != index {
+	I16Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(index int, i int16) {
+		if int(i) != index {
 			t.Fatalf("4: element %v erroneously reported as %v", index, i)
 		}
 	})
diff --git a/int32.go b/int32.go
index e60f842..c2c398b 100644
--- a/int32.go
+++ b/int32.go
@@ -146,7 +146,7 @@ func (s *I32Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -159,6 +159,7 @@ func (s I32Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -194,6 +195,7 @@ func (s I32Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -230,6 +232,7 @@ func (s I32Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -262,6 +265,7 @@ func (s I32Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case I32Slice:			copy(s[offset:], container)
 	case []int32:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -560,7 +564,7 @@ func (s *I32Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -573,6 +577,7 @@ func (s I32Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -596,6 +601,8 @@ func (s I32Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -628,6 +635,8 @@ func (s I32Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/int32_test.go b/int32_test.go
index c0e720d..006cdab 100644
--- a/int32_test.go
+++ b/int32_test.go
@@ -606,15 +606,15 @@ func TestI32SliceReverseEach(t *testing.T) {
 	})
 
 	count = 9
-	I32Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(i int) {
-		if i != int(count) {
+	I32Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(i int32) {
+		if i != count {
 			t.Fatalf("3: element %v erroneously reported as %v", count, i)
 		}
 		count--
 	})
 
-	I32Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(index int, i int) {
-		if i != index {
+	I32Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(index int, i int32) {
+		if int(i) != index {
 			t.Fatalf("4: element %v erroneously reported as %v", index, i)
 		}
 	})
diff --git a/int64.go b/int64.go
index 16cba2e..b9415dd 100644
--- a/int64.go
+++ b/int64.go
@@ -146,7 +146,7 @@ func (s *I64Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -159,6 +159,7 @@ func (s I64Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -194,6 +195,7 @@ func (s I64Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -230,6 +232,7 @@ func (s I64Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -262,6 +265,7 @@ func (s I64Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case I64Slice:			copy(s[offset:], container)
 	case []int64:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -561,7 +565,7 @@ func (s *I64Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -574,6 +578,7 @@ func (s I64Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -597,6 +602,8 @@ func (s I64Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -629,6 +636,8 @@ func (s I64Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/int64_test.go b/int64_test.go
index 5547558..518bfad 100644
--- a/int64_test.go
+++ b/int64_test.go
@@ -606,15 +606,15 @@ func TestI64SliceReverseEach(t *testing.T) {
 	})
 
 	count = 9
-	I64Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(i int) {
-		if i != int(count) {
+	I64Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(i int64) {
+		if i != count {
 			t.Fatalf("3: element %v erroneously reported as %v", count, i)
 		}
 		count--
 	})
 
-	I64Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(index int, i int) {
-		if i != index {
+	I64Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(index int, i int64) {
+		if int(i) != index {
 			t.Fatalf("4: element %v erroneously reported as %v", index, i)
 		}
 	})
diff --git a/int8.go b/int8.go
index 7294b2c..cdfc78d 100644
--- a/int8.go
+++ b/int8.go
@@ -146,7 +146,7 @@ func (s *I8Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -159,6 +159,7 @@ func (s I8Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -194,6 +195,7 @@ func (s I8Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -230,6 +232,7 @@ func (s I8Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -262,6 +265,7 @@ func (s I8Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case I8Slice:			copy(s[offset:], container)
 	case []int8:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -561,7 +565,7 @@ func (s *I8Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -574,6 +578,7 @@ func (s I8Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -597,6 +602,8 @@ func (s I8Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -629,6 +636,8 @@ func (s I8Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/int8_test.go b/int8_test.go
index ca58355..8157b00 100644
--- a/int8_test.go
+++ b/int8_test.go
@@ -606,15 +606,15 @@ func TestI8SliceReverseEach(t *testing.T) {
 	})
 
 	count = 9
-	I8Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(i int) {
-		if i != int(count) {
+	I8Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(i int8) {
+		if i != count {
 			t.Fatalf("3: element %v erroneously reported as %v", count, i)
 		}
 		count--
 	})
 
-	I8Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(index int, i int) {
-		if i != index {
+	I8Slice{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.ReverseEach(func(index int, i int8) {
+		if int(i) != index {
 			t.Fatalf("4: element %v erroneously reported as %v", index, i)
 		}
 	})
diff --git a/reflected.go b/reflected.go
index c65eaa0..2d12d15 100644
--- a/reflected.go
+++ b/reflected.go
@@ -187,6 +187,7 @@ func (s RSlice) Each(f interface{}) {
 	case func(interface{}):					for i := 0; i < s.Len(); i++ { f(s.At(i)) }
 	case func(int, interface{}):			for i := 0; i < s.Len(); i++ { f(i, s.At(i)) }
 	case func(interface{}, interface{}):	for i := 0; i < s.Len(); i++ { f(i, s.At(i)) }
+	default:								panic(f)
 	}
 }
 
@@ -222,6 +223,7 @@ func (s RSlice) While(f interface{}) int {
 															return i
 														}
 													}
+	default:										panic(f)
 	}
 	return s.Len()
 }
@@ -258,6 +260,7 @@ func (s RSlice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return s.Len()
 }
@@ -710,6 +713,7 @@ func (s RSlice) ReverseEach(f interface{}) {
 	case func(interface{}):						for i := s.Len() - 1; i > -1; i-- { f(s.At(i)) }
 	case func(int, interface{}):				for i := s.Len() - 1; i > -1; i-- { f(i, s.At(i)) }
 	case func(interface{}, interface{}):		for i := s.Len() - 1; i > -1; i-- { f(i, s.At(i)) }
+	default:									panic(f)
 	}
 }
 
diff --git a/slice.go b/slice.go
index 4bc94f3..f896346 100644
--- a/slice.go
+++ b/slice.go
@@ -100,6 +100,7 @@ func (s Slice) Each(f interface{}) {
 	case func(interface{}):						for _, v := range s { f(v) }
 	case func(int, interface{}):				for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):		for i, v := range s { f(i, v) }
+	default:									panic(f)
 	}
 }
 
@@ -120,6 +121,7 @@ func (s Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -141,6 +143,7 @@ func (s Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -173,6 +176,7 @@ func (s Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case Slice:					copy(s[offset:], container)
 	case []interface{}:			copy(s[offset:], container)
+	default:					panic(container)
 	}
 }
 
@@ -505,6 +509,7 @@ func (s Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
diff --git a/string.go b/string.go
index 86d2d6a..fa60ef9 100644
--- a/string.go
+++ b/string.go
@@ -115,7 +115,7 @@ func (s *SSlice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -128,6 +128,7 @@ func (s SSlice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -163,6 +164,7 @@ func (s SSlice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -199,6 +201,7 @@ func (s SSlice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -227,6 +230,7 @@ func (s SSlice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case SSlice:			copy(s[offset:], container)
 	case []string:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -531,7 +535,7 @@ func (s *SSlice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -544,6 +548,7 @@ func (s SSlice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -567,6 +572,8 @@ func (s SSlice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -599,6 +606,8 @@ func (s SSlice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/string_test.go b/string_test.go
index 1af7bff..b8bdb49 100644
--- a/string_test.go
+++ b/string_test.go
@@ -592,7 +592,7 @@ func TestSSliceKeepIf(t *testing.T) {
 func TestSSliceReverseEach(t *testing.T) {
 	var count	int
 	count = 9
-	Slice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(i interface{}) {
+	SSlice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(i interface{}) {
 		v, _ := strconv.Atoi(i.(string))
 		if v != count {
 			t.Fatalf("0: element %v erroneously reported as %v", count, i)
@@ -600,14 +600,14 @@ func TestSSliceReverseEach(t *testing.T) {
 		count--
 	})
 
-	Slice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(index int, i interface{}) {
+	SSlice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(index int, i interface{}) {
 		v, _ := strconv.Atoi(i.(string))
 		if index != v {
 			t.Fatalf("1: element %v erroneously reported as %v", index, i)
 		}
 	})
 
-	Slice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(key, i interface{}) {
+	SSlice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(key, i interface{}) {
 		v, _ := strconv.Atoi(i.(string))
 		if key.(int) != v {
 			t.Fatalf("2: element %v erroneously reported as %v", key, i)
@@ -615,7 +615,7 @@ func TestSSliceReverseEach(t *testing.T) {
 	})
 
 	count = 9
-	Slice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(i string) {
+	SSlice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(i string) {
 		v, _ := strconv.Atoi(i)
 		if v != count {
 			t.Fatalf("3: element %v erroneously reported as %v", count, i)
@@ -623,14 +623,14 @@ func TestSSliceReverseEach(t *testing.T) {
 		count--
 	})
 
-	Slice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(index int, i string) {
+	SSlice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(index int, i string) {
 		v, _ := strconv.Atoi(i)
 		if v != index {
 			t.Fatalf("4: element %v erroneously reported as %v", index, i)
 		}
 	})
 
-	Slice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(key interface{}, i string) {
+	SSlice{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}.ReverseEach(func(key interface{}, i string) {
 		v, _ := strconv.Atoi(i)
 		if key.(int) != v {
 			t.Fatalf("5: element %v erroneously reported as %v", key, i)
diff --git a/uint.go b/uint.go
index 581c1ee..1e26759 100644
--- a/uint.go
+++ b/uint.go
@@ -145,7 +145,7 @@ func (s *USlice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -158,6 +158,7 @@ func (s USlice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -193,6 +194,7 @@ func (s USlice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -229,6 +231,7 @@ func (s USlice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -261,6 +264,7 @@ func (s USlice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case USlice:			copy(s[offset:], container)
 	case []uint:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -559,7 +563,7 @@ func (s *USlice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -572,6 +576,7 @@ func (s USlice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -595,6 +600,8 @@ func (s USlice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -627,6 +634,8 @@ func (s USlice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/uint16.go b/uint16.go
index a96be18..369a03a 100644
--- a/uint16.go
+++ b/uint16.go
@@ -145,7 +145,7 @@ func (s *U16Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -158,6 +158,7 @@ func (s U16Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -193,6 +194,7 @@ func (s U16Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -229,6 +231,7 @@ func (s U16Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -261,6 +264,7 @@ func (s U16Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case U16Slice:			copy(s[offset:], container)
 	case []uint16:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -559,7 +563,7 @@ func (s *U16Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -572,6 +576,7 @@ func (s U16Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -595,6 +600,8 @@ func (s U16Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -627,6 +634,8 @@ func (s U16Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/uint32.go b/uint32.go
index 54c438a..ad7c01b 100644
--- a/uint32.go
+++ b/uint32.go
@@ -145,7 +145,7 @@ func (s *U32Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -158,6 +158,7 @@ func (s U32Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -193,6 +194,7 @@ func (s U32Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -229,6 +231,7 @@ func (s U32Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -261,6 +264,7 @@ func (s U32Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case U32Slice:			copy(s[offset:], container)
 	case []uint32:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -559,7 +563,7 @@ func (s *U32Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -572,6 +576,7 @@ func (s U32Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -595,6 +600,8 @@ func (s U32Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -627,6 +634,8 @@ func (s U32Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/uint64.go b/uint64.go
index 4a5be5f..80a2b15 100644
--- a/uint64.go
+++ b/uint64.go
@@ -145,7 +145,7 @@ func (s *U64Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -158,6 +158,7 @@ func (s U64Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -193,6 +194,7 @@ func (s U64Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -229,6 +231,7 @@ func (s U64Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -261,6 +264,7 @@ func (s U64Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case U64Slice:			copy(s[offset:], container)
 	case []uint64:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -559,7 +563,7 @@ func (s *U64Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -572,6 +576,7 @@ func (s U64Slice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -595,6 +600,7 @@ func (s U64Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+	default:						panic(f)
 	}
 }
 
@@ -627,6 +633,8 @@ func (s U64Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/uint8.go b/uint8.go
index 1709d47..71bd7ff 100644
--- a/uint8.go
+++ b/uint8.go
@@ -145,7 +145,7 @@ func (s *U8Slice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -158,6 +158,7 @@ func (s U8Slice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -193,6 +194,7 @@ func (s U8Slice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -229,6 +231,7 @@ func (s U8Slice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -261,6 +264,7 @@ func (s U8Slice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case U8Slice:			copy(s[offset:], container)
 	case []uint8:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -559,7 +563,7 @@ func (s *U8Slice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -567,11 +571,12 @@ func (s *U8Slice) KeepIf(f interface{}) {
 func (s U8Slice) ReverseEach(f interface{}) {
 	switch f := f.(type) {
 	case func(uint8):						for i := len(s) - 1; i > -1; i-- { f(s[i]) }
-	case func(int, uint8):				for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
-	case func(interface{}, uint8):		for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	case func(int, uint8):					for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	case func(interface{}, uint8):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -595,6 +600,8 @@ func (s U8Slice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -627,6 +634,8 @@ func (s U8Slice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/uintptr.go b/uintptr.go
index 4c61dce..b6c88e4 100644
--- a/uintptr.go
+++ b/uintptr.go
@@ -131,7 +131,7 @@ func (s *ASlice) DeleteIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -144,6 +144,7 @@ func (s ASlice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(v) }
 	case func(int, interface{}):			for i, v := range s { f(i, v) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, v) }
+	default:								panic(f)
 	}
 }
 
@@ -179,6 +180,7 @@ func (s ASlice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -215,6 +217,7 @@ func (s ASlice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -247,6 +250,7 @@ func (s ASlice) Overwrite(offset int, container interface{}) {
 	switch container := container.(type) {
 	case ASlice:			copy(s[offset:], container)
 	case []uintptr:			copy(s[offset:], container)
+	default:				panic(container)
 	}
 }
 
@@ -545,7 +549,7 @@ func (s *ASlice) KeepIf(f interface{}) {
 										}
 									}
 
-	default:						p = len(a)
+	default:						panic(f)
 	}
 	*s = a[:p]
 }
@@ -558,6 +562,7 @@ func (s ASlice) ReverseEach(f interface{}) {
 	case func(interface{}):					for i := len(s) - 1; i > -1; i-- { f(s[i]) }
 	case func(int, interface{}):			for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
 	case func(interface{}, interface{}):	for i := len(s) - 1; i > -1; i-- { f(i, s[i]) }
+	default:								panic(f)
 	}
 }
 
@@ -581,6 +586,8 @@ func (s ASlice) ReplaceIf(f interface{}, r interface{}) {
 											s[i] = replacement
 										}
 									}
+
+	default:						panic(f)
 	}
 }
 
@@ -613,6 +620,8 @@ func (s ASlice) Select(f interface{}) interface{} {
 											r = append(r, v)
 										}
 									}
+
+	default:						panic(f)
 	}
 	return r
 }
diff --git a/value.go b/value.go
index 8b98432..b6cadd1 100644
--- a/value.go
+++ b/value.go
@@ -131,6 +131,7 @@ func (s VSlice) Each(f interface{}) {
 	case func(interface{}):					for _, v := range s { f(safeInterface(v)) }
 	case func(int, interface{}):			for i, v := range s { f(i, safeInterface(v)) }
 	case func(interface{}, interface{}):	for i, v := range s { f(i, safeInterface(v)) }
+	default:								panic(f)
 	}
 }
 
@@ -166,6 +167,7 @@ func (s VSlice) While(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -202,6 +204,7 @@ func (s VSlice) Until(f interface{}) int {
 														return i
 													}
 												}
+	default:									panic(f)
 	}
 	return len(s)
 }
@@ -230,10 +233,11 @@ func (s VSlice) BlockClear(start, count int) {
 	}
 }
 
-func (s VSlice) Overwrite(offset int, source interface{}) {
-	switch source := source.(type) {
-	case VSlice:			copy(s[offset:], source)
-	case []reflect.Value:	s.Overwrite(offset, VSlice(source))
+func (s VSlice) Overwrite(offset int, container interface{}) {
+	switch container := container.(type) {
+	case VSlice:			copy(s[offset:], container)
+	case []reflect.Value:	s.Overwrite(offset, VSlice(container))
+	default:				panic(container)
 	}
 }
 
@@ -667,6 +671,7 @@ func (s VSlice) ReverseEach(f interface{}) {
 	case func(interface{}):						for i := s.Len() - 1; i > -1; i-- { f(safeInterface(s[i])) }
 	case func(int, interface{}):				for i := s.Len() - 1; i > -1; i-- { f(i, safeInterface(s[i])) }
 	case func(interface{}, interface{}):		for i := s.Len() - 1; i > -1; i-- { f(i, safeInterface(s[i])) }
+	default:									panic(f)
 	}
 }