- Join over
**1.5M+ people** - Join over
**100K+ communities** - Free
**without limits** - Create
**your own community**

- Feb 19 13:41@jdegoes banned @Patrick160893
- Jan 31 18:49ShermMeister starred scalaz/scalaz
- Jan 31 05:21jonyroy starred scalaz/scalaz
- Jan 30 21:14
- Jan 30 20:34jmg-duarte starred scalaz/scalaz
- Jan 30 18:43rajkirankv starred scalaz/scalaz
- Jan 30 09:07llater starred scalaz/scalaz
- Jan 30 07:41AgustaRC starred scalaz/scalaz
- Jan 30 04:16LiFangzhe starred scalaz/scalaz
- Jan 30 03:09xuwei-k labeled #2036
- Jan 29 19:11tigrus commented #2036
- Jan 29 19:11tigrus closed #2036
- Jan 29 13:32NeQuissimus commented #2036
- Jan 29 12:10
xuwei-k on 7.2.x

fix compile error with latest S… (compare)

- Jan 29 06:30tigrus commented #2036
- Jan 29 02:07NeQuissimus commented #2036
- Jan 28 20:41tigrus commented #2036
- Jan 28 19:12plokhotnyuk commented #2037
- Jan 28 17:09hrhino review_requested #2037
- Jan 28 15:32puffnfresh commented #2037

can anyone shed light on how the

`Foldable`

instance for scala's standard `Stream`

is able to short circuit in a case like this?```
import scalaz.{\/, Foldable}
import scalaz.std.stream._
Foldable[Stream].foldRight(Stream(1,2,3,4,5,6), \/.right[Unit, List[Int]](Nil)) { (i, acc) =>
println(i)
if (i > 3) \/.left[Unit, List[Int]](()) else acc.map(_ :+ i)
}
/*
1
2
3
4
res0: Unit \/ List[Int] = -\/(())
*/
```

Hello :) @tonymorris_gitlab @emilypi

We would like to move a project in scalaz to zio org: https://github.com/scalaz/scalaz-config

Who could help us to do that?

We would like to move a project in scalaz to zio org: https://github.com/scalaz/scalaz-config

Who could help us to do that?

@wi101 that'd probably be the most expedient way. Sorry for the inconvenience

Thanks

or is there a standard about this?

! 1 + 1

`error: illegal cyclic reference involving type a`

`Int = 2`

IList is simpler than std lib List and truly immutable (List is mutable under the hood). And it doesn't suffer from the a huge traits hierarchy. Unpopular opinion in this room but I think invarience has no benefit and even worse type inference. Anothe disadvantage is the lack of interop.

I was wondering if it would be unlawful but this implementation seems fair enough

```
implicit val intMaxInstance = Monoid.instance[Int @@ Tags.Max]({
case (a : (Int @@ Tags.Max),b : (Int @@ Tags.Max)) =>
val m : Int = Math.max(a.asInstanceOf[Int], b.asInstanceOf[Int])
Tags.Max(m)
}, Tags.Max(Int.MinValue))
```

My colleague was trying to write a function `def something(f: A => F[B]): F[A => B]`

We established that function cannot exist, because it proposes that any applicative is a monad:

```
trait Nope[F[_]] {
def applicative: Applicative[F]
def nope[A, B](f: A => F[B]): F[A => B]
def flatMap[A, B](f: A => F[B])(x: F[A]): F[B] =
applicative.ap(nope(f))(x)
}
```

But before we established it cannot exist, I searched for it, and found

`assemble :: forall b f . (Finite a, Applicative f) => (a -> f b) -> f (a -> b)`

Could somebody please walk me through what that type is, and what it says?

(Assuming as usual little is off topic in this channel and that WTF questions are okay)

That function just evaluates

`a -> f b`

for all possible `a`

s, getting an `f [(a,b)]`

, and then turns the `[(a, b)]`

into a function `a -> b`

by viewing the list of pairs as a relation.
So it's very limited: you can't do it unless you know all possible

`a`

s, and the resulting applicative effect is just the combination of all possible effects resulting from `a -> f b`

.