         }
     }
 }
-
 /// placeholder class
 class LazyLists {
     class var Ints:LazyList<Int,Int> {
-        return LazyList (
-            maker: LazyListMaker.One({ $0 }),
-            seed:  nil,
-            mapper:{ $0 }
+    return LazyList (
+        maker:  LazyListMaker.One({ $0 }),
+        seed:   nil,
+        mapper: { $0 }
         )
     }
     class var UInts:LazyList<UInt,UInt> {
-        return LazyList (
-            maker: LazyListMaker.One({ UInt($0) }),
-            seed:  nil,
-            mapper:{ $0 }
+    return LazyList (
+        maker:  LazyListMaker.One({ UInt($0) }),
+        seed:   nil,
+        mapper: { $0 }
         )
     }
 }
 /// Factory Functions
 func lazylist<T>(maker:Int->T?)->LazyList<T,T> {
     return LazyList (
-        maker:LazyListMaker.One(maker),
-        seed:nil,
-        mapper:{ $0 }
+        maker:  LazyListMaker.One(maker),
+        seed:   nil,
+        mapper: { $0 }
     )
 }
 func lazylist<T>(seed:[T])->LazyList<T,T> {
     return LazyList (
-        maker:nil,
-        seed:seed,
-        mapper:{ $0 }
+        maker:  nil,
+        seed:   seed,
+        mapper: { $0 }
     )
 }
 func lazylist<T>(seed:[T], maker:(Int,[T])->T?)->LazyList<T,T> {
     return LazyList (
-        maker:LazyListMaker.Two(maker),
-        seed:seed,
-        mapper:{ $0 }
+        maker:  LazyListMaker.Two(maker),
+        seed:   seed,
+        mapper: { $0 }
     )
 }

                    }
                    if let v = mapper(seed[i]) { result.append(v) }
                }
            // finite so break on broke :-)
            } else {
                for var i = 0; result.count < need; i++ {
                    if i == seed.count { break }
                    if let v = mapper(seed[i]) { result.append(v) }

    case Two((Int, [T])->T?)
}
class LazyList<T,U> {
    let maker:  LazyListMaker<T>?
    let seed:   [T]?
    let mapper: T->U?
    let offset: Int
    /// lazy list.  infinite unless maker is nil
    init(maker:LazyListMaker<T>?, seed:[T]?,
        mapper:T->U?, offset:Int = 0) {
            self.maker  = maker
            self.seed   = seed
            self.mapper = mapper
            self.offset = offset
    }
    /// creates new mapper and installs it
    func map<V>(mapper:U->V?)->LazyList<T,V> {
        return LazyList<T,V>(
            maker:  maker,
            seed:   seed,
            mapper: { (t:T) -> V? in
                if let u = self.mapper(t) { return mapper(u) }
                else { return nil }
