datastructures.kt

package com.syafdia.github.dummykotlin.datastructure

sealed class LinkedList<out T> {

    fun filter(f: (v: T) -> Boolean): LinkedList<T> {
        return when (this) {
            is Nil -> Nil
            is Node<T> -> when (f(head)) {
                true -> Node(head, tail.filter(f))
                false -> tail.filter(f)
            }
        }
    }

    fun <U> map(f: (v: T) -> U): LinkedList<U> {
        return when (this) {
            is Nil -> Nil
            is Node<T> -> Node(f(head), tail.map(f))
        }
    }

    fun <U> reduce(initial: U, f: (acc: U, v: T) -> U): U {
        return when (this) {
            is Nil -> initial
            is Node<T> -> tail.reduce(f(initial, head), f)
        }
    }

    fun size(): Int {
        return reduce(0) { total, _ ->
            total + 1
        }
    }

    override fun toString(): String {
        return when (this) {
            is Nil -> "Nil"
            is Node<T> -> "($head, $tail)"
        }
    }

    object Nil : LinkedList<Nothing>()

    data class Node<T>(
            val head: T,
            val tail: LinkedList<T> = Nil
    ): LinkedList<T>()

    companion object {

        fun <T> of(
                head: T,
                tail: LinkedList<T> = Nil
        ): LinkedList<T> {
            return Node(head, tail)
        }
    }
}



fun runDataStructure() {
    val lList = LinkedList.of(
            head = "B",
            tail = LinkedList.of(
                    head = "C",
                    tail = LinkedList.of(
                            head = "D"
                    )
            )
    )

    assertEquals(3, lList.size())
    assertEquals(
            "> AxCxDx",
            LinkedList.Node("A", lList)
                    .map { it + "x" }
                    .filter { !it.contains("Bx") }
                    .reduce("> ") { acc, v: String -> acc + v }
    )

}

fun <T> assertEquals(a: T, b: T) {
    if (a != b) {
        throw Exception("$a and $b is not equals")
    }
}