Kotlin Simple

Author: Edwin Wu

Kotlinlang/src/examples/callableReferences/Composition_of_functions.kt

@@ -0,0 +1,24 @@
+package examples.callableReferences
+
+/**
+ * The composition function return a composition of two functions passed to it:
+ * compose(f, g) = f(g(*)).
+ * Now, you can apply it to callable references.
+ *
+ * @author Edwin.Wu
+ * @version 2018/2/3 上午11:26
+ * @since JDK1.8
+ */
+fun main(args: Array<String>) {
+    val oddLength = compose(::isOdd2, ::length)
+    val strings = listOf("a", "ab", "abc")
+
+    println(strings.filter(oddLength))
+}
+
+fun isOdd2(x: Int) = x % 2 != 0
+fun length(s: String) = s.length
+
+fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C {
+    return { x -> f(g(x)) }
+}

Kotlinlang/src/examples/callableReferences/Reference_to_a_function.kt

@@ -0,0 +1,18 @@
+package examples.callableReferences
+
+/**
+ * "Callable References" or "Feature Literals", i.e. an ability to pass
+ * named functions or properties as values. Users often ask
+ * "I have a foo() function, how do I pass it as an argument?".
+ * The answer is: "you prefix it with a `::`".
+ * @author Edwin.Wu
+ * @version 2018/2/2 下午10:31
+ * @since JDK1.8
+ */
+fun main(args: Array<String>) {
+    val numbers = listOf(1, 2, 3)
+    val result = numbers.filter(::isOdd)
+    println(result)
+}
+
+fun isOdd(x: Int) = x % 2 != 0

Kotlinlang/src/examples/delegatedDroperties/Custom_delegate.kt

