structure.map {data -> analyse(data, structure)}.zip(structure.map{ it.reference}).filter{ it.first.isNotEmpty() }.forEach(::println)

val identical = structure.filter {
        data.size == it.size &&
        it != data &&
        it.hash == data.hash
    }.map { data ->
        Record(data, EnumSet.of(Similarity.IDENTICAL))
    }

So I want to minimize both the necessary calculations as well as the traversals, creating no intermediate data structures.

myThing
  .flatTap { element: String -> IO { log(element) } }
  .flatMap { element: String -> continueProgram(element) }

also

fun foo(b: Bar) : Type? {
    val filtered = b.listProp.filter { // Condition } 
    if (filtered.isEmpty()) {
        // Create and post analytics event
        return null
    }

   val unique = filtered.singleOrNull() ?: run {
        // Create different analytics event
        return null
   }
    ... // More operations that each can fail and should post an analytics event

   return t
}

fun <B> foldRightViaFoldLeft(identity: B, f: (A) -> (B) -> B): B =
        this.reverse().foldLeft(identity) { x -> { y -> f(y)(x) } }

fun <A, B> foldRight2(xs: List<A>, z: B, f: (A, B) -> B): B = foldLeft(xs, {y : B -> y}) { g, a -> {x : B -> f(a, g(x))}}(z)

inline

fun myScopedIntFunction(block: MyCustomIntFunctionScope): Int {
  return block.receive()
}

fun interface MyCustomIntFunctionScope {
  fun receive(): Int

  fun Int.plusThree(): Int {
    return this + 3
  }
}

fun main(){
  myScopedIntFunction {
      1.plusThree()  //won't compile
  }
  object: MyCustomIntFunctionScope {
      override fun receive(): Int {
          return 1.plusThree()
      }
  }.receive()      //works
}

fun manyParamFun(p1: Int, p2: String, p3: List<String>): String = ...
val newFun  = bind(::manyParamFun, p1=5) // to get (String, List<String>) -> String function

fun newFun(p2: String, p3: List<String>): String = manyParamFun(5, p2, p3)

fun FooMapper(netFoo: NetFoo, quaxMapper: (NetQuax) -> Quax): Foo {
	val meh = MehMapper(foo.meh, quaxMapper)
	val bar = BarMapper(foo.bar)
	return Foo(meh, bar)
}

fun MehMapper(netMeh: NetMeh, quaxMapper: (NetQuax) -> Quax): Meh {
	quaxMapper(netMeh.quax)
	...
}

I have just started looking at Kotlin, I have been using F# on .NET for a while now and I am liking Kotlin. I am missing pipe operator in Kotlin though, is there any plan to bring the pipe operator to Kotlin?

sealed class

when

sealed class Resource {
    data class Note(val content: String?) : Resource()
    data class Tag(val name: String?) : Resource()
    data class Character(val name: String?) : Resource()
    data class Address(val latitude: Float?, val longitude: Float?) : Resource()
}

fun pullResource(): List<Resource> = TODO()

fun Resource.toDecrypt(): Resource = when (this) {
    is Resource.Note -> TODO()
    is Resource.Tag -> TODO()
    is Resource.Character -> TODO()
    is Resource.Address -> TODO()
}

fun Resource.checkLegal(): Boolean = when (this) {
    is Resource.Note -> content != null
    is Resource.Tag -> name != null
    is Resource.Character -> name != null
    is Resource.Address -> latitude != null && longitude != null
}

inline fun <reified T> List<T>.insert() {
    when (T::class) {
        Resource.Note::class -> TODO("batch insert into the Note Entity")
        Resource.Tag::class -> TODO("batch insert into the Tag Entity")
        Resource.Character::class -> TODO("batch insert into the Character Entity")
        Resource.Address::class -> TODO("batch insert into the Address Entity")
    }
}

fun insertDB(l: List<Resource>) {
    fun <T : Resource> List<Resource>.cast(): List<T> = this as List<T>

    l.groupBy {
        when (it) {
            is Resource.Note -> "Note"
            is Resource.Tag -> "Tag"
            is Resource.Character -> "Character"
            is Resource.Address -> "Address"
        }
    }.let {
        it["Note"]?.cast<Resource.Note>()?.insert()
        it["Tag"]?.cast<Resource.Tag>()?.insert()
        it["Character"]?.cast<Resource.Character>()?.insert()
        it["Address"]?.cast<Resource.Address>()?.insert()
    }
}

fun main() {
    pullResource().map(Resource::toDecrypt).filter(Resource::checkLegal).let(::insertDB)
}

Result

fun one(): Result<SomeType> {
    return two()
        .map { someOtherType ->
            three(someOtherType)
                .map { someType -> 
                    doSomethingWithSomeType(someType)
                    someType
}

fun two(): Result<SomeOtherType> { ... }
fun three(someOtherType: SomeOtherType): Result<SomeOtherOtherType> { ... }

Result<Result<SomeType>>

Result<SomeType>

Flow

Either

fold