import java.lang.Math

import kotlin.math.sin
...
val x = sin(1.562)

import kotlin.math.absoluteValue
...
val x:Double = -3.5
val y = x.absoluteValue // -> 3.5

import java.util.Date
import java.util.GregorianCalendar
import java.text.SimpleDateFormat

val timeMillis:Long = System.currentTimeMillis()
val d = Date()
val cal = GregorianCalendar()
val sdf = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

val t1 = System.currentTimeMillis()
...
Log.d("LOG", "Calculation took " +
      (System.currentTimeMillis() - t1) + "ms")

import java.util.Date
...
val d = Date() // current time
Log.d("LOG", d.toString())
// -> s.th. like
// Sun Jan 13 10:12:26 GMT+01:00 2019

import java.util.Date
...
val d = Date()  // current time
val tm = d.time // ms since 1970-01-01T00:00:00 UTC

import java.util.Date
import java.util.Calendar
import java.util.GregorianCalendar
import java.util.TimeZone
...
val cal = GregorianCalendar()
// <- will hold the current time

cal.timeZone = TimeZone.getTimeZone("US/Hawaii")
// Note: TimeZone.getAvailableIDs().forEach {
//     Log.e("LOG","!!! " + it) }
// shows a list

// Set to current time
cal.time = Date()

// Set to 2018-02-01T13:27:44
cal.set(2018, Calendar.FEBRUARY,  1, 13, 27 ,44)

val month = cal.get(Calendar.MONTH)
val hour = cal.get(Calendar.HOUR_OF_DAY)

import java.util.Date
import java.text.SimpleDateFormat
import java.util.Locale
...

val d = Date() // now
val sdf = SimpleDateFormat("yyyy-MM-dd HH:mm")
Log.d("LOG", sdf.format(d)) // -> 2019-01-13 13:41

val loc = Locale("en")
val sdf2 = SimpleDateFormat("yyyy-MMM-dd HH:mm", loc)
Log.d("LOG", sdf2.format(d)) // -> 2019-Jan-13 13:41

val d2:Date = sdf.parse("2018-12-12 17:13")
Log.d("LOG", d2.toString())
// ->  Wed Dec 12 17:13:00 GMT+01:00 2018

import java.text.SimpleDateFormat
import java.util.Date
import java.util.TimeZone
...
val sdf = SimpleDateFormat("yyyy-MM-dd HH:mm")
sdf.timeZone = TimeZone.getTimeZone("US/Hawaii")

val d:Date = sdf.parse("2018-12-12 17:13")
Log.d("LOG", d.toString())
// ->  Thu Dec 13 04:13:00 GMT+01:00 2018

android {
    ...
    defaultConfig {
        ...
        minSdkVersion 26
        ...
    }
    ...
}

import java.time.*

// current day in the default time zone
val ld1 : LocalDate = LocalDate.now()

// "Now" corresponds to different days in different
// time zones. The following allows us to specify a
// different time zone
val z2 = ZoneId.of("UTC+01")
val ld2 : LocalDate = LocalDate.now(z2)

val ld3 = LocalDate.of(2018, Month.MARCH, 27)
val ld4 = LocalDate.of(2018, 3, 27) // the same

val lt1 : LocalTime = LocalTime.now()
val lt2 = LocalTime.now(z2) // different time zone
val lt3 = LocalTime.of(23, 27, 55) // 23:27:55

val ldt1 = LocalDateTime.now()
val ldt2 = LocalDateTime.now(z2)
val ldt3 = LocalDateTime.of(2018, Month.APRIL, 23, 23, 44, 12)
// <- 2018-04-23T23:44:12

import java.time.*
import java.time.format.*

// Parse ISO-8601
val ld1 = LocalDate.parse("2019-02-13")

// Parse other formats. For the format specification,
// see API documentation of class DateTimeFormatter.
val formatter1 = DateTimeFormatter.ofPattern("yyyy MM dd")
val ld2 = LocalDate.parse("2019 02 13", formatter1)

val lt1 = LocalTime.parse("21:17:23")
val lt2 = LocalTime.parse("21:17:23.3734")

val formatter2 = DateTimeFormatter.ofPattern("HH|mm|ss")
val lt3 = LocalTime.parse("21|17|23", formatter2)