@@ -16,7 +16,7 @@ import kotlin.reflect.KProperty
 class Example {
     var p: String by Delegate()
 
-    override fun toString() = "Example"
+    override fun toString() = "Example Class"
 }
 
 class Delegate {
@@ -27,12 +27,14 @@ class Delegate {
     operator fun setValue(thisRef: Any?, prop: KProperty<*>, value: String) {
         println("$value has been assigned to ${prop.name} in $thisRef")
     }
+
+    override fun toString(): String {
+        return "Fuck BTC"
+    }
 }
 
 fun main(args: Array<String>){
     val e = Example()
     println(e)
     e.p = "NEW"
-
-    println(e.p)
 }

Kotlinlang/src/examples/delegatedDroperties/Lazy_property.kt

@@ -0,0 +1,27 @@
+package examples.delegatedDroperties
+
+/**
+ * Delegates.lazy() is a function that returns a delegate that implements a lazy property:
+ * the first call to get() executes the lambda expression passed to lazy() as an argument
+ * and remembers the result, subsequent calls to get() simply return the remembered result.
+ * If you want thread safety, use blockingLazy() instead: it guarantees that the values will
+ * be computed only in one thread, and that all threads will see the same value.
+ *
+ * @author Edwin.Wu
+ * @version 2018/2/2 下午4:24
+ * @since JDK1.8
+ */
+class LazySample {
+    val lazy: String by lazy {
+        println("computed!")
+        "my lazy"
+    }
+}
+
+fun main(args: Array<String>) {
+    val sample = LazySample()
+    println("lazy = ${sample.lazy}")
+    println("lazy = ${sample.lazy}")
+
+
+}

Kotlinlang/src/examples/delegatedDroperties/NotNull_property.kt

@@ -0,0 +1,31 @@
+package examples.delegatedDroperties
+
+import kotlin.properties.Delegates
+
+/**
+ * Users frequently ask what to do when you have a non-null var, but you don't have an
+ * appropriate value to assign to it in constructor (i.e. it must be assigned later)?
+ * You can't have an uninitialized non-abstract property in Kotlin. You could initialize it
+ * with null, but then you'd have to check every time you access it. Now you have a delegate
+ * to handle this. If you read from this property before writing to it, it throws an exception,
+ * after the first assignment it works as expected.
+ *
+ * @author Edwin.Wu
+ * @version 2018/2/2 下午10:19
+ * @since JDK1.8
+ */
+class User1 {
+    var name: String by Delegates.notNull()
+
+    fun init(name: String) {
+        this.name = name
+    }
+}
+
+fun main(args: Array<String>) {
+    val user = User1()
+    // user.name -> IllegalStateException
+    user.init("Carl")
+    println(user.name)
+}
+

Kotlinlang/src/examples/delegatedDroperties/Observable_property.kt

@@ -0,0 +1,24 @@
+package examples.delegatedDroperties
+
+import kotlin.properties.Delegates
+
+/**
+ * The observable() function takes two arguments: initial value and a handler for modifications.
+ * The handler gets called every time we assign to `name`, it has three parameters:
+ * a property being assigned to, the old value and the new one. If you want to be able to veto
+ * the assignment, use vetoable() instead of observable().
+ * @author Edwin.Wu
+ * @version 2018/2/2 下午10:14
+ * @since JDK1.8
+ */
+class User {
+    var name: String by Delegates.observable("no name") { _, old, new ->
+        println("$old - $new")
+    }
+}
+
+fun main(args: Array<String>) {
+    val user = User()
+    user.name = "Carl"
+
+}

Kotlinlang/src/examples/delegatedDroperties/Properties_in_map.kt

@@ -0,0 +1,25 @@
+package examples.delegatedDroperties
+
+/**
+ * Properties stored in a map. This comes up a lot in applications like parsing JSON
+ * or doing other "dynamic" stuff. Delegates take values from this map (by the string keys -
+ * names of properties). Of course, you can have var's as well,
+ * that will modify the map upon assignment (note that you'd need MutableMap instead of read-only Map).
+ *
+ * @author Edwin.Wu
+ * @version 2018/2/2 下午10:22
+ * @since JDK1.8
+ */
+class User2(val map: Map<String, Any?>) {
+    val name: String by map
+    val age: Int by map
+}
+
+fun main(args: Array<String>) {
+    val user = User2(mapOf(
+            "name" to "John Doe",
+            "age" to 25
+    ))
+
+    println("name =${user.name}, age =${user.age}")
+}

Kotlinlang/src/examples/longerExamples/99_Bottles_of_Beer.kt

@@ -0,0 +1,78 @@
+package examples.longerExamples
+
+/**
+ * This example implements the famous "99 Bottles of Beer" program
+ * See http://99-bottles-of-beer.net/
+ *
+ * The point is to print out a song with the following lyrics:
+ *
+ *     The "99 bottles of beer" song
+ *
+ *     99 bottles of beer on the wall, 99 bottles of beer.
+ *     Take one down, pass it around, 98 bottles of beer on the wall.
+ *
+ *     98 bottles of beer on the wall, 98 bottles of beer.
+ *     Take one down, pass it around, 97 bottles of beer on the wall.
+ *
+ *       ...
+ *
+ *     2 bottles of beer on the wall, 2 bottles of beer.
+ *     Take one down, pass it around, 1 bottle of beer on the wall.
+ *
+ *     1 bottle of beer on the wall, 1 bottle of beer.
+ *     Take one down, pass it around, no more bottles of beer on the wall.
+ *
+ *     No more bottles of beer on the wall, no more bottles of beer.
+ *     Go to the store and buy some more, 99 bottles of beer on the wall.
+ *
+ * Additionally, you can pass the desired initial number of bottles to use (rather than 99)
+ * as a command-line argument
+ *
+ * @author Edwin.Wu
+ * @version 2018/2/3 上午11:56
+ * @since JDK1.8
+ */
+fun main(args: Array<String>) {
+//    if (args.isEmpty()) {
+//        println(99)
+//    } else {
+//        printBottles(args[0].toInt())
+//    }
+
+    printBottles(5)
+}
+
+fun printBottles(bottleCount: Int) {
+    if (bottleCount <= 0) {
+        println("No bottles - no song")
+        return
+    }
+
+    println("The \"${bottlesOfBeer(bottleCount)}\" song\n")
+
+    var bottles = bottleCount
+    while (bottles > 0) {
+        var bottlesOfBeer = bottlesOfBeer(bottles)
+        print("$bottlesOfBeer on the wall, $bottlesOfBeer.\nTake one down, pass it around, ")
+        bottles--
+        println("${bottlesOfBeer(bottles)} on the wall.\n")
+    }
+    println("No more bottles of beer on the wall, no more bottles of beer.\n" +
+            "Go to the store and buy some more, ${bottlesOfBeer(bottleCount)} on the wall.")
+}
+
+fun bottlesOfBeer(count: Int): String =
+        when (count) {
+            0 -> "no more bottles"
+            1 -> "1 bottle"
+            else -> "$count bottles"
+        } + " of beer"
+
+/*
+ * An excerpt from the Standard Library
+ */
+
+
+// This is an extension property, i.e. a property that is defined for the
+// type Array<T>, but does not sit inside the class Array
+val <T> Array<T>.isEmpty: Boolean get() = size == 0