@simon.vergauwen It seems like Ktor uses

Runtime.getRuntime().addShutdownHook(hook)

, is that only SIGINT? It seems like in your video it was clearly using SIGINT, but in my current version not...

how can i get the stacktrace of an error in functional style? throwing exception is not a right thing in FP.

Recently I've become a fan of explicit error handling using Result<V, E> (using https://github.com/michaelbull/kotlin-result). Yesterday I was shocked by the thought that handling errors this way somehow reminds me of Java's checked exceptions, with different syntax 😐 Is this analogy really correct? EDIT: I know that in Java some things are not possible like nice chaining of function calls. But in Kotlin it would be possible because of the language's "almost everything is an expression" paradigm.

I'm experimenting with Arrow's

raise()

functionality and I try to find a library function similar to the following hypothetical

orElse()

:

context(Raise<String>)
fun f1() = 1

context(Raise<String>)
fun f2(): Nothing = raise("error")

suspend inline fun <R, A> Effect<R, A>.orElse(noinline block: suspend (R) -> A) =
    fold(
        recover = block,
        transform = ::identity
    )

val v1 = effect { f1() }.orElse { 33 }
assertEquals(1, v1)

val v2 = effect { f2() }.orElse { 33 }
assertEquals(33, v2)

I use arrow 1.1.6-alpha.36. Thanks.

I have been writing a lot of Scala 3 recently and it really has made me wish Kotlin had a bit less brackets! Kotlin feels so noisy now. Especially when writing in a functional style

Anyone here doing functional Kotlin on Android? I am interested to hear what wider architecture you are using.

Is there a preferred way to approach companion function with a functional style ?

data class SomeData(val someValue: String) {
  companion object {
    fun someFunction() {}
  }
}

// OR

data class SomeData(val someValue: String) {
  companion object
}

fun SomeData.Companion.someFunction() {}

I have 2 functions which return Results.

functionOne: Result<Something>

functionTwo: Result<Unit>

I’ll only call functionTwo if the first one returns a Success, and return a

Result<Something>

in case both of them return a Success. What’s the best way to do it using std lib? I thought the nested folds and maps and ifs turned out a bit ugly

I finally had some time to experiment with my very old 🙂 idea of mutating immutable object graphs using Kotlin (with KSP help). I've created a short readme about its usage, I'd like to hear your opinions about the idea itself (eg. whether it is worth to continue development or not): https://github.com/kotlinw/kotlinw/tree/main/kotlinw-immutator

Hey, wondering if anyone has best practices tips / examples for implementing a "Tool" (i.e. asynchronous user workflow with a specific start / end, as opposed to something with an open-ended lifecycle like a view) in a MVU/Elm style using Kotlin coroutines. We currently have a sealed class "action" interface for representing actions the user can perform to interact with the tool, and a reducer function

(State, Action) -> State

, but my question was more about how to actually action this reducer to do stuff with the UI. Currently we are taking in a Flow of Actions, an initial state, and updating that state (as a StateFlow) by launching a collect block on the action flow to update the state. The body of the collect statement on the flow is synchronized with a mutex so actions should (I was hoping anyway) get executed in order sequentially. In practice, this seems to work. However, I've noticed in tests this sometimes fails, which makes me wonder if my setup of this is actually optimal. I was thinking maybe a channel of user actions might be more robust, but open to ideas!

My book on functional Kotln and DDD is now available on Amazon: https://www.amazon.co.uk/Objects-Functions-Software-Functional-Programming/dp/1680508458

Does kotlin have a

reduce

where I can pass the initial

acc

?

... where does the default

S

of the result even come from? O.o

Am I right in thinking that molecule basically provides monad comprehension over lists? Because it allows you to deal with each element of a flow as they come in and make a flow out of that, and you can do that for any number of flows you want, and so it's a monad comprehension, right?

Hello I’m working on an hobby oss project, ‘partial-function-kt’, which is a Kotlin analogue of Scala’s PartialFunction. Would you kindly be willing to share your thoughts, suggestions, or any feedback on this implementation? Or, if you have any good precedents, could you please share them with me? https://github.com/jsoizo/partial-function-kt

Hello all, just a quick question, I wonder if such a function exists in the Kotlin standard library? if not how should it be named? I'm calling it "combine" for now 🤔

fun <A, B, R> Collection<A>.combine(other: Collection<B>, transformation:(A, B)->R): List<R> = 
    ArrayList<R>(this.size * other.size).also{
        for(a in this){
            for(b in other){
                it.add(transformation(a, b))
        	}
        }
    }

Example:

fun main(){
   println( 
       listOf(1,2,3).combine(listOf("a", "b", "c")){a, b -> "$a-$b"} 
   )
}

Output:

[1-a, 1-b, 1-c, 2-a, 2-b, 2-c, 3-a, 3-b, 3-c]

maybe

cartesianProduct

?

Nested functions/ nested functions as data: Top or flop?

I've got an ADT with a whole lot of members, some recursive, some not. Now that the code is evolving, I've got some members which are possible at some stages of the program, and some others at other stages. What's the best way to model this? Use multiple inheritance to tag them for the specific stages?

