 enum LazyListMaker<T> {
     case One(Int->T?)
     case Two((Int, [T])->T?)
+    /// one or none
+    func getOne()->(Int->T?) {
+        switch self{
+        case .One(let one): return one
+        default: fatalError("Does not contain Int->T?")
+        }
+    }
+    /// two or none
+    func getTwo()->((Int, [T])->T?) {
+        switch self{
+        case .Two(let two): return two
+        default: fatalError("Does not contain Int, [T])->T?")
+        }
+    }
 }
 class LazyList<T,U> {
     let maker:  LazyListMaker<T>?

            offset: self.offset + n
        )
    }
    /// returns an array with n elements.
    /// this is where laziness ends
    func take(n:Int)->[U] {
        var result:[U] = []

            }
        } else { // List without array -- always infinite
            if let maker = self.maker {
                let makerone = maker.getOne()
                for var i = self.offset; result.count < n; i++ {
                    if let m = makerone(i) {
                        if let v = mapper(m) { result.append(v) }
