diff -r d13adbcebf0c src/libbitc/bitc/sets/bit.bitc
--- a/src/libbitc/bitc/sets/bit.bitc	Tue Oct 19 14:34:41 2010 -0700
+++ b/src/libbitc/bitc/sets/bit.bitc	Mon Oct 25 02:56:04 2010 -0700
@@ -38,12 +38,16 @@
 bitc version 0.11
 
 interface bitc.sets.bit {
+//  import bitc.stdio as stdio
   boxed struct bitset {
     nElem : mutable word
     nWords : mutable word
     bits : mutable (mutable uint32)[]
   }
 
+  exception EmptyBitset
+  exception InternalInconsistency
+
   def make() = bitset(0, 0, vector(0))
 
   def isEmpty(s:bitset) = s.nElem == 0;
@@ -83,6 +87,60 @@
           }
   }
 
+  def bitset_map(s: bitset, f) = {
+    when (isEmpty(s) == false)
+    do let numFound: mutable word = 0 in
+         loop i = 0 then i + 1
+         until i == s.nWords || numFound == s.nElem in
+           loop bit = 0 then bit + 1
+           until bit == 32 || numFound == s.nElem in
+             let on = s.bits[i] & (1 << bit) in
+               when(on > 0) do {
+                 f(i * 32 + bit)
+                 numFound := numFound + 1
+               }
+  }
+
+  def max(s: bitset) = {
+    when isEmpty(s) == true
+    do throw EmptyBitset
+
+    let ret:mutable word = s.nWords * 32 + 33 in // one greater than the largest possible
+      let foundMax: mutable bool = false in
+        loop i = s.nWords then i - 1
+        until (i == 0 || foundMax == true) in
+          loop bit = 32 then bit - 1
+          until (bit == 0 || foundMax == true) in
+            when ((s.bits[i - 1] & (1 << (bit - 1))) > 0)
+            do {
+              foundMax := true
+              ret := (i - 1) * 32 + (bit - 1)
+            }
+      when ret > (s.nWords + 1) * 32
+      do throw InternalInconsistency
+      ret
+  }
+
+  def min(s: bitset) = {
+    when isEmpty(s) == true
+    do throw EmptyBitset
+
+    let ret:mutable word = s.nWords * 32 + 33 in // one greater than the largest possible
+      let foundMin: mutable bool = false in
+        loop i = 0 then i + 1
+        until i == s.nWords || foundMin == true in
+          loop bit = 0 then bit + 1
+          until bit == 32 || foundMin == true in
+            when (s.bits[i] & (1 << bit) > 0)
+            do {
+              foundMin := true
+              ret := i * 32 + bit
+            }
+      when ret > (s.nWords + 1) * 32
+      do throw InternalInconsistency
+      ret
+  }
+
   def insert(s, n) = set(s, n, true)
   def remove(s, n) = set(s, n, false)
 }