mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
ff2dd6320a
When colon specifies is-a relationship between types, we put spaces on both sides of the colon. Swift SVN r27016
81 lines
2.2 KiB
Swift
81 lines
2.2 KiB
Swift
//===--- Map.swift - tests for lazy mapping -------------------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See http://swift.org/LICENSE.txt for license information
|
|
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
// RUN: %target-run-simple-swift | FileCheck %s
|
|
|
|
// CHECK: testing...
|
|
println("testing...")
|
|
|
|
// Test mapping a collection
|
|
// CHECK-NEXT: [6, 9, 12, 15, 18, 21]
|
|
let a = lazy(2..<8).map { $0 * 3 }.array
|
|
println(a)
|
|
|
|
// Test mapping a sequence
|
|
let s = lazy(a.generate()).map { $0 / 3 }
|
|
// CHECK-NEXT: <2, 3, 4, 5, 6, 7>
|
|
print("<")
|
|
var prefix = ""
|
|
for x in s {
|
|
print("\(prefix)\(x)")
|
|
prefix = ", "
|
|
}
|
|
println(">")
|
|
|
|
//===--- Avoid creating gratutitously self-destructive sequences ----------===//
|
|
|
|
// In a naive implementation, mapping over a non-self-destructive
|
|
// SequenceType having a reference-semantics GeneratorType produces a
|
|
// self-destructive mapped view. This is technically correct because
|
|
// Sequences are allowed to be self-destructive, and theoretically
|
|
// every multi-pass SequenceType would be a CollectionType, but Sequences are
|
|
// much easier to build than Collections and it would be extremely
|
|
// surprising for users if their mappings were not stable.
|
|
|
|
// A GeneratorType with reference semantics
|
|
class Counter : GeneratorType {
|
|
func next() -> Int? {
|
|
return n < end ? n++ : nil
|
|
}
|
|
|
|
init(_ n: Int, _ end: Int) {
|
|
self.n = n
|
|
self.end = end
|
|
}
|
|
|
|
var n: Int
|
|
var end: Int
|
|
}
|
|
|
|
// A SequenceType with value semantics
|
|
struct IntRange : SequenceType {
|
|
func generate() -> Counter {
|
|
return Counter(start, end)
|
|
}
|
|
|
|
var start: Int
|
|
var end: Int
|
|
}
|
|
|
|
|
|
// Make sure we can iterate a mapped view of IntRange without
|
|
// consuming it.
|
|
let m1 = lazy(IntRange(start: 1, end: 5)).map { $0 * 2 }
|
|
// CHECK-NEXT: [2, 4, 6, 8]
|
|
println(Array(m1))
|
|
|
|
// A second iteration produces the same result.
|
|
// CHECK-NEXT: [2, 4, 6, 8]
|
|
println(Array(m1))
|
|
|
|
// CHECK-NEXT: all done.
|
|
println("all done.")
|