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

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

fix compile error with latest S… (compare)

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

@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`

.
So this depends on that list always being such a relation, which isn't a trivial fact but is also not hard to show.

Practically speaking, you do so with

`a: A => pairs.find(_._1 == a)`

@hrhino right, I got thrown off somehow. thanks for the patient explanation.

(I guess I was thinking about injectivity and confused it with function-ness. Flipped the arrows somehow)

`Finite a`

implies an equality notion, and surely `allValues :: [a]`

is going to give me back all distinct values.(I guess I was thinking about injectivity and confused it with function-ness. Flipped the arrows somehow)

@zhongdj this channel, not so much. What do you mean by "active"?