I think it might be useful to have functions like this:

asRight :: forall e a f. Alternative f => Either e a -> f a
asRight (Right x) = pure x
asRight _ = empty

asLeft :: forall e a f. Alternative f => Either e a -> f e
asLeft (Left x) = pure x
asLeft _ = empty

let me know if this is desired addition and will open PR. (are names fine?)

A recent version of Data.Either moved fromRight and fromLeft to no longer be be partial but to provide a default. Perhaps these should be a Data.Either.Partial.from* version as can be seen with: purescript/purescript-strings#128

Would love to see a lazy note, in the spirit purescript-maybe's lazy functions (maybe' and fromMaybe')

note' :: forall a b. (Unit -> a) -> Maybe b -> Either a b

from base (https://hackage.haskell.org/package/base-4.11.1.0/docs/Data-Either.html):

partitionEithers :: [Either a b] -> ([a], [b])

suggested PS equivalent:

partition :: forall f a b. Foldable f => f (Either a b) -> Tuple (f a) (f b)

A Semiring is supposed to form a commutative monoid under addition, but:

> Left "hello" + Left " world" :: Either String Int
(Left "hello")

> Left " world" + Left "hello" :: Either String Int
(Left " world")

See discussion in purescript/documentation#211

With the current instance, we have:

> import Data.Either
> import Data.Either.Inject
> x = Left 0 :: Either Int String
> inj x :: Either Int String
Error found:
in module $PSCI
at <internal> line 0, column 0 - line 0, column 0

  No type class instance was found for
                                                 
    Data.Either.Inject.Inject (Either Int String)
                              String             
                                                 

while applying a function inj
  of type Inject t0 t1 => t0 -> t1
  to argument x
while checking that expression inj x
  has type Either Int String
in value declaration it

where t0 is an unknown type
      t1 is an unknown type

See https://github.com/purescript/documentation/blob/master/errors/NoInstanceFound.md for more information,
or to contribute content related to this error.

If being able to have inj specialise to the identity function is important, should injectReflexive go first? Alternatively, should we consider just dropping the instance?

$ test $TRAVIS_TAG && echo $GITHUB_TOKEN | pulp login && echo y | pulp publish --no-push
Please obtain a GitHub personal access token at:
  https://github.com/settings/tokens/new
No scopes are required, so don't check any of the boxes.

After you've done that, paste it in here: Successfully authenticated as garyb.
* ERROR: Your git working tree is dirty. Please commit or stash your changes first.

https://s3.amazonaws.com/archive.travis-ci.org/jobs/246280467/log.txt?X-Amz-Expires=30&X-Amz-Date=20170623T212624Z&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAJRYRXRSVGNKPKO5A/20170623/us-east-1/s3/aws4_request&X-Amz-SignedHeaders=host&X-Amz-Signature=e07ad853543fdea2e8fd453428ce9473079819c918c2cbbbfe216855bdcc87cc

toEither3 :: Either3 Number Number Number -> Color should be named fromEither3 as it takes Either3 (it's not returning Either3).

fromEither3 :: Color -> Either3 Number Number Number returns Either and it should be named toEither3.

Am I messing something?

data Color = Red Number | Green Number | Blue Number
-- 
toEither3 :: Either3 Number Number Number -> Color
toEither3 = either3 Red Green Blue

fromEither3 :: Color -> Either3 Number Number Number
fromEither3 (Red   v) = in1 v
fromEither3 (Green v) = in2 v
fromEither3 (Blue  v) = in3 v

see

Oftentimes, I find myself wanting to convert an Either to perform error accumulation. Currently I have a custom function that uses the either function, but it's kind of cumbersome. Maybe we should add a function here or in purescript-validation?

I'd like to have

fromLeft :: forall a b. a -> Either a b -> a
fromRight ::  forall a b. b -> Either a b -> b

over the current partial

fromLeft :: Partial => forall a b. Either a b -> a
fromLeft :: Partial => forall a b. Either a b -> b

as typing either (const a) identity becomes old rather quickly and I need these functions much more frequently than their partial counterparts. I'm not sure how confusing it would be to define these functions differently in two modules in this package, but even if don't rename the old ones I think this would be a win.

Should be fromRight instead of fromLeft here:

https://github.com/purescript/purescript-either/blob/master/src/Data/Either/Unsafe.purs#L20

https://github.com/purescript/purescript-either/blob/master/src/Data/Either.purs#L161

Forgive me if I'm totally wrong (sorry!), but I think that line should be:

f <<= Right x = Right (f (Right x))

I know it's a relatively minor thing, but this issue is more to cement my understanding of the Extend class... Thanks!

I'm new to all this but I believe this is a typo.
https://github.com/purescript/purescript-either/blob/v4.1.1/src/Data/Either.purs#L60
I think it should be Left f, not Left x.

For consistency with Data.Tuple.Nested and Data.Functor.Coproduct.