if there is Some(f : (A)->B), how I can make f work on another Some object? since map, ap, and flatMap all takes a function

hi all 👋 With arrow optics is it possible to modify multiple values in the same instruction? maybe something like :

fun t(dto: UpgradeTrigger) {
    UpgradeTrigger.run {
        title.modify(dto) { it.toUpperCase() }
        subtitle.modify(dto) { it.toUpperCase() }
    }
}

Does Arrow have the

tupled

function for data classes?

Hi! I want to ask a non-arrow related question, mainly because I think that arrow core developers have a lot of experience with kotlinc's type inference and maybe you'll be able to help me in finding a workaround/solution.

Hi!! I’m playing around with Kleisli but I don’t understand how to use

map2

with the two Kleisli instances I’ve created,

readNameKCO

and

readAgeKCO

. My goal is to create a new Kleisli that generates a

Person

instance from a

Config

one and then using it with

personK.run(config)

. I’m doing something wrong for sure but I don’t quite understand out to build the

personK

Kleisli

Probably a very naive question, but I can't find an easy solution for: What's the most concise way of turning a

List<Option<A>>

into a

Option<List<A>>

? So if any if the `Option`s in the original List is

None

, the whole return type should be

None

.

Learn more about optics today in this talk from @simon.vergauwen https://twitter.com/47deg/status/1281891101151055874?s=19

Hello all 👋 I am trying to define a typeclass, I have the following

data class Bank(val account: ErrorBox<Account>)
    data class Account(val balance: Int, val name: String)

    @JsonDeserialize(using = ErrorBoxDeserializer::class)
    class ErrorBox<T>(var failure: Throwable?, var value: T?)

and in my ErrorBoxDeserializer if the json is valid, I return a value otherwise an error. How would you do in order to give monad super powers to ErrorBox? it would be great if it could behave just like Either

Does anyone have an example of the new "box" for

either

?

if I add extensions to Apply, I have 87 fields 🙂

I saw a new addition a few weeks ago to arrow where you could specify a timeout/retry policy. I'm curious what an FP approach to designing a Circuit Breaker might look like. How might you keep your timeouts synchronized across your async layer without using side effects?

Hi, I would like to collect a metric (a timer) of IO<Either<E, A>> execution. I can measure the time with bracket and result with flatTap. But what I want to achieve is a timer tagged with the result (success, error, failure). Any ideas on how I can get time & result of IO execution?

Hey team, How can I flatten List<Either<Exception, Value>> to List<Value>??

I'm using

implementation "io.arrow-kt:arrow-generic:0.10.5

in the

build.gradle

file of an Android project. But this doesn't seem to make

Coproduct

available. Is there something else I need to do?

API docs of Arrow Fx Coroutines are up here for those interested: https://arrow-kt.io/docs/next/apidocs/arrow-fx-coroutines/index.html Feedback and contributions to docs very welcome!! All methods & data types are documented already.

Hi all 👋, I'm currently wading through the treacherous waters of Applicative and Traversable functors in the FP in Kotlin book 😅. I'm having some issues expressing some of the more advanced concepts like product, fusion and composition of types like

Applicative

and

Traverse

. An example of product would be when translating the following function from Scala:

def compose[G[_]](G: Applicative[G]): Applicative[({type f[x] = F[G[x]]})#f] = {
  val self = this
  new Applicative[({type f[x] = F[G[x]]})#f] {
   def unit[A](a: => A) = self.unit(G.unit(a))
   override def map2[A,B,C](fga: F[G[A]], fgb: F[G[B]])(f: (A,B) => C) =
    self.map2(fga, fgb)(G.map2(_,_)(f))
  }
 }

The problem here being how to express that type lambda

({type f[x] = F[G[x]]})#f

. The

unit

and

map2

functions should return types like

(F[A], G[A])

, translated to Kotlin that would be

Tuple2<Kind<F, A>, Kind<G, A>>

. From what I can tell, this simply isn't possible in Kotlin, but maybe someone else can see a way of achieving this that I just can't see.

Much (most?) of the Arrow code I've looked at conforms to 2 space indentation. I've always used 4. But it seems like the more functional-style code I write, the more I run out of horizontal space. Is that typical? What's the reasoning for the 2 space style chosen for Arrow? Is it a carryover from Scala conventions?

I’m messing around with trying to implemented a

Constrained<T>

as a DSL for domain modeling (inspired by this and other similar talks ). What I would really love is to make it a one liner to create constrained types with private constructors so that it becomes effortless to use in domain modeling. Currently in Kotlin the way to implement something like this is

data class Natural private constructor(val value: Int) {
    companion object {
        fun fromInt(v: Int): Either<NaturalFromIntFailure, Natural> =
            when (v < 0) {
                true -> NaturalFromIntFailure.IntMustBeGTEZero.left()
                false -> Natural(v).right()
            }
    }
}
sealed class NaturalFromIntFailure {
    object IntMustBeGTEZero: NaturalFromIntFailure()
}

which is fine I guess, but if people want to get in the habit of using constrained domain types for every type in a domain (as is recommended), this starts to become tedious and starts to lead toward cutting corners on these types. From reading about dependent types, it would be awesome to do something like

