Hi, I have an

either

block from which I want to return a

Left

value without any

bind

calls. For example

either<Error, Response> {
 when(foo) {
  1 -> callFunReturningEither().bind()
  else -> Error("foo is in else") <-- How to return this Left value?
 }
}

I have tried

Error("foo is in else").left().bind()

but it gives

Returning type parameter has been inferred to Nothing implicitly. Please specify type arguments explicitly to hide this warning. Nothing can produce an exception at runtime.

which I think is expected.

wat

what was the reason that the arity of function types maxed out at 22 originally? (before FunctionN). is there something special about 22 or was it arbitrary?

Hey folks, this is Jerry from DoorDash! When DoorDash moved from a monolith to microservices my team was looking for ways of making our code cleaner and more reliable. One of the low-hanging fruits was to utilize functional programming more instead of pure imperative programming/OOP when using Kotlin for writing backend services. I thought I would share some of these experiences with the developer community and wrote this guide “How to leverage functional programming in Kotlin to write better, cleaner code” that explains: The differences between FP and imperative programming and how to code different use-cases in Koltin with FP vs Imperative.

I’m just getting started with learning Kotlin and at the same time I’m trying to advance my functional programming understanding/skills. My background is in web development with JS (using functional/declarative libraries like Ramda and XState). Is there a recommend learning path? Books, tutorials, videos, etc. Thanks!

Hope this is the right place to ask this, since this is like an Either type. I’m using the following sealed class to return success or error types (credit to https://phauer.com/2019/sealed-classes-exceptions-kotlin/). It’s working great. I can use the

Outcome.Success

class with a value. However is it possible to use it without a value? There are some cases where I don’t want to pass a value in. I’m not quite sure what the definition would be for me not to pass a value in while not making value optional. Thanks!

sealed class Outcome<out T: Any> {
    class Success<out T: Any>(val value: T) : Outcome<T>()
    class Error(val msg: String, val exp: Exception? = null) : Outcome<Nothing>()
}

I wrote a series of three posts about how to use Functional Programming principles to design a web application in Kotlin: https://medium.com/pragmatic-programmers/from-objects-to-functions-c317f857bcea

Does anyone know if lambdas can have extension functions? By the looks of it I assume not but I'm not sure why they shouldn't.

Is there a parser-combinator that works on top of

Flow

?

when working with an

Either

I sometimes run into having multiple results where I need the results for another call. There I'm usually end up in an ugly structure with nested `flatMap`s. E.g.:

val result1 = foo() // : Either<Error, Result1>
val result2 = foo() // : Either<Error, Result2>
val result3 = foo() // : Either<Error, Result3>

val transformed = result1.flatMap { res1 ->
    result2.flatMap { res2 ->
        result3.flatMap { res3 -> someCall(res1, res2, res3) }
    }
}

isn't there a nicer way to do this?

Hi all - I’m new to FP in Kotlin (and in general 😅) - Is it practical (from a performance and dev ergonomics standpoint) in Kotlin to use higher order functions and partial application to inject dependencies to aim for a functional approach? E.g. if I want to use a database connection in a getUsers function, is it performant to partially apply the database object then use the getUsers function that way? Or would this cause problems down the line and I should just stick to traditional dependency injection with a class constructor?

I don't think you would see performance issues, but you might see code becoming less readable. There is no partial application in the language, though you can certainly emulate it.

I see so overall it would be recommended to avoid it and prefer classes for dependencies? Is idiomatic FP in kotlin more on the business logic side and not so much dealing with the dependencies and stateful code?

Hey @Muhammad Talha, not sure if you've seen #arrow which explores and offers a lot of utilities to do FP in Kotlin. I would say in general partial application is not very Kotlin idiomatic, and traditional DI with class constructors and modules is more idiomatic. An example, https://github.com/nomisRev/ktor-arrow-example/blob/main/src/main/kotlin/io/github/nomisrev/env/Dependencies.kt

I've got

kotlin
@JsonClass(generateAdapter = true)
data class Gallery<T>(val galleryItems: List<GalleryItem<T>>)

@JsonClass(generateAdapter = true, generator = "sealed:type")
sealed interface GalleryItem<T> {
    @TypeLabel("photo")
    @JsonClass(generateAdapter = true)
    data class Photo<T>(val url: T): GalleryItem<T>
    @TypeLabel("video")
    @JsonClass(generateAdapter = true)
    data class Video<T>(val url: T): GalleryItem<T>
}

And

val x: Gallery<String>

as well as

fun parse(x: String): HttpUrl

and I would like a

Gallery<HttpUrl>

in the end. In Haskell, I'd add a

deriving Functor

to the type declaration and then I could use all the fun combinatorics functions. How would I do that in Kotlin?

Hi all, figured here might be a good place to ask. I'm looking for a DI framework that satisfies the following constraints: 1. Doesn't use reflection (Don't want to deal with proguard nonsense more than nesecsary). 2. Compile-time validation of inject statements (I want to know before me code compiles if I try to inject something I haven't provided in a module). 3. Doesn't force you into using OO constructs (I want to be able to use injection in standalone functions and extension methods). Anything like this out there? Koin I think is the closest so far, satisfying 3 but not the others. Heck, I'd even take just 2 & 3 as long as the proguard config isn't too bad to set up and works well in practice without a lot of headaches. And of course context receivers probably solves all three, but they're not ready for production. Ditto for manual parameter passing, but my code-base is getting to the size where I am trying to ease the manual parameter passing burden a bit.

Wrote a blog about the problems with FP today: https://blog.jdriven.com/2022/10/the-problem-with-functional-programming/ (dont worry 😛 its not that negative)

Is there a way to match on two boolean variables at the same time with a single

when

statement? Aka

when (Pair(x, y)) {
  Pair(true, false) -> ...
}

Is there a way to only match part of a

Pair

match?

val mimes = rec.mimeType.split("/")
when (mimes[0] to mimes[1]) {
  "text" to "vcard" -> {}
  "video" to _ -> {}
}

^ the second one isn't really working out.

In Rust I can do this:

struct Circle {
    radius: u32,
}

impl Circle {
    fn new(radius: u32) -> Circle {
        Circle { radius }
    }
}

trait Shape {
    fn area(&self) -> f64;
    fn perimeter(&self) -> f64;
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * (self.radius as f64).powi(2)
    }

    fn perimeter(&self) -> f64 {
        2.0 * std::f64::consts::PI * (self.radius as f64)
    }
}

