Remove Jitpack dependency and added memoization to processors

README.md

@@ -36,7 +36,6 @@ Add it in your root `build.gradle` at the end of repositories.
 allprojects {
     repositories {
         jcenter()
-        maven { url 'https://jitpack.io' }
     }
 }
 ```

build.gradle

@@ -33,7 +33,6 @@ buildscript {
 
     repositories {
         jcenter()
-        maven { url 'https://jitpack.io' }
         maven { url "http://dl.bintray.com/kotlin/kotlin-dev" }
         maven { url "https://dl.bintray.com/jetbrains/markdown/" }
         maven { url "https://dl.bintray.com/arrow-kt/arrow-kt/" }
@@ -73,7 +72,6 @@ allprojects {
         maven { url "http://dl.bintray.com/kotlin/kotlin-dev" }
         maven { url "http://dl.bintray.com/arrow-kt/arrow-kt" }
         maven { url "https://dl.bintray.com/jetbrains/markdown/" }
-        maven { url 'https://jitpack.io' }
     }
 }
 

modules/core/arrow-annotations-processor/build.gradle

@@ -11,7 +11,6 @@ dependencies {
         exclude group: 'org.jetbrains.kotlin', module: 'kotlin-reflect'
     }
     compile "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
-    compile 'com.github.aballano:MnemoniK:1.0.0'
     compileOnly 'com.google.auto.service:auto-service:1.0-rc4'
     kapt 'com.google.auto.service:auto-service:1.0-rc4'
 

modules/core/arrow-annotations-processor/src/main/java/arrow/meta/internal/memoization.kt

@@ -0,0 +1,37 @@
+package arrow.meta.internal
+
+import java.util.concurrent.ConcurrentHashMap
+
+fun <P1, R> ((P1) -> R).memoize(): (P1) -> R = object : (P1) -> R {
+  private val m = MemoizedHandler<((P1) -> R), MemoizeKey1<P1, R>, R>(this@memoize)
+  override fun invoke(p1: P1) = m(MemoizeKey1(p1))
+}
+
+private interface MemoizedCall<in F, out R> {
+  operator fun invoke(f: F): R
+}
+
+private data class MemoizeKey1<out P1, R>(val p1: P1) : MemoizedCall<(P1) -> R, R> {
+  override fun invoke(f: (P1) -> R) = f(p1)
+}
+
+private class MemoizedHandler<F, in K : MemoizedCall<F, R>, out R>(val f: F) {
+  private val m = Platform.newConcurrentMap<K, R>()
+  operator fun invoke(k: K): R = m[k] ?: run { m.putSafely(k, k(f)) }
+}
+
+object Platform {
+
+  interface ConcurrentMap<K, V> : MutableMap<K, V> {
+    fun putSafely(k: K, v: V): V
+  }
+
+  fun <K, V> newConcurrentMap(): ConcurrentMap<K, V> {
+    val map by lazy { ConcurrentHashMap<K, V>() }
+    return object : ConcurrentMap<K, V>, MutableMap<K, V> by map {
+      override fun putSafely(k: K, v: V): V =
+        map.putIfAbsent(k, v) ?: v
+    }
+  }
+
+}

modules/core/arrow-annotations-processor/src/main/java/arrow/meta/processor/MetaProcessor.kt

@@ -1,13 +1,13 @@
 package arrow.meta.processor
 
-import aballano.kotlinmemoization.memoize
 import arrow.common.utils.AbstractProcessor
 import arrow.common.utils.ClassOrPackageDataWrapper
 import arrow.common.utils.ProcessorUtils
 import arrow.common.utils.knownError
 import arrow.meta.ast.Type
 import arrow.meta.ast.TypeName
 import arrow.meta.encoder.jvm.JvmMetaApi
+import arrow.meta.internal.memoize
 import arrow.meta.processor.MetaProcessor.AnnotatedElement
 import com.squareup.kotlinpoet.FileSpec
 import me.eugeniomarletti.kotlin.metadata.KotlinMetadataUtils

modules/docs/arrow-docs/docs/docs/README.md

@@ -169,19 +169,6 @@ Add the dependencies that you want to use
 
 ## Enabling kapt
 
-Add to your pom.xml file the following repository:
-```
-<repositories>
-    <repository>
-        <snapshots>
-            <enabled>false</enabled>
-        </snapshots>
-        <id>jitpack</id>
-        <url>https://jitpack.io</url>
-    </repository>
-</repositories>
-```
-
 Enable annotaton processing using kotlin plugin 
 ```
 <plugin>