             }
         }
     }
-    /// returns a new lazy list with n elements truncated
-    /// -- actually it only sets the offset
-    func drop(n:Int) -> LazyList<T,U> {
-        return LazyList<T,U> (
-            maker:  self.maker,
-            seed:   self.seed,
-            mapper: self.mapper,
-            offset: self.offset + n
-        )
-    }
     /// just take(i+1) and return the last element
     subscript(i:Int)->U? {
         let a = self.drop(i).take(1)
-        return a.isEmpty ? nil : a[0]
+            return a.isEmpty ? nil : a[0]
     }
     /// b..<e -> drop(b) then take (e-b)
     subscript(r:Range<Int>)->[U] {

                    }
                    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) }

            }
        )
    }
    /// returns a new lazy list with n elements truncated
    /// -- actually it only sets the offset
    func drop(n:Int) -> LazyList<T,U> {
        return LazyList<T,U> (
            maker:  self.maker,
            seed:   self.seed,
            mapper: self.mapper,
            offset: self.offset + n
        )
    }
    /// returns an array with n elements.
    /// this is where laziness ends
    func take(n:Int)->[U] {
        var result:[U] = []
        if self.seed {
            var seed = self.seed!
            let need = n + self.offset
            if let maker = self.maker { // fill the seed
                var makertwo:(Int,[T])->T?
                switch maker {
                case .Two(let two): makertwo = two