val ldt1 = LocalDateTime.parse("2019-02-13T21:17:23")
val ldt2 = LocalDateTime.parse("2019-02-13T21:17:23.3734")

val formatter3 = DateTimeFormatter.ofPattern("yyyy.MM.dd.HH.mm.ss")
val ldt3 = LocalTime.parse("2019.04.23.17.45.23", formatter3)

import android.util.Log
import java.time.*
import java.time.format.*

val s1 = LocalDate.now().format(
    DateTimeFormatter.ofPattern("yyyy|MM|dd"))
Log.d("LOG","s1 = ${s1}") // -> 2019|01|14

val s2 = LocalDate.now().format(
    DateTimeFormatter.ISO_LOCAL_DATE)
Log.d("LOG","s2 = ${s2}") // -> 2019-01-14

val s3 = LocalTime.now().format(
    DateTimeFormatter.ofPattern("HH mm ss"))
Log.d("LOG","s3 = ${s3}") // -> 14 46 20

val s4 = LocalTime.now().format(
    DateTimeFormatter.ISO_LOCAL_TIME)
Log.d("LOG","s4 = ${s4}") // 14:46:20.503

val s5 = LocalDateTime.now().format(
    DateTimeFormatter.ofPattern(
"yyyy MM dd - HH mm ss"))
Log.d("LOG","s5 = ${s5}") // -> 2019 01 14 - 14 46 20

val s6 = LocalDateTime.now().format(
    DateTimeFormatter.ISO_LOCAL_DATE_TIME)
Log.d("LOG","s6 = ${s6}") // -> 2019-01-14T14:46:20.505

import java.time.*
import java.time.temporal.*

val ld = LocalDate.now()
val lt = LocalTime.now()
val ldt = LocalDateTime.now()

val ld2 = ld.minusDays(7L)
val ld3 = ld.plusWeeks(2L)
val ld4 = ld.with(ChronoField.MONTH_OF_YEAR, 11L)

val lt2 = lt.plus(Duration.of(2L, ChronoUnit.SECONDS))
val lt3 = lt.plusSeconds(2L) // same

val ldt2 = ldt.plusWeeks(2L).minusHours(2L)

import java.time.*

val ldt : LocalDateTime = ...
val secs = ldt.toEpochSecond(ZoneOffset.of("+01:00"))

import java.time.*

val inz1 = Instant.now() // default time zone

// Specify time zone
val inz2 = Instant.now(Clock.system(
      ZoneId.of("America/Buenos_Aires")))

val secondsSince1970 : Long = 1_000_000_000L
val nanoAdjustment : Long = 300_000_000 // 300ms
val inz3 = Instant.ofEpochSecond(
    secondsSince1970, nanoAdjustment)

// "Z" is UTC ("Zulu" time)

val inz4 = Instant.parse("2018-01-23T23:33:14.513Z")

// Uniform converter, for the ZonedDateTime class
// see below
val inz5 = Instant.from(ZonedDateTime.parse("2019-02-13T21:17:23+01:00[Europe/Paris]"))

import java.time.*
import java.time.format.DateTimeFormatter

// Get now ------------------------------------------

// System clock, default time zone
val ot1 = OffsetTime.now()
val odt1 = OffsetDateTime.now()

// Use a different clock
val clock:Clock = ...
val ot2 = OffsetTime.now(clock)
val odt2 = OffsetDateTime.now(clock)

// Use a different time zone
val ot3 = OffsetTime.now(
      ZoneId.of("America/Buenos_Aires"))
val odt3 = OffsetDateTime.now(
      ZoneId.of("America/Buenos_Aires"))

// From time details --------------------------------

val ot4 = OffsetTime.of(23, 17, 3, 500_000_000,
      ZoneOffset.of("-02:00"))
val odt4 = OffsetDateTime.of(
      1985, 4, 23,            // 19685-04-23
      23, 17, 3, 500_000_000, // 23:17:03.5
      ZoneOffset.of("+02:00"))

// Parsed -------------------------------------------

val ot5 = OffsetTime.parse("16:15:30+01:00")
val odt5 = OffsetDateTime.parse("2007-12-03T17:15:30-08:00")
val ot6 = OffsetTime.parse("16 15 +00:00",
      DateTimeFormatter.ofPattern("HH mm XXX"))
