Value

Iterable

Option

Iterable

None

Iterable

Some

Either

Iterable

myMap.toPersistentMap().map { (key, value) -> ...}.fold { ... }

Iterable

Iterable

object PersistedMapFunctor

map

PersistentMap

arrow

./gradlew clean build

D:\dev\forks\arrow\modules\validation\arrow-validation\build\generated\source\kaptKotlin\main\extension\arrow\validation\refinedTypes\numeric\either\nonZero\EitherNonZero.kt: (18, 47): Type argument is not within its bounds: should be subtype of 'Number'

./gradlew clean build

PersistentMap

element

FunctorFilter

remove

filter

list.filter { it != element}

O(n)

O(1)

FunctorFilter

Eq

remove

FunctorFilter

O(n)

O(1)

PersistentMap

Kind<F, A>

Kind<ForPeristentMap, A>

==

removeIf

contains

FunctorFilter

Eq

==

Eq

arrow-core-data

core

PersistentMap

PersistentSet

PersistentList

PersistentMap

1. I’ll finish my port of persistent data structures to Kotlin in my own project

common

then I have to refactor the type hierarchy to align it with Arrow

null

<K, V>

null

interface

interface HashArrayMappedTrie<K, V> : Iterable<Tuple2<K, V>> {

    val isEmpty: Boolean
    val size: Int

    operator fun get(key: K): Option<out V>

    fun containsKey(key: K): Boolean

    fun put(key: K, value: V): HashArrayMappedTrie<K, V>

    fun remove(key: K): HashArrayMappedTrie<K, V>

    fun keysIterator(): Iterator<K>

    fun valuesIterator(): Iterator<V>
}

Option

MapK

core/arrow-persistent-collections

master

arrow-persistent-collections

modules

master

Foldable

FunctorFilter

MapK

k()

MapK

Map

PersistentMap

Map

modules/persistent/arrow-persistent-data-structures

@extension
interface PersistentMapFoldable<K, V> : Foldable<Tuple2<K, V>> {

  override fun <A, B> Kind<Tuple2<K, V>, A>.foldLeft(b: B, f: (B, A) -> B): B {
    TODO("not implemented")
  }

  override fun <A, B> Kind<Tuple2<K, V>, A>.foldRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B> {
    TODO("not implemented")
  }
}

MapK

