- 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

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"?

Hi guys, i am struggling with:

```
val foo = List(Validation.failure("bar"), Validation.success(8), Validation.success(10))
foo.sequence
```

The error says

`<console>:19: error: could not find implicit value for parameter ev: scalaz.Validation[String,Int] === G[B]`

I am trying to get `List[Int]`

or `List[String]`

(depends on existence of `Failure`

). My questions are:

- What does the error says? (After some digging I think it should say there is no
`Traversable`

instance for`Validation`

instead) - Is there any reasonable way to get the expected result?

Hi! I'm trying to migrate pureconfig to scalaz 7.3 (pureconfig/pureconfig#752) but I'm getting an error about a missing instance of `Unapply`

:

```
<console>:42: error: Implicit not found: scalaz.Unapply[scalaz.Applicative, Unit]. Unable to unapply type `Unit` into a type constructor of kind `M[_]` that is classified by the type class `scalaz.Applicative`. Check that the type class is defined by compiling `implicitly[scalaz.Applicative[type constructor]]` and review the implicits in object Unapply, which only cover common type 'shapes.'
List(validConf, invalidConf, anotherInvalidConf).traverseU { c =>
^
```

I couldn't find any migration guide or release notes for scalaz 7.3. Do I have to import something now?

`def f[F[_]](implicit E: MonadError[F, String], implicit T: MonadTell[F, Vector[String]]) = ...`

```
import scalaz._
import Scalaz._
type W[A] = Writer[Vector[String], A]
type T[A] = EitherT[W, String, A]
f[T].run.run
```

I get errors about not finding the implicits. Do I need to import something else? Is that type T making things tricky for the implicit resolution?
also switched to cats monadchronicle *drops mic*

resolvers += Resolver.sonatypeRepo("snapshots")

libraryDependencies += "org.scalaz" %% "scalaz-base" % "1804fbf6-SNAPSHOT"

libraryDependencies += "org.scalaz" %% "scalaz-base" % "1804fbf6-SNAPSHOT"

not

libraryDependencies += "org.scalaz" %% "scalaz-core" % "7.3.1"

I'm coming back to scalaz after a few years away so haven't been following anything closely

what's the roadmap for scalaz? is there one?

you all might be interested in the Scalaz Files series on my blog, which is up to four parts now https://failex.blogspot.com/

or just open your sbt project in intellij