Rename to just Either

Author: OddCoincidence

vm/src/obj/objrange.rs

@@ -7,7 +7,7 @@ use num_traits::{One, Signed, ToPrimitive, Zero};
 
 use crate::function::{OptionalArg, PyFuncArgs};
 use crate::pyobject::{
-    Either2, PyContext, PyIteratorValue, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+    Either, PyContext, PyIteratorValue, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
@@ -212,16 +212,16 @@ impl PyRangeRef {
         .into_ref_with_type(vm, cls)
     }
 
-    fn getitem(self, subscript: Either2<PyIntRef, PySliceRef>, vm: &VirtualMachine) -> PyResult {
+    fn getitem(self, subscript: Either<PyIntRef, PySliceRef>, vm: &VirtualMachine) -> PyResult {
         match subscript {
-            Either2::A(index) => {
+            Either::A(index) => {
                 if let Some(value) = self.get(index.value.clone()) {
                     Ok(PyInt::new(value).into_ref(vm).into_object())
                 } else {
                     Err(vm.new_index_error("range object index out of range".to_string()))
                 }
             }
-            Either2::B(slice) => {
+            Either::B(slice) => {
                 let new_start = if let Some(int) = slice.start.clone() {
                     if let Some(i) = self.get(int) {
                         i

vm/src/pyobject.rs

@@ -1203,7 +1203,7 @@ impl<T: PyValue + 'static> PyObjectPayload for T {
     }
 }
 
-pub enum Either2<A, B> {
+pub enum Either<A, B> {
     A(A),
     B(B),
 }
@@ -1216,28 +1216,28 @@ pub enum Either2<A, B> {
 /// ```
 /// use rustpython_vm::VirtualMachine;
 /// use rustpython_vm::obj::{objstr::PyStringRef, objint::PyIntRef};
-/// use rustpython_vm::pyobject::Either2;
+/// use rustpython_vm::pyobject::Either;
 ///
-/// fn do_something(arg: Either2<PyIntRef, PyStringRef>, vm: &VirtualMachine) {
+/// fn do_something(arg: Either<PyIntRef, PyStringRef>, vm: &VirtualMachine) {
 ///     match arg {
-///         Either2::A(int)=> {
+///         Either::A(int)=> {
 ///             // do something with int
 ///         }
-///         Either2::B(string) => {
+///         Either::B(string) => {
 ///             // do something with string
 ///         }
 ///     }
 /// }
 /// ```
-impl<A, B> TryFromObject for Either2<PyRef<A>, PyRef<B>>
+impl<A, B> TryFromObject for Either<PyRef<A>, PyRef<B>>
 where
     A: PyValue,
     B: PyValue,
 {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         obj.downcast::<A>()
-            .map(Either2::A)
-            .or_else(|obj| obj.clone().downcast::<B>().map(Either2::B))
+            .map(Either::A)
+            .or_else(|obj| obj.clone().downcast::<B>().map(Either::B))
             .map_err(|obj| {
                 vm.new_type_error(format!(
                     "must be {} or {}, not {}",