Skip to content

Commit b5bfbab

Browse files
oderskyodersky
committed
Change stdlib collections to be compiled under capture checking
1 parent 3caf116 commit b5bfbab

File tree

145 files changed

+1983
-1980
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

145 files changed

+1983
-1980
lines changed

‎tests/pos-special/stdlib/Test1.scala

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
import language.experimental.captureChecking
2+
import collection.{View, Seq}
3+
import collection.mutable.{ArrayBuffer, ListBuffer}
4+
5+
import java.io.*
6+
7+
object Test0:
8+
9+
def usingLogFile[sealed T](op: FileOutputStream^ => T): T =
10+
val logFile = FileOutputStream("log")
11+
val result = op(logFile)
12+
logFile.close()
13+
result
14+
15+
def test(xs: List[Int]) =
16+
usingLogFile: f =>
17+
xs.map: x =>
18+
f.write(x)
19+
x * x
20+
21+
object Test1:
22+
def test(it: Iterator[Int]^, v: View[Int]^) =
23+
val isEven: Int ->{cap[test]} Boolean = _ % 2 == 0
24+
val it2 = it.filter(isEven)
25+
val _: Iterator[Int]^{it, isEven} = it2
26+
val it2c: Iterator[Int]^{it2} = it2
27+
val v2 = v.filter(isEven)
28+
val _: View[Int]^{v, isEven} = v2
29+
val v2c: View[Int]^{v2} = v2
30+
val v3 = v.drop(2)
31+
val _: View[Int]^{v} = v3
32+
val v3c: View[Int]^{v3} = v3
33+
val (xs6, xs7) = v.partition(isEven)
34+
val (xs6a, xs7a) = v.partition(_ % 2 == 0)

‎tests/pos-special/stdlib/Test2.scala