typealias Natural = Constrained<Int><{ 
    when (it < 0) {
        true -> NaturalFromIntFailure.IntMustBeGTEZero.left()
        false -> Natural(it).right()
    }
}>
val x = Natural(-1) // Doesnt compile
val y = Natural.new(-1) // Left(NaturalFromIntFailure.IntMustBeGTEZero)

Alas messing around hasn’t gotten me close to this at all. This is the best I’ve gotten so far which is still a little too verbose , doesn’t have a consistent interface for constrained types, and has some public “private” methods :(

/*
----------------------------------------------------------------------------------------------------
Generic bits
 */
data class Constrained<A> private constructor(val a: A) {
    companion object {
        fun <A, E>validateNew(a: A, validator: (A) -> Either<E, A>): Either<E, Constrained<A>> =
            validator(a).fold(
                { it.left() },
                { Constrained(a).right() }
            )
    }
}

/*
----------------------------------------------------------------------------------------------------
Consumer Implementation
 */
typealias Natural = Constrained<Int>
sealed class NaturalFromIntFailure {
    object IntMustBeGTEZero: NaturalFromIntFailure()
}

fun natural(a: Int) = Natural.validateNew<Int, NaturalFromIntFailure>(a) {
    when (it < 0) {
        true -> NaturalFromIntFailure.IntMustBeGTEZero.left()
        false -> it.right()
    }
}
/*
----------------------------------------------------------------------------------------------------
Examples
 */

val a = Natural(-1) // Doesn't compile
val b = natural(1)  // Result: Right(Natural(1))
val c = natural(-1) // Result: Left(NaturalFromIntFailure.IntMustBeGTEZero)

Does anyone have any suggestions on if there are any tools available in arrow that could move this closer to the ideal state?

The new 'suspend' API is very interesting. I started to write some pieces of code ... But, to go further in my investigations, the absence of typeclass disturbs me: how to write a polymorphic program? I missed something between Async/ApplicativeError and suspend datatypes ! I understand: if I want to play with F, ..., i need to build datatypes over fxcoroutine. Is the right way ?

Hello Sorry for the dumb question but is there a way to transform a SequenceK<Either<Throwable, Iterable<T>>> to a SequenceK<Either<Throwable, T>> while preservering the original potential throwable? I'm tinkering around with this problem but without getting anywhere... =( Thanks!

Hi, i am trying to do something like this:

val result = Either.right(value).map { suspendFunction(it) }

Then i will use the snapshot

Will 0.10.6 be released or we will see only 0.11.0 ?

What platforms is arrow available on? Couldn't find anything on this in the docs.

@raulraja I am very interested in doing https://kotlinlang.slack.com/archives/C5UPMM0A0/p1585855394139500?thread_ts=1585852655.135300&amp;cid=C5UPMM0A0 on version 0.10.4 (which i am using now). Can I implement

TaskOf<A>

somehow myself until it gets available in

0.11.0

(i am assuming this) ?

Hi! I am going through this: https://next.arrow-kt.io/docs/fx/polymorphism/#arrow-fx-vs-tagless-final, and there is a mention about Direct relationship between 

suspend () -> A

 and 

Kind<F, A>

. Is there any ongoing development to replace or eliminate higher kinds? If yes, can someone please help me by pointing to a doc or with a simple example. Thanks!

Hi! Thanks to you, I think I finally understand how typeclasses solve the problem of adding new behavior to domain classes (eg. Convert a domain object to JSON, Serialize a domain object, Compare two objects, Display an object, etc). However, I do not understand how typeclasses can be used to add data to an object. I'm trying to model different ‘providers', which can request information from the net to create a specific domain object, let's call it ‘event'. Most properties of events will be identical, but some providers might have additional properties: for instance, maybe two providers can also create sub-events, but a third one cannot. I'd like to be able to conditionally know if a specific property is available on a specific event or not, for example to display the event (only available properties should be displayed). For the use case of ‘one provider lets you edit the event, the others don't', I see how I can leverage typeclasses to specifically add that behavior. However, I don't know how to add data. I thought of three solutions, that I don't find ‘clean', so I'd like to have your thoughts: 1. Use nullable fields for data that is not present on all events That way, it's easy to test if some data is present or not. The code can be very straightforward, but it's not very beautiful that there are many nullable fields on every object. A slightly better solution could be to have every field be an union of the expected data and an

Unimplemented

Singleton, but that still doesn't look so good. 2. Use inheritance Create one interface per optional field, and have each provider have its own event implementation that extends the correct interfaces. This could lead to a bit of repetition, though I guess combined with delegation it could look okay. 3. Use WeakHashMap in a typeclass to store the additional information That doesn't seem very nice as well... What do you think?

This message was deleted.

How does one convert a

List

to an

arrow.fx

Stream

using the

0.11-snapshot

? IDE completion doesn't appear to offer an appropriate extension that might do this.

Hei Hei. So I am trying to make a colleague understand

IO<A>

. I thought of starting with this line :

IO<A>

is just a another way of writing

suspend () -> Either<Throwable, A>

is this true ? I grasped this from the PR Simon worked on to bring features from IO to Either using coroutines so that we don’t have to box our types which apparently is costly. I know IO has its own thread pool, works on fibres and not coroutines, but I was wondering if the above statement could be a layman’s explanation ?