diff --git a/enumerable.go b/enumerable.go
index f3aa268..ce02d85 100644
--- a/enumerable.go
+++ b/enumerable.go
@@ -12,14 +12,14 @@ type Enumerable[T any] interface {
     SkipLast(int) Enumerable[T]
     Distinct() Enumerable[T]
     DistinctBy(func(T) any) Enumerable[T]
-    Union(Enumerable[T]) Enumerable[T]
-    UnionBy(Enumerable[T], func(T) any) Enumerable[T]
-    Intersect(Enumerable[T]) Enumerable[T]
-    IntersectBy(Enumerable[T], func(T) any) Enumerable[T]
-    Except(Enumerable[T]) Enumerable[T]
-    ExceptBy(Enumerable[T], func(T) any) Enumerable[T]
-    SequenceEqual(Enumerable[T]) bool
-    SequenceEqualBy(Enumerable[T], func(T) any) bool
+    Union(Iterable[T]) Enumerable[T]
+    UnionBy(Iterable[T], func(T) any) Enumerable[T]
+    Intersect(Iterable[T]) Enumerable[T]
+    IntersectBy(Iterable[T], func(T) any) Enumerable[T]
+    Except(Iterable[T]) Enumerable[T]
+    ExceptBy(Iterable[T], func(T) any) Enumerable[T]
+    SequenceEqual(Iterable[T]) bool
+    SequenceEqualBy(Iterable[T], func(T) any) bool
     Concat(...Iterable[T]) Enumerable[T]
     OrderBy(func(T, T) int) Enumerable[T]
 }
diff --git a/enumerator.go b/enumerator.go
index 14679c8..f4d991c 100644
--- a/enumerator.go
+++ b/enumerator.go
@@ -69,35 +69,35 @@ func (e *enumerator[T]) DistinctBy(keySelector func(T) any) Enumerable[T] {
     return distinctBy(e, keySelector)
 }
 
