update kotlin version to rc-91

build.gradle

@@ -1,5 +1,5 @@
 buildscript {
-    ext.KOTLIN_VERSION="1.1-M01"
+    ext.KOTLIN_VERSION="1.1.0-rc-91"
     ext.kotlin_version = '1.0.3'
 
     repositories {

src/main/kotlin/com/memoizr/assertk/IterableAssert.kt

@@ -3,14 +3,13 @@ package com.memoizr.assertk
 import org.assertj.core.api.AbstractIterableAssert
 import org.assertj.core.api.Assertions.assertThat
 
+
 class IterableAssert<ELEMENT : Any?, ACTUAL : Iterable<ELEMENT>> internal constructor(
         subjectUnderTest: ACTUAL?,
         override val assertion: AbstractIterableAssert<*, Iterable<ELEMENT>, ELEMENT, *> = assertThat(subjectUnderTest))// {
 : AbstractAssertBuilder<IterableAssert<ELEMENT, ACTUAL>, Iterable<ELEMENT>>(subjectUnderTest, IterableAssert::class.java) {
 
-    typealias SELF = IterableAssert<ELEMENT, ACTUAL>
-
-    infix fun _is(selector: SequenceSelector): SELF {
+    infix fun _is(selector: SequenceSelector): IterableAssert<ELEMENT, ACTUAL> {
         when (selector) {
             empty -> assertion.isEmpty()
             nullOrEmpty -> assertion.isNullOrEmpty()
@@ -22,82 +21,82 @@ class IterableAssert<ELEMENT : Any?, ACTUAL : Iterable<ELEMENT>> internal constr
     @Suppress("UNCHECKED_CAST")
     private fun <T> spread(expected: Iterable<T>): Array<T> = expected.toList().toTypedArray<Any?>() as Array<T>
 
-    infix fun hasSize(size: Int): SELF {
+    infix fun hasSize(size: Int): IterableAssert<ELEMENT, ACTUAL> {
         assertion.hasSize(size)
         return myself
     }
 
-    infix fun hasSameSizeAs(expected: ACTUAL): SELF {
+    infix fun hasSameSizeAs(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.hasSameSizeAs(expected)
         return myself
     }
 
-    infix fun contains(expected: ACTUAL): SELF {
+    infix fun contains(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.contains(*spread(expected))
         return myself
     }
 
-    infix fun containsOnly(expected: ACTUAL): SELF {
+    infix fun containsOnly(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.containsOnly(*spread(expected))
         return myself
     }
 
-    infix fun containsOnlyOnce(expected: ACTUAL): SELF {
+    infix fun containsOnlyOnce(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.containsOnlyOnce(*spread(expected))
         return myself
     }
 
-    infix fun containsExactlyInAnyOrder(expected: ACTUAL): SELF {
+    infix fun containsExactlyInAnyOrder(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.containsExactlyInAnyOrder(*spread(expected))
         return myself
     }
 
-    infix fun isSubsetOf(expected: ACTUAL): SELF {
+    infix fun isSubsetOf(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.isSubsetOf(*spread(expected))
         return myself
     }
 
-    infix fun containsSequence(expected: ACTUAL): SELF {
+    infix fun containsSequence(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.containsSequence(*spread(expected))
         return myself
     }
 
-    infix fun containsSubsequence(expected: ACTUAL): SELF {
+    infix fun containsSubsequence(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.containsSubsequence(*spread(expected))
         return myself
     }
 
-    infix fun doesNotContainAnyElementsOf(expected: ACTUAL): SELF {
+    infix fun doesNotContainAnyElementsOf(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.doesNotContainAnyElementsOf(expected)
         return myself
     }
 
-    infix fun doesNotHave(duplicates: duplicates): SELF {
+    infix fun doesNotHave(duplicates: duplicates): IterableAssert<ELEMENT, ACTUAL> {
         assertion.doesNotHaveDuplicates()
         return myself
     }
 
-    infix fun startsWith(expected: ACTUAL): SELF {
+    infix fun startsWith(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.startsWith(*spread(expected))
         return myself
     }
 
-    infix fun startsWith(firstElement: ELEMENT): SELF {
+    infix fun startsWith(firstElement: ELEMENT): IterableAssert<ELEMENT, ACTUAL> {
         assertion.startsWith(firstElement)
         return myself
     }
 
-    infix fun endsWith(expected: ACTUAL): SELF {
+    infix fun endsWith(expected: ACTUAL): IterableAssert<ELEMENT, ACTUAL> {
         assertion.endsWith(*spread(expected))
         return myself
     }
 
-    infix fun endsWith(firstElement: ELEMENT): SELF {
+    infix fun endsWith(firstElement: ELEMENT): IterableAssert<ELEMENT, ACTUAL> {
         assertion.endsWith(firstElement)
         return myself
     }
 
-    infix fun contains(onlyNotNull: onlyNotNull?): SELF {
+    infix fun contains(onlyNotNull: onlyNotNull?): IterableAssert<ELEMENT, ACTUAL> {
         if (onlyNotNull == null) assertion.containsNull() else assertion.doesNotContainNull()
         return myself
     }

src/test/kotlin/com/memoizr/assertk/Iterable assert test.kt

@@ -18,8 +18,7 @@ class `Iterable assert test` {
         }
     }
 
-    typealias IA<ELEMENT> = IterableAssert<ELEMENT, Iterable<ELEMENT>>
-    infix fun <T> IA<T>.canBe(dummyValue: Any): IA<T> = this
+    infix fun <T> IterableAssert<T, Iterable<T>>.canBe(dummyValue: Any): IterableAssert<T, Iterable<T>> = this
     val chained = Any()
 
     val emptyList = emptyList<Any>()