FunctorFilter.kt

package com.lenguyenthanh.functional

import arrow.core.None
import arrow.core.Option
import arrow.core.Some
import arrow.core.extensions.list.functorFilter.filterMap
import arrow.core.extensions.list.functorFilter.flattenOption
import arrow.core.toOption

/**
 * A combined `map` and `filter`. Filtering is handled via `Option`
 * instead of `Boolean` such that the output type `B` can be different than
 * the input type `A`.
 *
 * Example:
 * {{{
 * scala> import cats.implicits._
 * scala> val m: Map[Int, String] = Map(1 -> "one", 3 -> "three")
 * scala> val l: List[Int] = List(1, 2, 3, 4)
 * scala> def asString(i: Int): Option[String] = m.get(i)
 * scala> l.mapFilter(asString)
 * res0: List[String] = List(one, three)
 * }}}
 */

fun filterMapExample() {
    val m = mapOf(1 to "one", 3 to "three")
    val l = listOf(1, 2, 3, 4)
    fun asString(i: Int): Option<String> = m[i].toOption()
    val filtered = l.filterMap { asString(it) } // listOf("one", "three")
    println(filtered)
}
/**
 * Similar to [[mapFilter]] but uses a partial function instead of a function
 * that returns an `Option`.
 *
 * Example:
 * {{{
 * scala> import cats.implicits._
 * scala> val l: List[Int] = List(1, 2, 3, 4)
 * scala> FunctorFilter[List].collect(l){
 *      |   case 1 => "one"
 *      |   case 3 => "three"
 *      | }
 * res0: List[String] = List(one, three)
 * }}}
 */

// we dont have collect now

/**
 * "Flatten" out a structure by collapsing `Option`s.
 * Equivalent to using `mapFilter` with `identity`.
 *
 * Example:
 * {{{
 * scala> import cats.implicits._
 * scala> val l: List[Option[Int]] = List(Some(1), None, Some(3), None)
 * scala> l.flattenOption
 * res0: List[Int] = List(1, 3)
 * }}}
 */

fun flattenOptionExample() {
    val l = listOf(Some(1), None, Some(3), None)
    val flatten = l.flattenOption()
    println(flatten)
}

fun main() {
    filterMapExample()
    flattenOptionExample()
}