diff --git a/idea/testData/checker/Constructors.jet b/idea/testData/checker/Constructors.jet
index afb5c36fd5db4c3a50aad73ab62a873dedc9f2ca..d743cc0b5bd4b255265bb3a34b05f8585a68cfd4 100644
--- a/idea/testData/checker/Constructors.jet
+++ b/idea/testData/checker/Constructors.jet
@@ -48,16 +48,4 @@ class NoCPI {
var ab = 1
get() = 1
set(v) {}
-}
-
-a.select(it => it.toString()).where(it => it < 1)
-a.select{it.toString()}.where{it < 1}
-
-
-for (a in 1..10)
-
-for ((val a, val b) in range)
-
-for ((a, b) in range) {
- is Foo => sdgfsdg
}
\ No newline at end of file
diff --git a/idea/testData/psi/examples/priorityqueues/BinaryHeap.jet b/idea/testData/psi/examples/priorityqueues/BinaryHeap.jet
new file mode 100644
index 0000000000000000000000000000000000000000..78e074cebdc05c6ac2f6cae4e34176a454a672ed
--- /dev/null
+++ b/idea/testData/psi/examples/priorityqueues/BinaryHeap.jet
@@ -0,0 +1,89 @@
+class BinaryHeap(_data : IIterable, compare : Comparison = naturalOrder) : IPriorityQueue {
+ private val data : IMutableList = new ArrayList(_data)
+
+ {
+ for (val i in data.size / 2 .. 0) {
+ siftDown(i)
+ }
+ }
+
+ override fun extract() : T {
+ if (this.isEmpty)
+ throw new UnderflowException()
+ data.swap(0, data.lastIndex)
+ data.remove(data.lastIndex)
+ siftDown(0)
+ }
+
+ override fun add(item : T) {
+ data.add(item)
+ siftUp(data.lastItem)
+ }
+
+ private fun siftDown(index : Int) {
+ var current = index
+ while (current.left.exists) {
+ var min = current
+ if (current.left.value < min.value) {
+ min = current.left
+ }
+ if (current.right.exists && current.right.value < min.value) {
+ min = current.right
+ }
+ if (min == current) break
+ data.swap(min, current)
+ current = min
+ }
+ }
+
+ private fun siftUp(index : Int) {
+ if (!current.exists) return
+ var current = index
+ while (current.parent.exists) {
+ if (current.value < current.parent.value) {
+ data.swap(current, current.parent)
+ current = current.parent
+ }
+ }
+ }
+
+ private extension HeapIndex for Int {
+ val parent : Int
+ get() = (this - 1) / 2
+
+
+ val left : Int
+ get() = this * 2 + 1
+
+
+ val right : Int
+ get() = this * 2 + 2
+
+
+ val value : T = foo.bar()
+ get() = data[this]
+ set(it) {
+ $value = it
+ }
+
+
+ val exists : Boolean
+ get() = (this < data.size) && (this >= 0)
+
+ }
+
+ private extension for T {
+ fun compareTo(other : T) : Int = compare(this, other)
+ }
+
+}
+
+fun IMutableList.swap(a : Int, b : Int) {
+ val t = this[a]
+ this[a] = this[b]
+ this[b] = t
+}
+
+val IList.lastIndex : Int
+ get() = this.size - 1
+