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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// RUN: %target-typecheck-verify-swift -parse-stdlib
import Swift
infix operator < : ComparisonPrecedence
precedencegroup ComparisonPrecedence {
associativity: none
higherThan: EqualityPrecedence
}
infix operator == : EqualityPrecedence
infix operator != : EqualityPrecedence
precedencegroup EqualityPrecedence {
associativity: none
higherThan: AssignmentPrecedence
}
precedencegroup AssignmentPrecedence {
assignment: true
}
func testslice(_ s: Array<Int>) {
for i in 0..<s.count { print(s[i]+1) }
for i in s { print(i+1) }
_ = s[0..<2]
_ = s[0...1]
_ = s[...1]
_ = s[1...]
_ = s[..<2]
}
@_silgen_name("malloc") func c_malloc(_ size: Int) -> UnsafeMutableRawPointer
@_silgen_name("free") func c_free(_ p: UnsafeMutableRawPointer)
class Vector<T> {
var length : Int
var capacity : Int
var base : UnsafeMutablePointer<T>!
init() {
length = 0
capacity = 0
base = nil
}
func push_back(_ elem: T) {
if length == capacity {
let newcapacity = capacity * 2 + 2
let size = Int(Builtin.sizeof(T.self))
let newbase = UnsafeMutablePointer<T>(c_malloc(newcapacity * size)
.bindMemory(to: T.self, capacity: newcapacity))
for i in 0..<length {
(newbase + i).initialize(to: (base+i).move())
}
c_free(base)
base = newbase
capacity = newcapacity
}
(base+length).initialize(to: elem)
length += 1
}
func pop_back() -> T {
length -= 1
return (base + length).move()
}
subscript (i : Int) -> T {
get {
if i >= length {
Builtin.int_trap()
}
return (base + i).pointee
}
set {
if i >= length {
Builtin.int_trap()
}
(base + i).pointee = newValue
}
}
deinit {
base.deinitialize(count: length)
c_free(base)
}
}
protocol Comparable {
static func <(lhs: Self, rhs: Self) -> Bool
}
func sort<T : Comparable>(_ array: inout [T]) {
for i in 0..<array.count {
for j in i+1..<array.count {
if array[j] < array[i] {
let temp = array[i]
array[i] = array[j]
array[j] = temp
}
}
}
}
func find<T : Eq>(_ array: [T], value: T) -> Int {
var idx = 0
for elt in array {
if (elt == value) { return idx }
idx += 1
}
return -1
}
func findIf<T>(_ array: [T], fn: (T) -> Bool) -> Int {
var idx = 0
for elt in array {
if (fn(elt)) { return idx }
idx += 1
}
return -1
}
protocol Eq {
static func ==(lhs: Self, rhs: Self) -> Bool
static func !=(lhs: Self, rhs: Self) -> Bool
}
|
