A modern programming language that makes developers happier.

kotlinlang

What is the current suggestion to replace tupled ?

You might find this useful

<https://www.47deg.com/blog/arrow-0.13.0-release/|https://www.47deg.com/blog/arrow-0.13.0-release/>

I’ve been trying to use zip, but what I’m missing is the reified return behavior

For example I’m trying to accomplish something like this.

```suspend fun magic() {
  val (foo, bar, baz) = getDependencies().bind()
  return foo.count + bar.count + baz.count
}

suspend fun getDependencies() = parZip(
{ fooRepository.get() },
{ barRepository.get() },
{ bazRepository.get() }
)```


where each repository returns an either, if any of them fail, the left path is taken

I believe you should be able to combine them using something like:
```suspend fun dependencies(): Either&lt;Throwable, Pair&lt;String, String&gt;&gt; = either {
    parZip(
        { a().bind() },
        { b().bind() }
    ) { a, b -&gt; Pair(a, b) }
}

suspend fun a(): Either&lt;Throwable, String&gt; {
    delay(500)
    println("a")
    return Either.Right("a")
}
suspend fun b(): Either&lt;Throwable, String&gt; {
    println("b")
    return Either.Right("b")
}```
there might be a different syntax available but that's generally what I do

```suspend fun magic() = either {
  val (foo, bar, baz) = getDependencies().bind()
  return foo.count + bar.count + baz.count
}
suspend fun getDependencies() = either {
  parZip(
  { fooRepository.get().bind() },
  { barRepository.get().bind() },
  { bazRepository.get().bind() }
  ) { foo, bar, baz -&gt; Triple(foo, bar baz) } 
}```
I think this is what you're looking for. You can simply `bind()` inside `parZip` while it preserves the semantics of `either { }` and safely deals with the cancellation and concurrency within `parZip`.  So if `fooRepository.get()` returns immediately with `Left` than `barRepository.get()` and `bazRepository.get()` will get cannceled.

We deprecated/removed the aliases for `::Triple` etc since it's such a silly overload to repeat so many times

Ah too slow :joy: Exactly as <@U01CVCD9N76> mentions. We should add this to the documentation somewhere for sure.

If someone wants to contribute I'd be happy to help with whatever you need :wink:

Thanks so much you guys, I really appreciate the help :slightly_smiling_face:

Would you accept a PR that adds a method with no return that can be used like parZip, or is there something that accomplishes this already ?

for example

```either {
  parNoReturn(
    { effectfulFoo().bind() },
    { effectfulBar().bind() }
  )
}```

It would be nice to somehow delegate the bind externally, I’m not sure how you might do that though.

My imagined syntax would look something like

```parEffectfulValidatedNel(::effectfulFoo, ::effectfulBar).bind()```
where the passed functions can return Either / ValidatedNel / Validated and then the bound result would be something like ValidatedNel&lt;CustomError, Unit&gt;

Sorry, I realize this is somewhat incoherent haha

<@U01G67SHL5T> I’m not sure if no return would help us but this behavior could be encapsulated into something like `parZipEither` where the binds happen in the impl. The issue with `zip` and some of these methods is that it requires N methods for all the arities you want to support. I think people use `suspend () -&gt; Either&lt;E, A&gt;` frequent enough to justify it.