fn pretty_print<T: Shape>(shape: T) {
    println!("Area: {}", shape.area());
    println!("Perimeter: {}", shape.perimeter());
}

fn main() {
    let circle = Circle::new(1);

    pretty_print(circle);
}

So the trait is like a Kotlin Interface. And now my function pretty_print can take any type(struct) that implements Shape. This seems like a very powerful feature to me as it means I can extend types. How can I achieve the same thing in Kotlin?

Is there a name for this patter in functional programming? What would you name the function?

fun ((A, B) -> Unit).whatShouldThisBeNamed(b: B): (A) -> Unit {
        return { a -> this(a, b) }
    }

(A function that returns a simpler function by providing one of the parameters to the first function)

Hi, lets say I have a sequence of objects (for simplicity I use strings):

val s = sequenceOf("Lorem", "ipsum", "dolor", "sit", "amet")

What’s the best way to limit elements so total size is smaller than desired. For example:

val s2 = s.someFunction(maxSize = 17) { it.length }
println(s2.toList()) // [Lorem, ipsum, dolor]

@elizarov Testing using context receivers for type classes (as claimed in the KEEP should be possible?) Why isn't this working?:

interface ServiceLocator<I> {
//    fun getRealImpl(): I
    fun getEmulatedImpl(): I
//    fun getStubbedImpl(): I
}

context(ServiceLocator<I>)
inline fun <reified I> locateEmulated(): I = getEmulatedImpl()

object StringServiceLocator : ServiceLocator<String> {
    override fun getEmulatedImpl(): String = "test"
}

object LongServiceLocator : ServiceLocator<Long> {
    override fun getEmulatedImpl(): Long = 5
}

object StringLongLocatorFactory: ServiceLocatorFactory {
    // In the future (scope properties): with val ...
    inline fun <reified I> locate(): I {
        with(LongServiceLocator) {
            with(StringServiceLocator) {
                return locateEmulated<I>()
            }
        }
    }
}

No required context receiver found: Cxt { context(ServiceLocator<I>) public inline fun <reified I> locateEmulated(): I defined in [...] in file ServiceLocatorFactory.kt[SimpleFunctionDescriptorImpl@1aa4cbc9] }

Working through category theory for programmers and doing the exercises in Kotlin. What is wrong with this memoize function?

fun <A, B> memoize (f: (A) -> B) = { a: A ->
    val cache = mutableMapOf<A, B>()
    cache.computeIfAbsent(a) { f(a) }
}

I've got a problem statement where it would be really helpful to be able to match on about 4 variables (incoming states from different subsystems, and a requested state, and possibly even previous states), are there some compiler plugins / good workarounds for that?

I started a Discord server for folks working through the book FP Made Easier by C Scalfani. Here's an invite (good for 7 days).

Hi buddies. Do you have any sample code about apply FP/Arrow to CleanArchitect Android app ?

I’m thinking about creating a tool that would promote a more functional approach in certain contexts, like forbid using

var

or

for

loops (mutability in general), with a way to opt out in certain cases. Think: a step towards more pure FP. I’m wondering if you’d be keen to use it and, if yes, what approach you’d suggest to implement it. I’m thinking about a detekt rule or a compiler plugin that would emit an error or a warning (configurable)

Hi all! I'm reading a huge file/object from a remote source in bunches... send fragments of the file thru a Flow and wanna process complete lines one by one. I got below implementation... but I was wondering if there is a way to get rid of the var and get a more functional solution. Thanks in advance.

fun main() = runBlocking {
    var lastline = ""
    readHugeFile().collect { value ->
        val lines = (lastline+value).lines()
        lines.dropLast(1).forEach {
            println(it)
        }
        lastline = lines.last()
    }
    println(lastline)
}

fun readHugeFile(): Flow<String> = flowOf(
    """line 1
        |line 2
        |li""".trimMargin(),
    """ne 3
        |line 4
        |lin""".trimMargin(),
    """e 5
        |line 6
        """.trimMargin()
)