What I found missing in Try is possibility to do something on value and return it. For example:

Try {
   // ...
}.onEach {
   printLog(it)
}.map {
   // ...
}

instead of

Try {
   // ...
}.map {
   printLog(it)
   it
}.map {
   // ...
}

Description

Better handle Option and Either generics. The default upper bounds in Kotlin, if not specified, is Any? -> [https://kotlinlang.org/docs/reference/generics.html#upper-bounds (https://kotlinlang.org/docs/reference/generics.html#upper-bounds).

Without these changes, it is currently legal to have a nullable option value:

fun getNull(): Option<String?> = Option.Some(null) 

Examples

    class Value<out T>(val value: T) /* i.e. NullableValue<out T : Any?> */ {
        override fun hashCode(): Int = value!!.hashCode() // must account for possibly null value (!! operator)
    }

    class NonNullValue<out T : Any>(val value: T) {
        override fun hashCode(): Int = value.hashCode() // value is not null, no need for !!
    }

    @Test fun generics() {
        // Legal to use 'String?' instead of 'String'
        val nullValue: Value<String?> = Value(null)

        // Compile error for nullable generic type
//        val nonNullValue: NonNullValue<String?>

        val nonNullValue: NonNullValue<String>
        nonNullValue = NonNullValue("non-null")

        assertEquals("default", nullValue.value ?: "default")
        assertEquals("non-null", nonNullValue.value ?: "default")
    }

Hi Mario,

thank you very much for funKTionale!

I have a question regarding memoization of member functions. I'm used to Java and Groovy and a Kotlin Newbie.

Maybe you have some time and can give some insights on this...

I'd like to memoize the sum member function of this immutable data class (just a silly example)

package tryout

data class MyDataClass(val a: Int = 1,
                       val b: Int = 2) {

    fun sum(): Int {
        println("Calculating...")
        return a + b
    }
}

fun main(args: Array<String>) {
    val myData = MyDataClass()
    println(myData.sum())
    println(myData.sum())
    println(myData.sum())
}

In groovy I can do this using an annotation

package tryout

import groovy.transform.CompileStatic
import groovy.transform.Immutable
import groovy.transform.Memoized

@CompileStatic
@Immutable
class MyGroovyDataClass {

	int a, b

	@Memoized
	int sum() {
		println("Calculating...")
		a + b
	}

	static void main(String[] args) {
		def myData = new MyGroovyDataClass(1, 2)
		println(myData.sum())
		println(myData.sum())
		println(myData.sum())
	}
}

If I want to do this using funkTionale, then there is at the moment "only" this solution, right?

package tryout

import org.funktionale.memoization.memoize

data class MyMemoizedDataClassV1(val a: Int = 1,
                                 val b: Int = 2) {

    private val memoizedSum: (Int, Int) -> Int = { i: Int, j: Int ->
        println("Calculating...")
        i + j
    }.memoize()

    fun sum(): Int {
        return memoizedSum(a, b)
    }
}

fun main(args: Array<String>) {
    val myData = MyMemoizedDataClassV1()
    println(myData.sum())
    println(myData.sum())
    println(myData.sum())

    val myData2 = myData.copy(b = 99)
    println(myData2.sum())
    println(myData2.sum())
    println(myData2.sum())

    val myData3 = myData2.copy(a = 101)
    println(myData3.sum())
    println(myData3.sum())
    println(myData3.sum())
}

Or is there a "more direct" solution?

Thanks for your time & best regards, Peti

Can I transform function like fun myProc(a:Int, b: String, c: Float) to fun myProc(c:Float) in one step?

Right now I use code myProc.partially1(1).partially1("") , but maybe there are best solution?

Hi!

I just wanted to clarify whether it was a design decision to make Either unbiased. As far as I remember, the only unbiased version of Either in the Scala world is ancient scala.util.Either and it's criticized by everyone left and right for exactly its unbiased nature.

Pretty much all alternatives including scala.util.Try, scalaz.\/ or cats.data.Xor are right-biased. In your wiki you are also pointing out that

Traditionally the Left represent an error and Right a correct return

So, why not make it right-biased by design and provide map and flatMap? It would make it even more useful.

Thank you for a great library!

repositories {
    mavenCentral()
    jcenter()
    maven { url "https://jitpack.io" }
}

dependencies {
    compile 'org.funktionale:funktionale:1.2'
}

Functions like eitherTry and Try would also be useful when catching exceptions thrown by suspending functions. The current implementations don't support this. For example, I cannot to this:

fun main(args: Array<String>) = runBlocking {
    val a = async<String>(CommonPool) {
        throw Throwable()
    }

    val result = eitherTry {
        a.await()
    }
    println(result)
}

This fails to compile on a.await because we are not in a suspending block.

I see two potential solutions:

• Add new functions (or change existing signatures) to support coroutines. E.g: eitherTry becomes suspend fun <T> eitherTry(body: suspend () -> T): Either<Throwable, T>
• Simply mark these functions inline.

In your talk you said you have a script to generate functions like this:

infix inline fun <P1, R> P1.pipe(t: (P1) -> R): R = t(this)

infix inline fun <P1, P2, R> P1.pipe2(crossinline t: (P1, P2) -> R): (P2) -> R = { p2 -> t(this, p2) }

infix inline fun <P1, P2, P3, R> P1.pipe3(crossinline t: (P1, P2, P3) -> R): (P2, P3) -> R = { p2, p3 -> t(this, p2, p3) }

Would you mind sharing it?

I want to automate the generation of functions like that.

The name of the second argument "f" like a not very good solution. I like to use named argument for fold calling and any more functions. Of course, I can write:

 fold(isEmpty = {...}){value -> ...}

But I want to be able to write like this

 fold(isEmpty = {...},  some = {value -> ...})

I'd like to use this library in an application of mine. Would you be willing to add an open source license like Apache or MIT to the project? I could create a pull request to do it if you'd like.

Hi,

when using this library on Android 4.2 and older, I get an INSTALL_FAILED_DEXOPT. It might have something to do with this problem: http://stackoverflow.com/questions/21434837/installing-kotlin-android-project-fails-with-install-failed-dexopt After recompiling funKTionale with latest Kotlin (Beta 2), everything works fine. Could you please upload a recompiled version to the official maven repo? Many thanks.

I was able to build v1.2 and publish to my local nexus repo, but it might be useful for you to publish to mavenCentral or another publicly available repo and update the mavenCentral.com details for the module.

It sounds from https://www.47deg.com/blog/announcing-arrow-for-kotlin/ like this project has been replaced by Arrow—if that's true, could you add a note to that effect to the top of the readme?

This is an attempt to fix #42.

Instead of adding more excludes to remove unwanted libraries (JetBrains annotations and IntelliJ annotations), I've specified that only the contents of the org.funktionale package should be included in it - this is easier than having to maintain a list of excluded libraries, even if development has now halted in favor of Arrow.

I couldn't figure out how to build the project locally, but I hope this solution works.

I figured that in my compilation problem with gradle 3.0 described here [1] the reason is in fact funktionale. I cannot pinpoint it any further but I suppose it's a good idea to report it here. It used to compile just fine before I updated my build environment.

[1] https://stackoverflow.com/questions/48504912/android-gradle-3-0-multiple-dex-files-define-lorg-jetbrains-annotations-testonl

Functions like Try<T>.flatMap and Try<T>.fold swallow RuntimeExceptions, making it harder to find bugs.

For example, I tried to use a TODO(), but my application did not terminate:

fun main(args: Array<String>) {
    val result = Success("Test").flatMap<Unit> { TODO() }
    println(result)
}

Instead, the console prints

Failure(kotlin.NotImplementedError: An operation is not implemented.)