Lines changed: 232 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,232 @@
1+
import scala.reflect.ClassTag
2+
import language.experimental.captureChecking
3+
import collection.{View, Seq}
4+
import collection.mutable.{ArrayBuffer, ListBuffer}
5+
6+
object Test {
7+
8+
def seqOps(xs: Seq[Int]) = { // try with Seq[Int]^{cap}
9+
val strPlusInt: (String, Int) => String = _ + _
10+
val intPlusStr: (Int, String) => String = _ + _
11+
val isEven: Int => Boolean = _ % 2 == 0
12+
val isNonNeg: Int => Boolean = _ > 0
13+
val flips: Int => List[Int] = x => x :: -x :: Nil
14+
val x1 = xs.foldLeft("")(strPlusInt)
15+
val y1: String = x1
16+
val x2 = xs.foldRight("")(intPlusStr)
17+
val y2: String = x2
18+
val x3 = xs.indexWhere(isEven)
19+
val y3: Int = x3
20+
val x4 = xs.head
21+
val y4: Int = x4
22+
val x5 = xs.to(List)
23+
val y5: List[Int] = x5
24+
val (xs6, xs7) = xs.partition(isEven)
25+
val ys6: Seq[Int] = xs6
26+
val ys7: Seq[Int] = xs7
27+
val xs8 = xs.drop(2)
28+
val ys8: Seq[Int] = xs8
29+
val xs9 = xs.map(isNonNeg)
30+
val ys9: Seq[Boolean] = xs9
31+
val xs10 = xs.flatMap(flips)
32+
val ys10: Seq[Int] = xs10
33+
val xs11 = xs ++ xs
34+
val ys11: Seq[Int] = xs11
35+
val xs12 = xs ++ Nil
36+
val ys12: Seq[Int] = xs12
37+
val xs13 = Nil ++ xs
38+
val ys13: Seq[Int] = xs13
39+
val xs14 = xs ++ ("a" :: Nil)
40+
val ys14: Seq[Any] = xs14
41+
val xs15 = xs.zip(xs9)
42+
val ys15: Seq[(Int, Boolean)] = xs15
43+
val xs16 = xs.reverse
44+
val ys16: Seq[Int] = xs16
45+
println("-------")
46+
println(x1)
47+
println(x2)
48+
println(x3)
49+
println(x4)
50+
println(x5)
51+
println(xs6)
52+
println(xs7)
53+
println(xs8)
54+
println(xs9)
55+
println(xs10)
56+
println(xs11)
57+
println(xs12)
58+
println(xs13)
59+
println(xs14)
60+
println(xs15)
61+
println(xs16)
62+
}
63+
64+
def iterOps(xs: => Iterator[Int]^) =
65+
val strPlusInt: (String, Int) => String = _ + _
66+
val intPlusStr: (Int, String) => String = _ + _
67+
val isEven: Int ->{cap[iterOps]} Boolean = _ % 2 == 0
68+
val isNonNeg: Int => Boolean = _ > 0
69+
val flips: Int => List[Int] = x => x :: -x :: Nil
70+
val x1 = xs.foldLeft("")(strPlusInt)
71+
val y1: String = x1
72+
val x2 = xs.foldRight("")(intPlusStr)
73+
val y2: String = x2
74+
val x4 = xs.next()
75+
val y4: Int = x4
76+
val x5 = xs.to(List)
77+
val y5: List[Int] = x5
78+
val (xs6, xs7) = xs.partition(isEven)
79+
val ys6: Iterator[Int]^{xs6, isEven} = xs6
80+
val ys7: Iterator[Int]^{xs7, isEven} = xs7
81+
val (xs6a, xs7a) = xs.partition(_ % 2 == 0)
82+
val ys6a: Iterator[Int]^{xs6} = xs6
83+
val ys7a: Iterator[Int]^{xs7} = xs7
84+
val xs8 = xs.drop(2)
85+
val ys8: Iterator[Int]^{xs8} = xs8
86+
val xs9 = xs.map(isNonNeg)
87+
val ys9: Iterator[Boolean]^{xs9} = xs9
88+
val xs10 = xs.flatMap(flips)
89+
val ys10: Iterator[Int]^{xs10} = xs10
90+
val xs11 = xs ++ xs
91+
val ys11: Iterator[Int]^{xs11} = xs11
92+
val xs12 = xs ++ Nil
93+
val ys12: Iterator[Int]^{xs12} = xs12
94+
val xs13 = Nil ++ xs
95+
val ys13: List[Int] = xs13
96+
val xs14 = xs ++ ("a" :: Nil)
97+
val ys14: Iterator[Any]^{xs14} = xs14
98+
val xs15 = xs.zip(xs9)
99+
val ys15: Iterator[(Int, Boolean)]^{xs15} = xs15
100+
println("-------")
101+
println(x1)
102+
println(x2)
103+
println(x4)
104+
println(x5)
105+
println(xs6.to(List))
106+
println(xs7.to(List))
107+
println(xs8.to(List))
108+
println(xs9.to(List))
109+
println(xs10.to(List))
110+
println(xs11.to(List))
111+
println(xs12.to(List))
112+
println(xs13.to(List))
113+
println(xs14.to(List))
114+
println(xs15.to(List))
115+
116+
def viewOps(xs: View[Int]^) = {
117+
val strPlusInt: (String, Int) => String = _ + _
118+
val intPlusStr: (Int, String) => String = _ + _
119+
val isEven: Int ->{cap[viewOps]} Boolean = _ % 2 == 0
120+
val isNonNeg: Int => Boolean = _ > 0
121+
val flips: Int => List[Int] = x => x :: -x :: Nil
122+
val x1 = xs.foldLeft("")(strPlusInt)
123+
val y1: String = x1
124+
val x2 = xs.foldRight("")(intPlusStr)
125+
val y2: String = x2
126+
//val x3 = xs.indexWhere(_ % 2 == 0) // indexWhere does not exist on View
127+
//val y3: Int = x3
128+
val x4 = xs.head
129+
val y4: Int = x4
130+
val x5 = xs.to(List)
131+
val y5: List[Int] = x5
132+
val (xs6, xs7) = xs.partition(isEven)
133+
val ys6: View[Int]^{xs6, isEven} = xs6
134+
val ys7: View[Int]^{xs7, isEven} = xs7
135+
val (xs6a, xs7a) = xs.partition(_ % 2 == 0)
136+
val ys6a: View[Int]^{xs6} = xs6
137+
val ys7a: View[Int]^{xs7} = xs7
138+
val xs8 = xs.drop(2)
139+
val ys8: View[Int]^{xs8} = xs8
140+
val xs9 = xs.map(isNonNeg)
141+
val ys9: View[Boolean]^{xs9} = xs9
142+
val xs10 = xs.flatMap(flips)
143+
val ys10: View[Int]^{xs10} = xs10
144+
val xs11 = xs ++ xs
145+
val ys11: View[Int]^{xs11} = xs11
146+
val xs12 = xs ++ Nil
147+
val ys12: View[Int]^{xs12} = xs12
148+
val xs13 = Nil ++ xs
149+
val ys13: List[Int] = xs13
150+
val xs14 = xs ++ ("a" :: Nil)
151+
val ys14: View[Any]^{xs14} = xs14
152+
val xs15 = xs.zip(xs9)
153+
val ys15: View[(Int, Boolean)]^{xs15} = xs15
154+
println("-------")
155+
println(x1)
156+
println(x2)
157+
println(x4)
158+
println(x5)
159+
println(xs6.to(List))
160+
println(xs7.to(List))
161+
println(xs8.to(List))
162+
println(xs9.to(List))
163+
println(xs10.to(List))
164+
println(xs11.to(List))
165+
println(xs12.to(List))
166+
println(xs13.to(List))
167+
println(xs14.to(List))
168+
println(xs15.to(List))
169+
}
170+
171+
def stringOps(xs: String) = {
172+
val x1 = xs.foldLeft("")(_ + _)
173+
val y1: String = x1
174+
val x2 = xs.foldRight("")(_ + _)
175+
val y2: String = x2
176+
val x3 = xs.indexWhere(_ % 2 == 0)
177+
val y3: Int = x3
178+
val x4 = xs.head
179+
val y4: Int = x4
180+
val x5 = xs.to(List)
181+
val y5: List[Char] = x5
182+
val (xs6, xs7) = xs.partition(_ % 2 == 0)
183+
val ys6: String = xs6
184+
val ys7: String = xs7
185+
val xs8 = xs.drop(2)
186+
val ys8: String = xs8
187+
val xs9 = xs.map(_ + 1)
188+
val ys9: Seq[Int] = xs9
189+
val xs9a = xs.map(_.toUpper)
190+
val ys9a: String = xs9a
191+
val xs10 = xs.flatMap((x: Char) => s"$x,$x")
192+
val ys10: String = xs10
193+
val xs11 = xs ++ xs
194+
val ys11: String = xs11
195+
val ops = collection.StringOps(xs) // !!! otherwise we can a "cannot establish reference"
196+
val xs13 = Nil ++ ops.iterator
197+
val ys13: List[Char] = xs13
198+
val xs14 = xs ++ ("xyz" :: Nil)
199+
val ys14: Seq[Any] = xs14
200+
val xs15 = xs.zip(xs9)
201+
val ys15: Seq[(Char, Int)] = xs15
202+
println("-------")
203+
println(x1)
204+
println(x2)
205+
println(x3)
206+
println(x4)
207+
println(x5)
208+
println(xs6)
209+
println(xs7)
210+
println(xs8)
211+
println(xs9)
212+
println(xs9a)
213+
println(xs10)
214+
println(xs11)
215+
println(xs13)
216+
println(xs14)
217+
println(xs15)
218+
}
219+
220+
def main(args: Array[String]) = {
221+
val ints = List(1, 2, 3)
222+
val intsBuf = ints.to(ArrayBuffer)
223+
val intsListBuf = ints.to(ListBuffer)
224+
val intsView = ints.view
225+
seqOps(ints)
226+
seqOps(intsBuf)
227+
seqOps(intsListBuf)
228+
viewOps(intsView)
229+
iterOps(ints.iterator)
230+
stringOps("abc")
231+
}
232+
}

0 commit comments

Comments
 (0)