Unresolved reference: launch

Trying to run some examples for Kotlin coroutines, but can't build my project. I'm using the latest gradle release - 4.1

Any suggestions what to check/fix?

Here is build.gradle

buildscript {
    ext.kotlin_version = '1.1.4-3'

    repositories {
        mavenCentral()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

apply plugin: 'kotlin'
apply plugin: 'application'

kotlin {
    repositories {
        jcenter()
    }

    experimental {
        coroutines 'enable'
    }

    dependencies {
        compile "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.18"
    }
}

and the main.kt

fun main(args: Array<String>) {
    launch (CommonPool) {
        delay(1000L)
        println("World!")
    }

    println("Hello, ")
    Thread.sleep(2000L)
}

when I run gradle compileKotlin I get the following

e: /Users/philippgrigoryev/projects/kotlin-coroutines/src/main/kotlin/main.kt: (2, 5): Unresolved reference: launch
e: /Users/philippgrigoryev/projects/kotlin-coroutines/src/main/kotlin/main.kt: (2, 13): Unresolved reference: CommonPool
e: /Users/philippgrigoryev/projects/kotlin-coroutines/src/main/kotlin/main.kt: (3, 9): Unresolved reference: delay`

Launch isn't used anymore directly. The Kotlin documentation suggests using:

fun main() { 
    GlobalScope.launch { // launch a new coroutine in background and continue
        delay(1000L)
        println("World!")
    }
    println("Hello,") // main thread continues here immediately
    runBlocking {     // but this expression blocks the main thread
        delay(2000L)  // ... while we delay for 2 seconds to keep JVM alive
    } 
}

If you are using Coroutines 1.0+, the import is no longer

> import kotlinx.coroutines.experimental.*

but

> import kotlinx.coroutines.launch

You would need the following in the dependencies closure of your build.gradle (for Coroutines 1.0.1):

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.1'
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.1"

Like already answered in the comments, the import is missing for the kotlinx.coroutines.experimental.* package. You can have a look at my examples at GitHub if you like.

import kotlinx.coroutines.experimental.*

fun main(args: Array<String>) {
 
    launch(CommonPool) {
        delay(1000)
        LOG.debug("Hello from coroutine")
    }

}

Try this way,

//add this lines to gradle

 implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$rootProject.kotlinx_coroutines"
 implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$rootProject.kotlinx_coroutines"


  class xyz{
     private val job = Job()
        private val coroutinesScope: CoroutineScope = CoroutineScope(job + Dispatchers.IO)
    
      ....
     . ...
       coroutinesScope.launch {
                       // task to do
                        Timber.d("Delete Firebase Instance ID")
                    }
    
    
    // clear the job
      job.cancel()
    
    }

I am using

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.1"

Instead of launch, GlobalScope.launch works.

Given below is the imports:-

import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch

This confused me for a while because the tutorial I am doing shows it used directly... I think they have changed how it is used from a previous version.

I think the trick is that you can only call launch() within a Coroutine scope.

So this does not work:

fun main() {
    launch()  // not called within coroutine scope
}

Where this will work:

fun main() {
 runBlocking {
        launch()  // called within coroutine scope
    }
}

code snippit example