val odt6 = OffsetDateTime.parse("20181115 - 231644 +02:00",
      DateTimeFormatter.ofPattern("yyyyMMdd - HHmmss XXX"))

// From other objects -------------------------------

val lt = LocalTime.parse("16:14:27.235")
val ld = LocalDate.parse("2018-05-24")
val inz = Instant.parse("2018-01-23T23:33:14.513Z")
val ot7 = OffsetTime.of(lt, ZoneOffset.of("+02:00"))
val odt7 = OffsetDateTime.of(ld, lt, ZoneOffset.of("+02:00"))
val ot8 = OffsetTime.ofInstant(inz, ZoneId.of("America/Buenos_Aires"))

val odt8 = OffsetDateTime.ofInstant(inz, ZoneId.of("America/Buenos_Aires"))

val zdt = ZonedDateTime.of( // see below
      2018, 2, 27,          // 2018-02-27
      23, 27, 33, 0,        // 23:27:33.0
      ZoneId.of("Pacific/Tahiti"))
val odt9 = zdt.toOffsetDateTime()

// uniform converter
val ot10 = OffsetTime.from(zdt)
val odt10 = OffsetDateTime.from(zdt)

import java.time.*

val ot = OffsetTime.parse("16:15:30+01:00")
val lt : LocalTime = ot.toLocalTime()

val odt = OffsetDateTime.parse("2007-12-03T17:15:30-08:00")
val ldt : LocalDateTime = odt.toLocalDateTime()
val lt2 : LocalTime = odt.toLocalTime()
val ld2 : LocalDate = odt.toLocalDate()
val ot2 : OffsetTime = odt.toOffsetTime()

val zdt : ZonedDateTime = odt.toZonedDateTime()
// see below for class ZonedDateTime

import java.time.*

// Get "now" using the system clock and the default
// time zone from your operating system.
val zdt1 = ZonedDateTime.now()

// Get "now" using a time zone. To list all available
// predefined zone IDs, try
//     Log.d("LOG", ZoneId.getAvailableZoneIds().
//                 joinToString { it + "\n" })
val z2 = ZoneId.of("UTC+01")
val zdt2 = ZonedDateTime.now(z2)

// Get "now" using an instance of Clock
val clock3 = Clock.systemUTC()
val zdt3 = ZonedDateTime.now(clock3)

import java.time.*

val z4 = ZoneId.of("Pacific/Tahiti")
val zdt4 = ZonedDateTime.of(
      2018, 2, 27,            // 2018-02-27
      23, 27, 33, 0,          // 23:27:33.0
      z4)
// The 7th par is nanoseconds, so for
// 23:27:33.5 you have to enter
// 500_000_000 here

val localDate = LocalDate.parse("2018-02-27")
val localTime = LocalTime.parse("23:44:55")
val zdt5 = ZonedDateTime.of(localDate, localTime,
      ZoneId.of("America/Buenos_Aires"))

val ldt = LocalDateTime.parse("2018-02-27T23:44:55.3")
val zdt6 = ZonedDateTime.of(ldt,
      ZoneId.of("America/Buenos_Aires"))

val inz = Instant.parse("2018-01-23T23:33:14.513Z")
val zdt7 = ZonedDateTime.ofInstant(inz,
      ZoneId.of("America/Buenos_Aires"))

val zdt8 = ZonedDateTime.parse(
      "2018-01-23T23:33:14Z[America/Buenos_Aires]")

import java.time.*
import java.time.format.DateTimeFormatter

val zdt1 = ZonedDateTime.parse(
      "2007-12-03T10:15:30+01:00[Europe/Paris]")

val formatter = DateTimeFormatter.ofPattern(
    "HH:mm:ss.SSS")
// See DateTimeFormatter API docs for more options
val str = zdt1.format(formatter)

import java.time.*

val ldt = LocalDateTime.parse("2018-02-27T23:44:55.3")
val zdt = ZonedDateTime.of(ldt,
      ZoneId.of("America/Buenos_Aires"))

val ldt2 = zdt.toLocalTime()

import java.time.*
import java.time.temporal.ChronoUnit

val ldt1 = LocalDateTime.parse("2018-01-23T17:23:00")
val ldt2 = LocalDateTime.parse("2018-01-24T16:13:10")
val ldt3 = LocalDateTime.parse("2020-01-24T16:13:10")

