1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
// RangeReplaceablePlusDefault benchmark
//
// Source: https://gist.github.com/airspeedswift/392599e7eeeb74b481a7
import TestsUtils
public let benchmarks =
BenchmarkInfo(
name: "RangeReplaceableCollectionPlusDefault",
runFunction: run_RangeReplaceableCollectionPlusDefault,
tags: [.validation],
legacyFactor: 4
)
@inline(never)
public func run_RangeReplaceableCollectionPlusDefault(_ n: Int) {
let stringsRef = [1, 2, 3]
let strings = ["1", "2", "3"]
let toInt = { (s: String) -> Int? in Int(s) }
var a = [Int]()
var b = [Int]()
for _ in 1...250*n {
let a2: Array = mapSome(strings, toInt)
let b2 = mapSome(strings, toInt)
a = a2
b = b2
if !compareRef(a, b, stringsRef) {
break
}
}
check(compareRef(a, b, stringsRef))
}
func compareRef(_ a: [Int], _ b: [Int], _ ref: [Int]) -> Bool {
return ref == a && ref == b
}
// This algorithm returns a generic placeholder
// that can be any kind of range-replaceable collection:
func mapSome
<S: Sequence, C: RangeReplaceableCollection>
(_ source: S, _ transform: (S.Element)->C.Element?) -> C {
var result = C()
for x in source {
if let y = transform(x) {
result.append(y)
}
}
return result
}
// If you write a second version that returns an array,
// you can call the more general version for implementation:
func mapSome<S: Sequence,U>(_ source: S, _ transform: (S.Element)->U?)->[U] {
// just calls the more generalized version
// (works because here, the return type
// is now of a specific type, an Array)
return mapSome(source, transform)
}
|
