tests: Prepare (ignored) test for enumerate() method

pkgs/std/traits.dora

@@ -154,13 +154,37 @@ pub trait Iterator {
 
     result
   }
+
+  @TraitObjectIgnore
+  fn enumerate(): Enumerate[Self] {
+      Enumerate[Self](it = self, idx = 0)
+  }
 }
 
 pub trait IntoIterator {
   type IteratorType: Iterator;
   fn iter(): Self::IteratorType;
 }
 
+pub class Enumerate[I: Iterator] {
+    it: I,
+    idx: Int,
+}
+
+impl[I: Iterator] Iterator for Enumerate[I] {
+    type Item = (Int, I::Item);
+
+    fn next(): Option[(Int, I::Item)] {
+        if self.it.next() is Some(value) {
+            let idx = self.idx;
+            self.idx += 1;
+            Some[(Int, I::Item)]((idx, value))
+        } else {
+            None[(Int, I::Item)]
+        }
+    }
+}
+
 pub trait IndexGet {
   type Index;
   type Item;

tests/stdlib/iterator-enumerate.dora

@@ -0,0 +1,22 @@
+//= ignore
+
+use std::collections::{HashMap, VecIter};
+use std::traits::Enumerate;
+
+fn main() {
+    let x = Vec[Int]::new(1, 2, 3, 4, 5);
+    let it1: VecIter[Int] = x.iter();
+    let it: Enumerate[VecIter[Int]] = it1.enumerate();
+    assert(Some[(Int, Int)]((0, 1)) == it.next());
+    assert(Some[(Int, Int)]((1, 2)) == it.next());
+    assert(Some[(Int, Int)]((2, 3)) == it.next());
+    assert(Some[(Int, Int)]((3, 4)) == it.next());
+    assert(Some[(Int, Int)]((4, 5)) == it.next());
+    assert(it.next() is None);
+
+    // let x = Array[Int]::new(1, 2, 3, 4, 5);
+    // assert(x.iter().count() == 5);
+
+    // let x = HashMap[Int, String]::new((1, "one"), (2, "two"), (3, "three"));
+    // assert(x.iter().count() == 3);
+}