// Getting a duration: ------------------------------

val d1 = Duration.between(ldt1, ldt2)
// Note: this works also for Instant and ZonedDateTime

// objects

val d2 = Duration.of(27L, ChronoUnit.HOURS) // 27hours

val d3 = Duration.ZERO.
             plusDays(3L).
             plusHours(4L).
             minusMinutes(78L)

val d4 = Duration.parse("P2DT3H4M")
// <- 2 days, 3 hours, 4 minutes
// For more specifiers, see the API documentation
// of Duration.parse()

// Getting a period: --------------------------------

val ld1 = LocalDate.parse("2018-04-23")
val ld2 = LocalDate.parse("2018-08-16")

val p1 = Period.between(ld1, ld2)
// Note, end date not inclusive

val p2 = Period.of(2, 3, -1)

// <- 2 years + 3 months - 1 day

val p3 = Period.parse("P1Y2M-3D")
// <- 1 year + 2 months - 3 days
// For more specifiers, see the API documentation
// of Period.parse()

import java.time.*

// Duration operations: ------------------------------

val d = Duration.parse("P2DT3H4M")
// <- 2 days, 3 hours, 4 minutes

val d2 = d.plusDays(3L)
// also:  .minusDays(33L)
// or     .plusHours(2L)    or  .minusHours(1L)
// or     .plusMinutes(77L) or  .minusMinutes(7L)
// or     .plusSeconds(23L) or  .minusSeconds(5L)
// or     .plusMillis(11L)  or  .minusMillis(55L)
// or     .plusNanos(1000L) or  .minusNanos(5_000_000L)

val d3 = d.abs()          // make positive
val d4 = d.negated()      // swap sign
val d5 = d.multipliedBy(3L)   // three times as long
val d6 = d.dividedBy(2L)      // half as long

// Period operations: --------------------------------

val p = Period.of(2, 3, -1)
// <- 2 years + 3 months - 1 day

val p2 = p.normalized()

// <- possibly adjusts the year to make the month lie
// inside [-11;+11]

val p3 = p.negated()

val p4 = p.minusYears(11L)
// also:  .plusYears(3L)
// or     .minusMonths(4L) or  .plusMonths(2L)
// or     .minusDays(40L)  or  .plusDays(5L)

val p5 = p.multipliedBy(5) // 5 times as long

import java.time.*

val d = Duration.parse("P2DT3H4M")

val p = Period.of(2, 3, -1)
// <- 2 years + 3 months - 1 day

val ld = LocalDate.parse("2018-04-23")
val lt = LocalTime.parse("17:13:12")
val ldt = LocalDateTime.of(ld, lt)
val zdt = ZonedDateTime.parse(
      "2007-12-03T10:15:30+01:00[Europe/Paris]")
val inz = Instant.parse("2018-01-23T23:33:14.513Z")

// ---- Using a LocalDate
val ld2 = ld.plus(p)  // or .minus(p)
// val ld3 = ld.plus(d) // -> exception
// val ld4 = ld.minus(d) // -> exception

// ---- Using a LocalTime

val lt2 = lt.plus(d)  // or .minus(d)
// val lt3 = lt.minus(p) // -> exception
// val lt4 = lt.plus(p) // -> exception

// ---- Using a LocalDateTime
val ldt2 = ldt.plus(d)  // or .minus(d)
val ldt3 = ldt.plus(p)  // or .minus(p)

// ---- Using a ZonedDateTime
val zdt2 = zdt.plus(d)  // or .minus(d)
val zdt3 = zdt.plus(p)  // or .minus(p)

// ---- Using an Instant
val inz2 = inz.plus(d)  // or .minus(d)
// val inz3 = inz.minus(p) // -> exception
// val inz4 = inz.plus(p) // -> exception

import java.time.*

val clock : Clock = ...
val ldt = LocalDateTime.now(clock)
val zdt = ZonedDateTime.now(clock)
val inz = Instant.now(clock)

import java.time.*

val myClock = object : Clock() {
    override fun withZone(zone: ZoneId?): Clock {
        // Supposed to return a copy of this clock
        // with a different time zone
        return this
    }

    override fun getZone(): ZoneId {
        // Supposed to return the zone ID
        return ZoneId.of("Z")
    }

    override fun instant(): Instant {
        // This is the engine of the clock. It must
        // provide an Instant
        return Instant.parse("2018-01-23T23:33:14Z")
    }
}