-func (e *enumerator[T]) Union(target Enumerable[T]) Enumerable[T] {
+func (e *enumerator[T]) Union(target Iterable[T]) Enumerable[T] {
     return union(e, target)
 }
 
-func (e *enumerator[T]) UnionBy(target Enumerable[T], keySelector func(T) any) Enumerable[T] {
+func (e *enumerator[T]) UnionBy(target Iterable[T], keySelector func(T) any) Enumerable[T] {
     return unionBy(e, target, keySelector)
 }
 
-func (e *enumerator[T]) Intersect(target Enumerable[T]) Enumerable[T] {
+func (e *enumerator[T]) Intersect(target Iterable[T]) Enumerable[T] {
     return intersect(e, target)
 }
 
-func (e *enumerator[T]) IntersectBy(target Enumerable[T], keySelector func(T) any) Enumerable[T] {
+func (e *enumerator[T]) IntersectBy(target Iterable[T], keySelector func(T) any) Enumerable[T] {
     return intersectBy(e, target, keySelector)
 }
 
-func (e *enumerator[T]) Except(target Enumerable[T]) Enumerable[T] {
+func (e *enumerator[T]) Except(target Iterable[T]) Enumerable[T] {
     return except(e, target)
 }
 
-func (e *enumerator[T]) ExceptBy(target Enumerable[T], keySelector func(T) any) Enumerable[T] {
+func (e *enumerator[T]) ExceptBy(target Iterable[T], keySelector func(T) any) Enumerable[T] {
     return exceptBy(e, target, keySelector)
 }
 
-func (e *enumerator[T]) SequenceEqual(target Enumerable[T]) bool {
+func (e *enumerator[T]) SequenceEqual(target Iterable[T]) bool {
     return sequenceEqual[T](e, target)
 }
 
-func (e *enumerator[T]) SequenceEqualBy(target Enumerable[T], keySelector func(T) any) bool {
+func (e *enumerator[T]) SequenceEqualBy(target Iterable[T], keySelector func(T) any) bool {
     return sequenceEqualBy(e, target, keySelector)
 }
 
diff --git a/funcs_set_operation.go b/funcs_set_operation.go
index 0073887..7c25c01 100644
--- a/funcs_set_operation.go
+++ b/funcs_set_operation.go
@@ -3,115 +3,115 @@
 package handy
 
 import (
-	"github.com/hsldymq/goiter"
-	"iter"
+    "github.com/hsldymq/goiter"
+    "iter"
 )
 
-func union[T any](e1, e2 Enumerable[T]) Enumerable[T] {
-	return distinct[T](newEnumerator(goiter.Concat(e1.Iter(), e2.Iter())))
+func union[T any](e1, e2 Iterable[T]) Enumerable[T] {
+    return distinct[T](newEnumerator(goiter.Concat(e1.Iter(), e2.Iter())))
 }
 
-func unionBy[T any](e1, e2 Enumerable[T], keySelector func(T) any) Enumerable[T] {
-	return distinctBy(newEnumerator(goiter.Concat(e1.Iter(), e2.Iter())), keySelector)
+func unionBy[T any](e1, e2 Iterable[T], keySelector func(T) any) Enumerable[T] {
+    return distinctBy(newEnumerator(goiter.Concat(e1.Iter(), e2.Iter())), keySelector)
 }
 
-func intersect[T any](e1, e2 Enumerable[T]) Enumerable[T] {
-	typeComparable := isTypeComparable[T]()
-	_, comparableImpl := any(zVal[T]()).(Comparable)
-	if comparableImpl {
-		return intersectBy(e1, e2, func(v T) any { return any(v).(Comparable).ComparingKey() })
-	} else if typeComparable {
-		return intersectBy(e1, e2, func(v T) any { return v })
-	} else {
-		return newEnumerator(goiter.Empty[T]())
-	}
+func intersect[T any](e1, e2 Iterable[T]) Enumerable[T] {
+    typeComparable := isTypeComparable[T]()
+    _, comparableImpl := any(zVal[T]()).(Comparable)
+    if comparableImpl {
+        return intersectBy(e1, e2, func(v T) any { return any(v).(Comparable).ComparingKey() })
+    } else if typeComparable {
+        return intersectBy(e1, e2, func(v T) any { return v })
+    } else {
+        return newEnumerator(goiter.Empty[T]())
+    }
 }
 
-func intersectBy[T any](e1, e2 Enumerable[T], keySelector func(T) any) Enumerable[T] {
-	seq := func(yield func(T) bool) {
-		e2Keys := map[any]bool{}
-		next2, stop2 := iter.Pull(e2.Iter())
-		defer stop2()
-		for {
-			v, ok := next2()
-			if !ok {
-				break
-			}
-			k := keySelector(v)
-			e2Keys[k] = true
-		}
+func intersectBy[T any](e1, e2 Iterable[T], keySelector func(T) any) Enumerable[T] {
+    seq := func(yield func(T) bool) {
+        e2Keys := map[any]bool{}
+        next2, stop2 := iter.Pull(e2.Iter())
+        defer stop2()
+        for {
+            v, ok := next2()
+            if !ok {
+                break
+            }
+            k := keySelector(v)
+            e2Keys[k] = true
+        }
 
-		e1Keys := map[any]bool{}
-		next1, stop1 := iter.Pull(e1.Iter())
-		defer stop1()
-		for {
-			v, ok := next1()
-			if !ok {
-				return
-			}
-			k := keySelector(v)
-			if !e2Keys[k] {
-				continue
-			}
-			if e1Keys[k] {
-				continue
-			}
-			e1Keys[k] = true
-			if !yield(v) {
-				return
-			}
-		}
-	}
-	return newEnumerator(seq)
+        e1Keys := map[any]bool{}
+        next1, stop1 := iter.Pull(e1.Iter())
+        defer stop1()
+        for {
+            v, ok := next1()
+            if !ok {
+                return
+            }
+            k := keySelector(v)
+            if !e2Keys[k] {
+                continue
+            }
+            if e1Keys[k] {
+                continue
+            }
+            e1Keys[k] = true
+            if !yield(v) {
+                return
+            }
+        }
+    }
+    return newEnumerator(seq)
 }
 
-func except[T any](e1, e2 Enumerable[T]) Enumerable[T] {
-	typeComparable := isTypeComparable[T]()
-	_, comparableImpl := any(zVal[T]()).(Comparable)
-	if comparableImpl {
-		return exceptBy(e1, e2, func(v T) any { return any(v).(Comparable).ComparingKey() })
-	} else if typeComparable {
-		return exceptBy(e1, e2, func(v T) any { return v })
-	} else {
-		return newEnumerator(e1.Iter())
-	}
+func except[T any](e1, e2 Iterable[T]) Enumerable[T] {
+    typeComparable := isTypeComparable[T]()
+    _, comparableImpl := any(zVal[T]()).(Comparable)
+    if comparableImpl {
+        return exceptBy(e1, e2, func(v T) any { return any(v).(Comparable).ComparingKey() })
+    } else if typeComparable {
+        return exceptBy(e1, e2, func(v T) any { return v })
+    } else {
+        return newEnumerator(e1.Iter())
+    }
 }
 
-func exceptBy[T any](e1, e2 Enumerable[T], keySelector func(T) any) Enumerable[T] {
-	seq := func(yield func(T) bool) {
-		e2Keys := map[any]bool{}
-		next2, stop2 := iter.Pull(e2.Iter())
-		defer stop2()
-		for {
-			v, ok := next2()
-			if !ok {
-				break
-			}
-			k := keySelector(v)
-			e2Keys[k] = true
-		}
+func exceptBy[T any](e1, e2 Iterable[T], keySelector func(T) any) Enumerable[T] {
+    seq := func(yield func(T) bool) {
+        e2Keys := map[any]bool{}
+        next2, stop2 := iter.Pull(e2.Iter())
+        defer stop2()
+        for {
+            v, ok := next2()
+            if !ok {
+                break
+            }
+            k := keySelector(v)
+            e2Keys[k] = true
+        }
 
-		e1Keys := map[any]bool{}
-		next1, stop1 := iter.Pull(e1.Iter())
-		defer stop1()
-		for {
-			v, ok := next1()
-			if !ok {
-				return
-			}
-			k := keySelector(v)
-			if e2Keys[k] {
-				continue
-			}
-			if e1Keys[k] {
-				continue
-			}
-			e1Keys[k] = true
-			if !yield(v) {
-				return
-			}
-		}
-	}
+        e1Keys := map[any]bool{}
+        next1, stop1 := iter.Pull(e1.Iter())
+        defer stop1()
+        for {
+            v, ok := next1()
+            if !ok {
+                return
+            }
+            k := keySelector(v)
+            if e2Keys[k] {
+                continue
+            }
+            if e1Keys[k] {
+                continue
+            }
+            e1Keys[k] = true
+            if !yield(v) {
+                return
+            }
+        }
+    }
 
-	return newEnumerator(seq)
+    return newEnumerator(seq)
 }
diff --git a/list.go b/list.go
index a55a1aa..8e665b5 100644
--- a/list.go
+++ b/list.go
@@ -290,35 +290,35 @@ func (l *List[T]) DistinctBy(keySelector func(T) any) Enumerable[T] {
     return distinctBy(l, keySelector)
 }
 
-func (l *List[T]) Union(target Enumerable[T]) Enumerable[T] {
+func (l *List[T]) Union(target Iterable[T]) Enumerable[T] {
     return union(l, target)
 }
 
-func (l *List[T]) UnionBy(target Enumerable[T], keySelector func(T) any) Enumerable[T] {
+func (l *List[T]) UnionBy(target Iterable[T], keySelector func(T) any) Enumerable[T] {
     return unionBy(l, target, keySelector)
 }
 
-func (l *List[T]) Intersect(target Enumerable[T]) Enumerable[T] {
+func (l *List[T]) Intersect(target Iterable[T]) Enumerable[T] {
     return intersect(l, target)
 }
 
-func (l *List[T]) IntersectBy(target Enumerable[T], keySelector func(T) any) Enumerable[T] {
+func (l *List[T]) IntersectBy(target Iterable[T], keySelector func(T) any) Enumerable[T] {
     return intersectBy(l, target, keySelector)
 }
 
-func (l *List[T]) Except(target Enumerable[T]) Enumerable[T] {
+func (l *List[T]) Except(target Iterable[T]) Enumerable[T] {
     return except(l, target)
 }
 
-func (l *List[T]) ExceptBy(target Enumerable[T], keySelector func(T) any) Enumerable[T] {
+func (l *List[T]) ExceptBy(target Iterable[T], keySelector func(T) any) Enumerable[T] {
     return exceptBy(l, target, keySelector)
 }
 
-func (l *List[T]) SequenceEqual(target Enumerable[T]) bool {
+func (l *List[T]) SequenceEqual(target Iterable[T]) bool {
     return sequenceEqual[T](l, target)
 }
 
-func (l *List[T]) SequenceEqualBy(target Enumerable[T], keySelector func(T) any) bool {
+func (l *List[T]) SequenceEqualBy(target Iterable[T], keySelector func(T) any) bool {
     return sequenceEqualBy(l, target, keySelector)
 }