Build Kotlin Multiplatform
Release Maven Central
Snapshot Release Sonatype Snapshot
Source API Documentation License

Project Setup

Gradle

Kotlin

implementation("it.czerwinski:kotlin-util:1.5.10")

Groovy

implementation 'it.czerwinski:kotlin-util:1.5.10'

Maven

<dependency>
  <groupId>it.czerwinski</groupId>
  <artifactId>kotlin-util</artifactId>
  <version>1.5.10</version>
</dependency>

Kotlin Multiplatform Projects

In multiplatform projects, the library can be used as commonMain dependency.

See also Kotlin Multiplatform Mobile Example.

Supported Types

Utilities

Option

Scala documentation Scala sources

Implementation differences:

  • exists has been replaced with any – Kotlin convention
  • forall has been replaced with all – Kotlin convention
  • foreach has been replaced with forEach – Kotlin convention
  • orNull has been replaced with getOrNull – Kotlin convention
  • unzip3 has been replaced with unzip – there is no ambiguity in Kotlin
  • implemented additional functions: filterNotNull, filterIsInstance – Kotlin convention

Kotlin introduces its own null-safety mechanisms. Most of the times, Options can be replaced by nullable types in Kotlin, e.g.:

var number: Option<Int> = // …

number.map { it.toString() }.getOrElse { "" }

gives the same result as:

var number: Int? = // …

number?.let { it.toString() }.orEmpty()

However, Options might be useful whenever null values are not allowed, e.g. RxJava 2.x Observable.

Either

Scala documentation Scala sources

Implementation differences:

  • exists has been replaced with any – Kotlin convention
  • forall has been replaced with all – Kotlin convention
  • foreach has been replaced with forEach – Kotlin convention
  • implemented additional functions: filterNot, filterNotNull, filterIsInstance – Kotlin convention
  • implemented additional functions: filterToOption, filterNotToOption, filterNotNullToOption, filterIsInstanceToOption
  • implemented additional function getOrNull in addition to toOption – Kotlin uses its own null-safety mechanisms

Since version 1.3, this implementation is right-biased, therefore it is possible to use methods directly on Either instead of RightProjection, e.g. it is possible to use Either.map {} instead of Either.right.map {}. Use of RightProjection has been deprecated.

Scala convention that “dictates that Left is used for failure and Right is used for success” (Scala Standard Library Documentation) is still a preferred way of using this class.

Try

Scala documentation Scala sources

Implementation differences:

  • foreach has been replaced with forEach – Kotlin convention
  • implemented additional functions: filterNot, filterNotNull, filterIsInstance – Kotlin convention
  • implemented additional function getOrNull in addition to toOption – Kotlin uses its own null-safety mechanisms

Additional Iterators

EmptyIterator

Iterator based on the result of scala.collection.Iterator.empty, producing no values.

Kotlin defines an internal EmptyIterator, which can only be obtained indirectly from empty collections, e.g.:

emptyList<Nothing>().iterator()

SingletonIterator

Iterator based on the result of scala.collection.Iterator.single[A](elem: A), producing a single value.

An iterator for a singleton list is defined in Java, in a package-private static method java.util.Collections.singletonIterator(E e). It can only be obtained indirectly from a new instance of a singleton list, e.g.:

java.util.Collections.singletonList(element).iterator()

Kotlin Multiplatform Mobile Example

  1. Create a new Kotlin Multiplatform Mobile project.
  2. In shared/build.gradle.kts, add kotlin-util dependency to commonMain:
     repositories {
         // [...]
        
         mavenCentral()
     }
     kotlin {
         // [...]
        
         sourceSets {
             // [...]
        
             val commonMain by getting {
                 dependencies {
                     implementation("it.czerwinski:kotlin-util:1.5.10")
                 }
             }
         }
     }
    
  3. Edit Platform class to return Option<String>: commonMain:
     expect class Platform() {
         val platform: Option<String>
     }
    

    androidMain:

     actual class Platform actual constructor() {
         actual val platform: Option<String> = Some("Android ${android.os.Build.VERSION.SDK_INT}")
     }
    

    iosMain:

     actual class Platform actual constructor() {
         actual val platform: Option<String> = Some(
             UIDevice.currentDevice.systemName() + " " + UIDevice.currentDevice.systemVersion
         )
     }
    
  4. Edit Greetings class to get value from Option:
     class Greeting {
         fun greeting(): String {
             return "Hello, kotlin-util on ${Platform().platform.getOrElse { "unknown platform" }}!"
         }
     }    
    
  5. Run both mobile apps.
Android screenshot
Android screenshot
iOS screenshot
iOS screenshot