... use myClock

import java.time.*

val myClock = ClockTwiceAsFast()
Log.d("LOG", LocalDateTime.now(myClock).format(
      DateTimeFormatter.ISO_LOCAL_DATE_TIME))
Thread.sleep(1000L)
Log.d("LOG", LocalDateTime.now(myClock).format(
      DateTimeFormatter.ISO_LOCAL_DATE_TIME))

import java.io.File

// We are inside an Activity or other Context!
val dataDir:File = getFilesDir()

dataDir.resolve("a.txt").takeIf{ !it.exists() }.appendText("Hello World A")
dataDir.resolve("b.txt").takeIf{ !it.exists() }.appendText("Hello World B")
File(dataDir,"dir1").mkdirs()dataDir.resolve("dir1").resolve("a.txt").
    takeIf{ !it.exists() }.appendText("Hello World dir1-A")

val someDir:File = ...

val file:File = someDir.resolve("fileName")

dataDir.walk().maxDepth(1).forEach { file ->
    Log.d("LOG", file.toString())
}

/data/user/0/multipi.pspaeth.de.multipi/files
/data/user/0/multipi.pspaeth.de.multipi/files/instant-run
/data/user/0/multipi.pspaeth.de.multipi/files/a.txt
/data/user/0/multipi.pspaeth.de.multipi/files/b.txt
/data/user/0/multipi.pspaeth.de.multipi/files/dirs1
/data/user/0/multipi.pspaeth.de.multipi/files/dir1

dataDir.walk().filter { it.isFile() }.forEach {
    file ->
    Log.d("LOG", file.toString())
}

dataDir.walk().filter { it.endsWith(".txt") }.
forEach {
    file ->
    Log.d("LOG", file.toString())
}

dataDir.walk().filter {
      it.name.matches(".*invoice\\d\\d.*\\.txt")
}.forEach {
    file ->
    Log.d("LOG", file.toString())
}

val file = dataDir.resolve("a.txt")
// or any other file

// Write to the file
file.writeText("In the house, there was no light")

// Append to the file
file.appendText("\nIn the house, there was no light")

val file = dataDir.resolve("a.txt")
val bytes = byteArrayOf(27, 34, 13, 47, 50)

// Write to the file
file.writeBytes(bytes)

// Append to the file
file.appendBytes(bytes)

val file = dataDir.resolve("a.txt")
val fileText:String = file.readText()

val file = dataDir.resolve("a.txt")
val fileText:String = file.readText(
      Charsets.ISO_8859_1)

val file = dataDir.resolve("a.txt")
val fileBytes:ByteArray = file.readBytes()

val file = dataDir.resolve("a.txt")

val allLines = file.readLines()
allLines.forEach { ln ->
  // do something with the line (a String)
}

val file = dataDir.resolve("a.txt")

// Only API level > 25
file.bufferedReader.use {
    it.lines().forEach { ln ->
        // do something with the line (a String)
    }
}

import java.io.File
...

val file = dataDir.resolve("a.txt")

// Buffer size implementation dependent
file.forEachBlock{ buffer:ByteArray, bytesRead:Int ->
    // do something with the buffer
}

// Or, if you want to prescribe the buffer size
file.forEachBlock(512) { buffer, bytesRead ->
    // do something with the buffer

}

import java.io.File
...

val file:File = ...
val wasDeleted:Boolean = file.delete()

import java.io.File
...

val file:File = ...
val wasDeleted:Boolean = file.deleteRecursively()

import java.io.File
...

val file:File = ...
file.deleteOnExit()

import java.io.File
...

val prefix = "tmpFile"
val suffix = ".tmp"
val tmpFile:File = File.createTempFile(prefix, suffix)
tmpFile.deleteOnExit()

... use tmpFile

import java.io.File
...

val file1:File = ...
val file2:File = ...

f1.copyTo(f2)       // f2 must not exist
f1.copyTo(f2, true) // overwrite if necessary

// To fine-tune performance, you can tweak the
// buffer size
f1.copyTo(f2, bufferSize = 4096)

import java.io.File
...

val dir1:File = ...
val dir2:File = ...

