ExponentialMonoid?
so, straight into Semigroup it goes then!
Hi everyone, new to Kotlin, new to Arrow, new to FP. I'm reading the docs about Arrow Fx here https://arrow-kt.io/docs/0.10/fx/#turning-side-effects-into-pure-values-with-effect and I was wondering whether someone can explain to me something.
How exactly is it that we can consider
How exactly is it that we can consider
effect { sayHello() } a "pure value"? I get that it returns an IO object and is lazily evaluated, but won't it still cause a side effect when eventually evaluated?
Well constructed FP programs look something like the following:
(a) Summon required instances (usually parameterized over IO at the top level, but could be Rx or coroutines in the case of Android or interop with other systems)
(b) Construct computations by composition of lazy functions over effects. A better example might be
effect { doSql("INSERT INTO xx (yy) VALUES ($zz)") }.flatMap { (rowsInserted) -> ... }, which says "here's a function that inserts something into a table. Given that I have that function, give me another function that not only inserts something into the table but also does something based on the number of rows inserted. So computations are constructed entirely by function composition. effect { sayHello() } essentially gives me a function I can compose but not run yet.
So that's pure/referentially transparent because it is only a function, not a side-effect that occurs.
So the whole goal of FP program construction is to build compositions of functions/effects and then have a single call that causes the effects to be evaluated. What ends up happening is that smaller FP programs are being constructed inside of larger FP programs as effects are evaluated. (This is necessary to enable conditional execution of effects)
The nice property about this is that the contract is explicit: if you write a function that takes a
(Int, String) and produces a IO<Unit> you can replace that function with anything with that type signature and it will "just work" within the confines the contract: IO is an effect that sequences computations (Monad) and captures errors (MonadError). (IO also has a number of other typeclasses it inherits from enabling it to be used to create programs that operate in parallel over fibers/coroutines/threads/etc.)
Also, as an additional 2 cents: I'd recommend actually writing programs using Kotlin/Arrow or Scala/Cats + Cats Effect or Haskell to really get the feel for it. There are a lot of terms used that originate from category theory; don't hesitate to ask for a conceptual meaning of them, there are lots of friendly people willing to help answer them. I found I had to pull information in from a lot of different places to get even a basic handle on it.
Learning concepts in one or more of them will translate to the others readily.
Finally, I'd recommend joining #arrow on kotlinlang.slack.com
That channel generally has more people present available to answer questions more of the time.
Same limitation: emulated HKT. Require additional boilerplates... But doable. See
https://github.com/aol/cyclops
https://github.com/aol/cyclops
I think this may be the most promising new entrant for FP in Java: https://palatable.github.io/lambda/
Hi guys, I am pretty new to FP and have a question regarding Kleisli:
Basically I want to pass a context down to the db access layer, but I want to access this context everywhere in between. So as an example I have this:
object OrderRepository {
fun findAll(userId: String): Kleisli<Context, ForIO, List<Order>> =
Kleisli { ctx ->
IO {
ctx.db.query("someQuery")
}
}
}
object OrderService {
fun findAll(userId: String): Kleisli<Context, ForIO, List<OrderResponse>> =
OrderRepository.findAll(userId).map(IO.monad()) { orderList ->
orderList.map {
//Create OrderResponse from Order
}
}
}The OrderService calls the OrderRepository in this case. This examples works fine, but my problem is, that I don't know how to access the context in the OrderService (findAll) function. Can you tell me how to do that, or doesn't this make sense at all? Thanks in advance for your help.
I got an answer to the question above here: https://stackoverflow.com/questions/62390210/how-can-i-access-the-context-in-every-function-of-a-call-chain-with-kleisli
I have REST controller endpoint that executes command handler that is wrapped in
IO.fx (snippet below). I'm changing the return type of a commandFrom(commandType, command) from Command to Either<InvalidCommand, Command>. I'm struggling with finding the best way to tie these together with this change. Any feedback is welcome. Thank you. return commandHandler.handle(commandFrom(commandType, command))
.attempt()
.map { result -> result.fold({ Response.Error(it.toString()) }, { Response.Success(it) }) }
.unsafeRunSync()
Hm... I think this may work. Can you comment if this is the right approach.
return EitherT.monad<ForIO, DomainError>(IO.monad()).fx.monad {
val command = EitherT(commandFrom(commandType, command)).bind()
EitherT(commandHandler.handle(command).map { it.right() }).bind()
}.value().fix()
.map { result -> result.fold({ Response.Error(it.toString()) }, { Response.Success(it) }) }
.unsafeRunSync()
And if it's the right approach, can someone please break down the following piece of code
EitherT.monad<ForIO, DomainError>(IO.monad()).fx.monad. I have a very hard time understanding it.
@Synesso
Reader is isomorphic to a function call, so strictly speaking it is not needed :)
In 0.10.5 it's expecting
MF: Monad<DomainError> and in 0.10.3 MF: Monad<ForIO>. Do you think this is a bug or intentional change between the two version?
I am unfortunately not familiar with the details of changes between 0.10.3 and 0.10.5. The people in the #arrow channel at kotlinlang.slack.com may have those answers. (That channel has much more activity than this Gitter channel does, and you may receive more timely and accurate answers to your questions there.)
Is that slack channel open for everyone?
hey there, I followed arrow's config from github, and gradle build succesful, but when I import arrow.* , intellij idead tell me that arrow is not resolved, here is the gradle config https://paste.ubuntu.com/p/znWcb9BcDn/
Hi all, I am using Validated as you can see in the following code:
return aList
.traverse(ValidatedNel.applicative(Nel.semigroup<ValidationError>()), ::validate)
.fix()
.map{
it.fix()
}the code does what I expect, however I am asking is there is a better way to write it to avoid the two time fix() function calls. I understand it returns a Kind<NotEmptyList<ValidationError>, Kind<ForListK, MyModel>>. Any recommendation?
head over to #arrow in kotlinlang.slack.com , the devs are there and generally are good about answering questions