But we want to get rid of that because I can do that with a compiler plugin if I can intercept the AST before it expands and auto register instances

This SO answer https://stackoverflow.com/a/35164370/1772342 provides a lazy concatenation method by defining a custom extension function on

Sequence

, but why isn't the operand of

Sequence.plus(...)

evaluated lazily by default? Are there any plans to provide this behavior? Is there a way to use the stdlib functions to get a truly lazy implementation for concatenation of Iterables? @h0tk3y

sorry guys, I was tired when I posted

anyMatch

was a typo, I meant

all { }

and

allMatch { }

@kevinmost @arocnies

@elizarov @gildor Would you like us to contribute the KEEP and submit a PR to https://github.com/Kotlin/KEEP for further discussion? I'm not sure about the process but we are very much interested in this feature.

I think

Int.Companion.empty()

and auto creation of

Companion

makes more sense

I am reading “An introduction to Functional Programming through Lambda Calculus” what does this expression mean? T := X; X := Y; Y := T

My first book with @rivu.chakraborty

Would you not agree that runA is a pretty obscure name, regardless of whether it's already used in Scala? I think it would be better to use more explicit names. I'm generally wary of names that rely on convention, although its not always feasable to avoid. For example Factory, Visitor and so on are also a convention and relatively meaningless on their own, but at least you can take a good guess. This however, seems like a very clear cut case to me where the API can be made much more friendly at very little cost, not to mention that FP developers shoukd have no problem adopting to simple naming changes when theyre already familoar with the concepts (the reverse is decidedly not true for OOP devs)

Speaking of static typing, are there any static functional languages on the JVM?

For those of you getting initiated into FP and wanting to learn what you can use

Try

for: https://twitter.com/arrow_kt/status/964099546103123969

also for cases like

fold

, I would like to create 0 object instead of 2

The core module is pretty small and as for the Try constructor we can make those inline if it doesn't break other stuff

it keeps a copy of the method + one copy per callsite

I like this pattern a lot, I even include own implementation of Result class (with value, HttpError and Exception cases) to my kotlin-coroutines-retrofit adapter, because it’s much more pleasant and safe to use something like this with coroutines (and not only with coroutines, but with any IO code)

Hi 🙂 Another FP newbie here 😉 And one thing bothers me: what type/container should I use to represent a single value that’s neither optional nor can fail in any way, but I still want to

map

over it? I know I could use Kotlin’s

let

, but maybe there’s a proper FP way of doing this?

Most people start with the basic data types but IMO the killer feature in Arrow is Ad-Hoc Polymorphism, if you depend on type classes and perform only Effects in the monadic context of

F

you can create entire pure programs that entirely independent of the runtime data types that backs their declaration.

How would that help? The background service updates latest posts (i.e. at the top of the list) while the pagination loads additional old posts (i.e. at the bottom of the list). I don't even really care about this specific scenario, the app only exists to come up with a scaleable functional architecture that can deal with such problems (like synchronizing parent and child state)

I understand the problem when we cannot modify

Color

, but it is not such a common case + probably in the future we will be able to use extension interfaces.

Don’t you need to instantiate IntAddMonoid and IntMultiplyMonoid at the bottom there?

So in Rxjava terms, a Monad is the lambda inside the .map operator?

I feel like I'm missing something here, how do I return a function from a function?

want to have something like fun funGenerator(some flags) { if flag = a return fn(param) { some operation on param } if flag = b return fn(param1 param2} {some different operations } }

It’s not true. Inline functions still exist in bytecode, so you cannot mark function as inline and decrease methods count Impact of methods count on performance is very limited and hardly measurable. Dex size is important for application startup time, but it’s not only about methods count. Also inline functions will increase dex size, not decrease, especially if you inline functions with big body. And inline functions is not something related only to functional programming, so even with other inline functions advantages it doesn’t look like argument for functional programming

The only point which “indirectly improve performance” that I see is that functional style is much easier to use with asynchronous code and convertatation of synchronous functional code to asynchronous is much more simple thing than refactoring of syncronous imperative to asyncronous. Same with concurrency. So it can improve general performance when you use more asynchronous and concurrent operations and do not block the main thread.

Thanks @simon.vergauwen So. it can’t be done without specifying the f signature?

It would be nice to remove

newDogsMap[it.key]!!

specifically…

Hi guys! Is there any way to exit-early/short-circuit from the

reduce

function? I wan’t to reduce an infinite sequence of numbers, but only until some condition is met (based on the result of the reduce). I know Clojure has this neat

reduced

function for this. In Haskell we could use

scan

. But do we have anything similar in Kotlin’s stdlib?

or even

fun testFun(nums: IntArray) =
    nums.fold(Int.MIN_VALUE to Int.MAX_VALUE) { (largest, smallest), next ->
        max(largest, next) to min(smallest, next)
    }.run { first - second }

is that really iterating through the array?