f1.copyRecursively(f2)       // f2 must not exist
f1.copyRecursively(f2, true) // overwrite if necessary

// To fine-tune error handling, you can add a handler.
// Otherwise an IOException gets thrown.
f1.copyRecursively(f2, onError = {
    file:File, ioException:IOException ->
    // do something.

    // What to do now? Just skip this file, or
    // terminate the complete function?
    OnErrorAction.SKIP // or .TERMINATE
})

import java.io.File
...

val file1:File = ...
val file2:File = ...

file1.renameTo(file2)

import java.io.File
import java.util.Date
...

val file = dataDir.resolve("a.txt")
val log = { msg:String -> Log.d("LOG", msg) }

log("Name: " + file.name)
log("The file exists: " + file.exists())
log("You can read the file: " + file.canRead())
log("You can write to the file: " + file.canWrite())
log("Is a directory: " + file.isDirectory())
log("Is a real file: " + file.isFile())
log("Last modified: " + Date(file.lastModified()))
log("Length: " + file.length())

import java.net.URL
import kotlin.concurrent.thread

thread {
    val contents:String =
      URL("http://www.example.com/something.txt").
      readText()

    val isoContents =
      URL("http://www.example.com/something.txt").
      readText(Charsets.ISO_8859_1)

    val img:ByteArray =
      URL("http://www.example.com/somepic.jpg").
      readBytes()
}

import android.util.Log

open class MyBase(val baseProp:Int)
class MyClass(var prop1:Int) :
      java.io.Serializable, MyBase(13) {
    var prop2:String
        get() = "Hi"
        set(value) { /* ignore */ }

    init {
        Log.d("LOG", "Hello from init")
    }

    fun function(i:Int):Int {
        return prop1 * i
    }
}

val instance = MyClass(42)

val clazz = MyClass::class

// We can also get it from instances
val clazz = instance::class

import android.util.Log
import kotlin.reflect.*
import kotlin.reflect.full.*

Log.d("LOG", "**** constructors")
clazz.constructors.forEach { c ->
    Log.d("LOG", c.toString())
}

// show only our own properties
Log.d("LOG", "**** declaredMemberProperties") clazz.declaredMemberProperties.forEach { p ->
    Log.d("LOG", p.toString())
}

// show also inherited properties
Log.d("LOG", "**** memberProperties")
clazz.memberProperties.forEach { p ->

    Log.d("LOG", p.toString())
}

// show only our own functions
Log.d("LOG", "**** declaredFunctions")
clazz.declaredFunctions.forEach { f ->
    Log.d("LOG", f.toString())
}

// show also inherited functions
Log.d("LOG", "**** functions")
clazz.functions.forEach { f ->
    Log.d("LOG", f.toString())
}

val p1: KProperty1<out MyClass, Any?> =
    clazz.declaredMemberProperties.find {
          it.name == "prop1" }!!
val f1: KFunction<*> =
    clazz.declaredFunctions.find {
          it.name == "function" }!!

...
val instance = MyClass(42)

val p1: KProperty1<out MyClass, Any?>? =
    clazz.declaredMemberProperties.find {
        it.name == "prop1" }!!
val p1Mutable: KMutableProperty1<out MyClass, Any?> =
    p1 as KMutableProperty1

// getting
val prop1Val = p1.getter.call(instance)

// setting
p1Mutable.setter.call(instance, 55)

// invoking
val f1: KFunction<*> =
    clazz.declaredFunctions.find {

          it.name == "function" }!!
val res = f1.call(instance, 44) as Int

// Only directly declared superclasses and interfaces
clazz.superclasses.forEach { sc ->
    Log.d("LOG", sc.toString())
}

// All superclasses and interfaces
clazz.allSuperclasses.forEach { sc ->
    Log.d("LOG", sc.toString())
}

val clazz : KClass = ...

// If we have a no-arg primary constructor
val instance1 = clazz.createInstance()

// Otherwise for the primary constructor
val instance2 = clazz.primaryConstructor?.call(
    [parameters]
)

// Otherwise
val instance3 = clazz.constructors.
      find { [criterion] }!!.
    call( [parameters] )

val patStr = "^\\w{3}$"     // exactly 3 word chars
val patStr2 = """^\w{3}$""" // the same

val re = Regex("^\\w{3}$")     // exactly 3 word chars

