     override func next() -> Element? {
         switch list {
         case .Nil: return nil
-        case .Cons(let h, let box):
-            list = box.value
+        case .Cons(let h, let t):
+            list = t
             return h
         }
     }

let space:Tokenizer<()> = many(sat(isSpace)) |>> success(())
let ident:Tokenizer<String> = letter |>>= { c in
    many(alphanum) |>>= { cs in
        var list = List<Character>.Cons(h: c, t: Box(cs))
        return success(String(list))
    }
}

let nat:Tokenizer<Int> = digit |>>= { d in
    many(digit) |>>= { ds in
        var list = List<Character>.Cons(h: d, t: Box(ds))
        return success(Int(String(list))!) // Oops, could have some overflow or exception
    }
}

}


// Like Haskell Applicative <*>
infix operator <*> { associativity left precedence 120 }
func <*><A,B>(lhs:Tokenizer<A -> B>, rhs:Tokenizer<A>) -> Tokenizer<B> {
    return apply(lhs, rhs)
}

// Haskell Applicative <*
infix operator <* { associativity left precedence 120 }
func <*<A,B>(lhs:Tokenizer<A>, rhs:Tokenizer<B>) -> Tokenizer<A> {
    return liftA2(const)(lhs)(rhs)
}

// Haskell Applictive *>
infix operator *> { associativity left precedence 120 }
func *><A,B>(lhs:Tokenizer<A>, rhs:Tokenizer<B>) -> Tokenizer<B> {
    return liftA2(const(id))(lhs)(rhs)