with(intFold) {

      "Folding a list of ints" {
        forAll(Gen.list(<http://Gen.int|Gen.int>())) { ints ->
          fold(Int.monoid(), ints.k()) == ints.sum()
        }
      }
    }

@JvmName("orEmpty")
@Suppress(
        "UNCHECKED_CAST",
        "USELESS_CAST",
        "EXTENSION_SHADOWED_BY_MEMBER",
        "UNUSED_PARAMETER"
)
fun <K, V, A> orEmpty(arg0: Applicative<Tuple2<K, V>>, arg1: Monoid<A>): Tuple2<K, V, A> =
        arrow.core.Tuple2
   .foldable<K, V>()
   .orEmpty<A>(arg0, arg1) as arrow.core.Tuple2<K, V, A>

Foldable<Tuple2<K, V>>

forAll {}

"Should be able to use fold as a filter" {

    val result = listOf(1, 2, 3, 4).k().foldLeft(listOf<Int>()) { list, next ->
        if (next == 2) {
            list
        } else list.plus(next)
    }

    with(result) {
        forAll {
            result == listOf(0, 3, 4)
        }
    }

}

result

list(1, 3, 4)

FoldTest

Foldable

remove

with(result)

result shouldBe listOf(0, 3, 4)

Foldable

Monoid

compose

identity

fun <A> Kind<F, A>.remove(element: A): Kind<F, A> = foldLeft(???) { foldable, next ->
    if(element == next) {
      foldable
    } else foldable ??? next
  }

fun <A> Kind<F, A>.remove(element: A): Kind<F, A>

FunctorFilter

fun <A> Kind<F, A>.remove(element: A, monoid: Monoid<A>): Kind<F, A> = foldLeft(monoid.empty()) { foldable, next ->
    if(element == next) {
      foldable
    } else monoid.???
  }

combine

add

fun <A> Kind<F, A>.remove(element: A, MF: MonoidK<F>, MA: Monoid<A>): Kind<F, A> = MF.run {
    foldLeft(empty()) { acc, a ->
      if (a == element) {
        acc
      } else ???
    }
  }

Monoid<MonoidK<F>>

monoid.empty()

A

foldLeft

Kind<F, A>

Applicative

listOf()

listOf(1)

listOf(3)

listOf(4)

Monoid

emptyList() + listOf(1) + listOf(3) + listOf(4)

ListK.foldable().run { listOf(1, 2, 3, 4).k().remove(2) }

emptyList().combineK(listOf(1).combineK(listOf(3).combineK(listOf(4))))

monoidK.empty().combineK(just(1).combineK(just(3).combineK(just(4))))

Applicative

"Should be able to remove from Foldable" {

    val result = ListK.foldable().run { listOf(1, 2, 3, 4).k().remove(2, ListK.monoidK(), ListK.applicative()) }

    result shouldBe listOf(1, 3, 4)
}

just

Eq

==

Eq

==

Eq

Concurrent

parApplicative()

Applicative

Apply

Eq

remove

val MetaComponentRegistrar.typeClasses: List<ExtensionPhase>
  get() =
    meta(
      classOrObject(::isExtension) { ktClass ->
        val typeClass = ktClass.typeClassName()
        val typeArgs = ktClass.typeArgumentNames()
        val factoryName = typeClass.decapitalize()
        println("intercepted ${ktClass.name}")
        listOf(
          ktClass.text,
          "fun $factoryName(): $typeClass<${typeArgs..","}> = TODO()"
        )
      },
      IrGeneration { compilerContext, file, backendContext, bindingContext ->
        file.transformChildren(object: IrElementTransformer<Unit> {

        }, Unit)
      }
    )

typeArgs..","

","

fun <A> Kind<ForListK, A>.remove(element: A) = remove(element, ListK.monoidK(), ListK.applicative())

@extension
interface ListKFoldable : Foldable<ForListK> {
  override fun <A, B> Kind<ForListK, A>.foldLeft(b: B, f: (B, A) -> B): B =
    fix().foldLeft(b, f)

  override fun <A, B> Kind<ForListK, A>.foldRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B> =
    fix().foldRight(lb, f)

  override fun <A> Kind<ForListK, A>.isEmpty(): kotlin.Boolean =
    fix().isEmpty()

  fun <A> Kind<ForListK, A>.remove(element: A) = remove(element, ListK.monoidK(), ListK.applicative())
}

remove

Foldable

"Should be able to remove from Foldable" {

  val result = ListK.foldable().run { listOf(1, 2, 3, 4).k().remove(2) }

  println(result)

  result shouldBe listOf(1, 3, 4)
}

Foldable

@extension

<out A>

remove

fun <A> ListK<A>.remove(element: A): ListK<A> = this.??? // can't find it

fix()

ListK

Foldable

ListKFoldable

Foldable

PersistentMap

/**
 * A [PersistentMap] is an immutable [Map] which implements structural sharing.
 */
@higherkind
data class PersistentMap<K, V>(private val map: Map<K, V>) : PersistentMapOf<K, V> {

  val isEmpty: Boolean = map.isEmpty()
  val size: Int = map.size

  operator fun get(key: K): Option<V> = Option.fromNullable(map[key])

  fun getOrElse(key: K, defaultValue: V): V = map.getOrElse(key) { defaultValue }

  fun containsKey(key: K): Boolean = map.containsKey(key)

  fun put(key: K, value: V): PersistentMap<K, V> {
    TODO()
  }

  fun remove(key: K): PersistentMap<K, V> {
    TODO()
  }
}

/**
 * A [PersistentMap] is an immutable [Map] which implements structural sharing.
 */
@higherkind
data class PersistentMap<K, V>(private val map: HashArrayMappedTrie<K, V>) : PersistentMapOf<K, V> {

  val isEmpty: Boolean = map.isEmpty
  val size: Int = map.size

  operator fun get(key: K): Option<V> = map[key]

  fun containsKey(key: K): Boolean = map.containsKey(key)

  fun put(key: K, value: V): PersistentMap<K, V> {
    return PersistentMap(map.put(key, value))
  }

  fun remove(key: K): PersistentMap<K, V> {
    return PersistentMap(map.remove(key))
  }
}

MapK

PersistentMapK

PersistentMap

mapk.kt

PersistentMapK

Foldable

@extension
interface MapKFoldable<K> : Foldable<PersistentMapKPartialOf<K>>

@extension
@undocumented
interface PersistentMapKFunctor<K> : Functor<PersistentMapKPartialOf<K>>

mapk.kt

map

PersistentMapK

PersistentMapK<K, V>

PersistentMapKOf<K, V>

PersistentMapK

ForPersistentMapK

map

@extension
@undocumented
interface PersistentMapKFunctor<K> : Functor<PersistentMapKPartialOf<K>> {
  override fun <A, B> Kind<PersistentMapKPartialOf<K>, A>.map(f: (A) -> B): Kind<PersistentMapKPartialOf<K>, B> {
    TODO("not implemented")
  }
}

> Task :arrow-persistent-data-structures:kaptKotlin FAILED
e: error: Arrow's annotations can only be used on Kotlin classes. Not valid for error.NonExistentClass

PersistentMapKOf

PersistentMapK

@higherkind

companion object

PersistentMapK

remove

Foldable

remove

key

Foldable

Foldable

key

Foldable

key

remove

Missing newline before ")"

)

Traverse

Foldable

IO.parApplicative()

parTraverse

traverse

parApplicative()

Traverse

List<Option<User>>

None

Option

Option<List<User>>

None

Applicative

Apply

listOf(1, 2).map { Some(it) }.sequence()

listOf(1, 2).traverse { Some(it) }