val matches1 = "Hello".matches(re) // -> false
val matches2 = "abc".matches(re)   // -> true

"Hello" % ".*ll.*"

"Hello".matches(Regex(".*ll.*"))

Regex(pattern:String, option:RegexOption)
Regex(pattern:String, options:Set<RegexOption>)

val re1 = Regex("^A(/|_)\\d{4}$")

// This is the same:
val ENDS = "$"
val re2 = Regex("""
    ^       # begins with
    A       # an "A"
    (/|_)   # a "/" or a "_"
    \d{4}   # 4 digits
    $ENDS   # ends here
""", RegexOption.COMMENTS)

val re = Regex("\\|")
// <- use "\" escape to get a "|" as a literal

val s = "ABC|12345|_0_1"
val split: List<String> = s.split(re)
// -> "ABC", "12345", "_0_1"

// limit to at most 37 splits
val split37 = s.split(re, limit = 37)

// a number pattern
val re = Regex("""
    -?  # possibly a "-"
    \d+ # one or more digits
    (
      \.   # a dot
      \d+  # one or more digits
    )?     # possibly
 """, RegexOption.COMMENTS)

val s = "x = 37.5, y = 3.14, z = -100.0"

val firstNumber:MatchResult? = re.find(s)
// start at a certain index instead:
// val firstNumber = re.find(s, 5)

val notFound = firstNumber == null
firstNumber?.run {
    val num = groupValues[0]

    // do something with num...
}

val allNumbers:Sequence<MatchResult> = re.findAll(s)
allNumbers.forEach { mr ->
    val num = mr.groupValues[0]
    // do something with num...
}

val re = Regex("""
    (
      (
        -?  # possibly a "-"
        \d+ # one or more digits
      )
      (
        \.   # a dot
        (
          \d+  # one or more digits
        )
      )?     # possibly
    )
 """, RegexOption.COMMENTS)

// The pattern from the last listing compressed
val re = Regex("""((-?\d+)(\.(\d+))?)""")

val s = "x = 37.5, y = 3.14, z = -100.0"

val firstNumber:MatchResult? = re.find(s)

val notFound = firstNumber == null
firstNumber?.run {
    val (num, nf, f1, f2) = destructured

    // <- "37.5", "37", ".5", "5"
    // the same:
    //   val num = groupValues[1]
    //   val nf = groupValues[2]
    //   val f1 = groupValues[3]
    //   val f2 = groupValues[4]
    val wholeMatch = groupValues[0]  // 37.5
    // ...
}

val allNumbers:Sequence<MatchResult> = re.findAll(s)
allNumbers.forEach { mr ->
    val (num, nf, f1, f2) = mr.destructured
    // the same:
    //   val num = mr.groupValues[1]
    //   val nf = mr.groupValues[2]
    //   val f1 = mr.groupValues[3]
    //   val f2 = mr.groupValues[4]
    val wholeMatch = mr.groupValues[0]
    // ... wholeMatch is: 37.5, 3.14 or -100.0
    // ... num is: 37.5, 3.14 or -100.0
    // ... nf is: 37, 3, -100
    // ... f1 is: .5, .14, .0
    // ... f2 is 5, 14, 0
}

// again the number pattern:
val re = Regex("""((-?\d+)(\.(\d+))?)""")

val s = "x = 37.5, y = 3.14, z = -100.0"

// replace the first number by 22.22
val s2 = re.replaceFirst(s, "22.22")
// -> "x = 22.22, y = 3.14, z = -100.0"

// replace all numbers by 22.22
val s3 = re.replace(s, "22.22")
// -> "x = 22.22, y = 22.22, z = 22.22"

// again the number pattern:
val re = Regex("""((-?\d+)(\.(\d+))?)""")

val s = "x = 37.5, y = 3.14, z = -100.0"

// double all numbers
val s2 = re.replace(s, { mr:MatchResult ->
    val theNum = mr.groupValues[1].toDouble()
    (theNum * 2).toString() // <- replacement
})
// -> "x = 75.0, y = 6.28, z = -200.0"

// zero all fractions
val s3 = re.replace(s, { mr:MatchResult ->

    val (num, nf, f1, f2) = mr.destructured

    nf + ".0" // <- replacement
})
// -> "x = 37.0, y = 3.0, z = -100.0"