I am curious, if purly functional, serverside kotlin has any effects, except from confusing any java developer and making its developer irreplaceable. Any effects on cpu/ram/ other performance issues?

Is there a way to pass multiple context receiver scopes to a single

with(..)

clause?

I'm creating a new backend API server in Kotlin and I was wondering what best practices users here recommend around using Arrow and Kotlin.Result. What features, if any, of Arrow do you find indispensable and why, taking into consideration the fact that new programmers may not be familiar with functional programming or even Kotlin, and just Java instead? Which ones would you introduce first? As you might suspect, I'm thinking of Kotlin.Result or Arrow.Either.

My local lens dealer's gonna be arrow?

Can any FP wizard here show me how the reverse state monad would work in Kotlin? I can't seem to wrap my head around the laziness needed. I have a version that uses

suspend

and a

Channel

to pass a value "backwards" in time, but I don't trust that it's actually "correct"

How would I do a

when

on two items? Use a

Pair

and deconstruct using

to

?

Can someone explain why this whole thing about creating sealed classes with different types and all that, why is called

algebraic data types

? What's the relationship with algebra?

I've got a list maps, and I'd like to merge them into a single map, with a value merge function. Is there one such a collection operation?

I'd like to reference a partially-applied function with receiver. Is this possible? Say, I have a function

f(x: X, (X) -> Y): Y

that takes some argument

x: X

and a function

(X) -> Y

. And I have a concrete function with receiver, say

Int.makeY(x: X): Y

. I would like to partially apply

makeY

to a given receiver and pass it to

f

, like

val foo = 5
f(x) { foo::makeY }

However, this results in an ArgumentTypeMismatch compilation error, stating that

Y

was expected instead of the provided function reference. Am I simply making a mistake in my declaration, or is it simply not possible to pass a partially applied function with receiver as reference?

ST Monad in Kotlin, with subregioning, and with similar safety guarantees as in Haskell! (

STRef

and the

STScope

itself may both escape, but they're only usable exactly in the region they were gotten in!) (playground)

import kotlin.coroutines.Continuation
import kotlin.coroutines.EmptyCoroutineContext
import kotlin.coroutines.RestrictsSuspension
import kotlin.coroutines.intrinsics.startCoroutineUninterceptedOrReturn

class STRef<in R, S> internal constructor(internal var state: S)

@RestrictsSuspension
interface STScope<R> {
  suspend fun <S> new(init: S): STRef<R, S> = STRef(init)
  suspend fun <S> STRef<R, S>.get(): S = state
  suspend fun <S> STRef<R, S>.set(value: S) {
    state = value
  }
  suspend fun subregion(block: suspend SubSTScope<*, R>.() -> Unit)
}

// could use typealias instead, but bad IDE support
interface SubSTScope<R1 : R2, R2> : STScope<R1>

class STScopeImpl<R> : SubSTScope<R, R> {
  // could even be inline!
  override suspend fun subregion(block: suspend SubSTScope<*, R>.() -> Unit) = block()
}

fun <R> runST(block: suspend STScope<*>.() -> R): R =
  block.startCoroutineUninterceptedOrReturn(STScopeImpl<Any?>(), Continuation(EmptyCoroutineContext) {}) as R

fun main() {
  runST {
    // need to use inner functions here because the compiler isn't smart enough about existential
    // Outference might solve this problem!
    suspend fun <R> STScope<R>.example() {
      val ref = new(0)
      ref.set(42)
      println(ref.get()) // prints 42
      //val escape = { ref.get() } // not allowed to escape
      //val escape = runST { ref.get() } // still not allowed to escape
      //runST { with(this@example) { ref.get() } } // even this doesn't work!
      subregion {
        suspend fun <R1: R> STScope<R1>.inside() {
          val innerRef = new(0)
          innerRef.set(100)
          println(innerRef.get()) // prints 100
          println(ref.get()) // prints 42
        }
        inside()
      }
    }
    example()
  }
}

I hence conjecture that

@RestrictsSuspension

subsumes the concept of monadic regions, albeit while limiting some of Kotlin's magic (can't use general

suspend

functions inside, can't extend them easily, etc). In fact, I think Kotlin may have just enough features to enable general capability/resource tracking.

didn't know where to ask, so i'll ask here. can someone see what's (obviously, probably) wrong with this? i'm attempting to sort some polygons by their lowest z-coordinate. the nasty code looks like this:

val sortedFaces: List<Pair<Int, List<Int>>> get() {
        return faces.mapIndexed { i, it ->
            Pair(i, it)
        }.sortedByDescending { indexedFace ->
            indexedFace.second.minByOrNull {
                vertices[it].z
            }
        }.also { 
            it.forEach {
                println("${it.first}: ${it.second.map { vertices[it].z }.min() }")
            }
            println()
        }
    }

and prints something like this:

5: 0.535865025190621
3: -1.1402821230261972
0: -1.3581312119491156
2: -1.3581312119491156
4: -1.3581312119491156
1: -0.7537141141135403

how can it possibly print a wrongly sorted list here?