$ curl -s "https://get.sdkman.io" | bash
$ source "$HOME/.sdkman/bin/sdkman-init.sh"
$ sdk version
SDKMAN 5.7.3+337

$ sdk install kotlin
Downloading: kotlin 1.3.21
In progress...
##################################### 100,0%
Installing: kotlin 1.3.21
Done installing!
Setting kotlin 1.3.21 as default.

$ sdk install java
Downloading: java 11.0.2-open
In progress...
##################################### 100,0%
Repackaging Java 11.0.2-open...
Done repackaging...
Installing: java 11.0.2-open
Done installing!
Setting java 11.0.2-open as default.

$ sdk install kscript
$ sdk install gradle
$ sdk install visualvm

#!/usr/bin/env kscript

val conf = "Ruby on Ice"
println("Hello everyone at $conf!")

$ kscript kscript-hello.kts 
Hello everyone at Ruby on Ice!

$ sdk install micronaut
$ mn --version
| Micronaut Version: 1.0.4
| JVM Version: 1.8.0_191

var conference = "Ruby on Ice"
println("Hello world from ${conference} ${java.time.Year.now()}")

conference = "Ruby on Ice"
puts "Hello world from #{conference} #{Time.now.year}"

var placesWeAreAt = mapOf(
    "Tegernsee" to true,
    "The Moon" to false
)
placesWeAreAt.forEach { (place, areWeThere) ->
    println("Are we at $place? $areWeThere")
}

places_we_are_at = {
  "Tegernsee" => true,
  "The Moon" => false
}.freeze
places_we_are_at.each { |place, are_we_there|
  puts "Are we at #{place}? #{are_we_there}"
}

var placesWeAreAt = mapOf(
    "Tegernsee" to true,
    "The Moon" to false
)
placesWeAreAt.forEach { (place, areWeThere) ->
    println("Are we at $place? $areWeThere")
}

places_we_are_at = {
  "Tegernsee" => true,
  "The Moon" => false
}
places_we_are_at.each { |place, are_we_there|
  puts "Are we at #{place}? #{are_we_there}"
}

fun giveMe(number: Int, str: String): String {
    return str.repeat(number)
}

giveMe(5, "hello")

def give_me(number, str)
  str * number
end  

give_me(5, "hello")

fun myTimes(howMany: Int, block: (Int) -> Unit) {
    var current = 0
    while (current < howMany) {
        block.invoke(current)
        current += 1
    }
}

myTimes(10) { n -> println("Yay $n!") }

def my_times(how_many, &block)
  current = 0
  while (current < how_many)
    block.call(current)
    current += 1
  end
end

my_times(10) { |n| puts("Yay #{n}!") }

package onice

class Foo(
    val arg1: String = "immutable arg default", /* default for arg1 */
    var arg2: String = "mutable arg default",
    var arg3: String // No default
) {
    fun concatenateAll(): String { return listOf(arg1, arg2, arg3).joinToString("; ") }
}

println(Foo(arg3 = "arg3").concatenateAll())

module OnIce
  class Foo
    attr_reader   :arg1
    attr_accessor :arg2
    attr_accessor :arg3

    def initialize(arg1: "immutable arg default", arg2: "mutable arg default", arg3:)
      @arg1, @arg2, @arg3 = arg1, arg2, arg3
    end

    def concatenate_all; [arg1, arg2, arg3].join("; "); end
  end
end

puts OnIce::Foo.new(arg3: "arg3").concatenate_all

val greeter = { str: String -> "Welcome, $str" }

greeter("Sun!")

greeter = lambda { |str| "Welcome, #{str}" }

greeter.("Sun!")

val isEven =
    if (number % 2 == 0) {
        "is even"
    } else {
        "is not even"
    }

is_even =
  if (number.even?)
    "is even"
  else
    "is not even"
  end

val result = when (obj) {
    1 -> "one"
    "two" -> "two"
    else -> "have no idea"
}

result = case obj
when 1
  "one"
when "two"
  "two"
else
  "have no idea"
end

val nullString: String? = null
val niceString = "nice!"
val safeCall = nullString?.contains("Hello")
val string = nullString ?: niceString

nil_string = nil
nice_string = "nice!"
safe_call = nil_string&.include?("Hello")
string = nil_string || nice_string

val numbers = (1..10).toList().toTypedArray()

fun many_arguments(vararg args: Any) {
    println(args.toList())
}

many_arguments(*numbers)

numbers = (1..10).to_a

def many_arguments(*args)
  puts args
end

many_arguments(*numbers)

interface User {
    fun name(): String
}

class RubyOnIce {
    fun hello(): String { return "Hello, world!" }
    fun hello(user: User): String { return "Hello there, ${user.name()}!" }
}

object RubyOnIceTest : Spek({
    val subject by memoized { RubyOnIce() }

    describe("hello") {
        it("greets everyone") {
            assertThat(subject.hello()).isEqualTo("Hello, world!")
        }

        context("when a user is supplied") {
            val name = "Ivo"
            val user = mock<User> { on { name() } doReturn(name) }

            it("greets only the supplied user") {
                assertThat(subject.hello(user)).isEqualTo("Hello there, Ivo!")
            }
        }
    }
})

createHTML().html {
    head {
        title { +"Hello there!" }
    }
    body {
        ul {
            li { +"One item" }
            li { +"Another item" }
        }
    }
}

class Foo
  attr_reader :ruby_on_ice
  attr_reader :conference

  def initialize(ruby_on_ice:, conference:)
    @ruby_on_ice = ruby_on_ice
    @conference = conference
  end

  def ==(other)
    ruby_on_ice == other.ruby_on_ice &&
      conference == other.conference
  end

  def to_s
    "Foo ruby_on_ice=#{ruby_on_ice} ..."
  end
end

def check(user, password)
  # ...
end

user = "ivo"
password = "trustno1"

check(password, user)

fun check(user: String, password: String) {
  // ...
}

val user = "ivo"
val password = "trustno1"

check(password, user)