Updated kotlin lib, removed kotlin benchmark

Author: aballano

.github/workflows/todo-to-issue.yml

@@ -0,0 +1,16 @@
+# https://github.com/alstr/todo-to-issue-action
+name: "TODO to Issue"
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: "actions/checkout@master"
+      - name: "TODO to Issue"
+        uses: "alstr/[email protected]"
+        id: "todo"

.gitignore

@@ -30,3 +30,4 @@ Icon?
 ehthumbs.db
 Thumbs.db
 *~*
+local.properties

.travis.yml

@@ -6,5 +6,4 @@ jdk:
 
 script:
   - ./gradlew test
-  - ./gradlew benchmark
   - ./gradlew clean build

README.md

@@ -1,7 +1,5 @@
 # MnemoniK 
 [![](https://jitpack.io/v/aballano/mnemonik.svg)](https://jitpack.io/#aballano/mnemonik)
- [ ![Download](https://api.bintray.com/packages/aballano/maven/mnemonik/images/download.svg) ](https://bintray.com/aballano/maven/mnemonik/_latestVersion)
-[![Kotlin version badge](https://img.shields.io/badge/kotlin-1.4.10-blue.svg)](http://kotlinlang.org/)
   [![Hex.pm](https://img.shields.io/hexpm/l/plug.svg)](http://www.apache.org/licenses/LICENSE-2.0)
 
 Simple [memoization](https://en.wikipedia.org/wiki/Memoization) extension function for Kotlin 
@@ -10,17 +8,22 @@ Simple [memoization](https://en.wikipedia.org/wiki/Memoization) extension functi
 ## Rationale
 > Suppose you have a performance-intensive function that you must call repeatedly. 
 A common solution is to build an internal cache (...) Memoization is a feature built into a programming language that enables automatic caching of recurring function-return values.
-
-Functional Thinking - Neal Ford
+>
+> Functional Thinking - Neal Ford
 
 Kotlin doesn't have yet any similar feature in it's tools. Although it might have it at some point I wanted to experiment a bit with this technique so that's why I created the lib. 
 
 
 ## Important
-**Functions must be pure** for the caching technique to work. A pure function is one that has no side effects: it references no other mutable class fields, doesn't set any values other than the return value, and relies only on the parameters for input.
-Obviously, you can reuse cached results successfully only if the function reliably returns the same values for a given set of parameters.
+Functions must be pure for the caching technique to work.
+
+A pure function is one that has no side effects: it references no other mutable class fields,
+doesn't set any values other than the return value, and relies only on the parameters for input.
 
-Also, when passing or returning Objects, make sure to **implement both `equals` and `hashcode`** for the cache to work properly!
+In other words, you can reuse cached results successfully only if the function reliably returns the
+same values for a given set of parameters.
+
+Also, when passing or returning Objects, make sure to implement both equals and hashcode for the cache to work properly.
 
 ## Usage
 Having a function like
@@ -35,11 +38,11 @@ You can create a memoized version of it by just calling an extension function ov
 val memoized = ::anExpensiveFun.memoize()
 ```
 
-Now `memoized` is the same function as `anExpensiveFun` but is wrapped in a Closure that contains an internal cache, meaning that the first call to:
+Now `memoized` is the same function as `anExpensiveFun` but is wrapped in a lambda that contains an internal cache, meaning that the first call to:
  ```kotlin
 memoized(5, true)
 ```
-Will just execute the function. But the second call **with the same arguments** will retrieve the already calculated value from cache.
+Will just execute the function and return the value. But a second call **with the same arguments** will retrieve the previous value from cache.
 
 Note that we're storing values in a **memory cache**, so try to have that in consideration when doing a relatively big amount of calls to your memoized function or if you use big objects as parameters or return type.
 
@@ -50,12 +53,12 @@ val memoized = ::anExpensiveFun.memoize(50)
 ```
 By default the cache size is initialized with 256.
 
-Now you can also pass a specific `HashMap` instance (like ConcurrentHashMap) which also allows freeing the cache after you're done.
+Now you can also pass any `MutableMap` instance (like `HashMap`) which allows custom control of it.
 
 ```kotlin
 val map = ConcurrentHashMap<Int, Long>(50)
 val memoizedFib = ::fib.memoize(cache = map)
-(...)
+
 // clear the cache at the end
 map.clear
 ```

build.gradle

@@ -1,67 +1,29 @@
 buildscript {
-    ext.kotlin_version = '1.4.10'
+    ext.kotlin_version = '1.6.10'
 
     repositories {
         mavenCentral()
-        maven { url 'https://dl.bintray.com/kotlin/kotlinx' }
     }
 
     dependencies {
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlinx:kotlinx.benchmark.gradle:0.2.0-dev-20"
-        classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlin_version"
     }
 }
 
 group = 'com.aballano'
 
 subprojects { project ->
     apply plugin: "kotlin"
-    apply plugin: 'kotlinx.benchmark'
-    apply plugin: "kotlin-allopen"
 
     repositories {
         mavenCentral()
-        maven { url 'https://dl.bintray.com/kotlin/kotlinx' }
-    }
-
-    sourceSets {
-        benchmarks
     }
 
     dependencies {
         implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-        implementation "org.jetbrains.kotlinx:kotlinx.benchmark.runtime-jvm:0.2.0-dev-20"
 
         testImplementation 'io.kotlintest:kotlintest-runner-junit5:3.4.2'
         testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.3.0"
-
-        benchmarksImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.3.0"
-        benchmarksCompile sourceSets.main.output + sourceSets.main.runtimeClasspath
-    }
-
-    allOpen {
-        annotation("org.openjdk.jmh.annotations.State")
-    }
-
-    benchmark {
-        configurations {
-            main {
-                warmups = 20
-                iterations = 10
-                iterationTime = 3
-                iterationTimeUnit = "s"
-            }
-            smoke {
-                warmups = 5
-                iterations = 3
-                iterationTime = 500
-                iterationTimeUnit = "ms"
-            }
-        }
-        targets {
-            register("benchmarks")
-        }
     }
 
     test {

lib/src/benchmarks/kotlin/MemoizeBenchmark.kt

@@ -7,6 +7,18 @@ import java.util.concurrent.ConcurrentMap
 
 private const val DEFAULT_CAPACITY = 256
 
+/**
+ * Functions must be pure for the caching technique to work.
+ *
+ * A pure function is one that has no side effects: it references no other mutable class fields,
+ * doesn't set any values other than the return value, and relies only on the parameters for input.
+ * In other words, you can reuse cached results successfully only if the function reliably returns the
+ * same values for a given set of parameters.
+ *
+ * Also, when passing or returning Objects, make sure to implement both equals and hashcode for the cache to work properly.
+ */
+
+
 fun <A, R> ((A) -> R).memoize(
     initialCapacity: Int = DEFAULT_CAPACITY
 ): (A) -> R = memoize(HashMap(initialCapacity))