Is there a standard name or implementation of the "purely applicative Either"?

Question

I frequently find use for what I call the "purely applicative Either", i.e. Either with the Applicative instance available so long as we don't implement a Monad instance as well.

newtype AEither e a = AEither { unAEither :: Either e a }
  deriving Functor

-- technically we only need Semigroup
instance Monoid e => Applicative (AEither e) where
  pure a = AEither (pure a)
  AEither e1 <*> AEither e2 = AEither (combine e1 e2) where
    combine (Right f) (Right a) = Right (f a)
    combine (Left m1) (Left m2) = Left (m1 <> m2)
    combine (Left m ) _         = Left m
    combine _         (Left m ) = Left m

It's a really useful Applicative as it provides a more powerful notion of "summarization of error" than Either's Monad instance can do. To that end, I find myself implementing it over-and-over again.

Is there a standard instance somewhere? Is there even a standard name?

If you submit a patch to my `errors` library then I will accept it. — Gabriella Gonzalez, Mar 08 '14 at 03:00
I may end up doing that. I really feel like this belongs in some kind of more general `applicatives` package along with the purely applicative product, though. — J. Abrahamson, Mar 08 '14 at 03:40
Kinda related: https://github.com/ekmett/semigroups/issues/25 — Roman Cheplyaka, Mar 08 '14 at 08:44
That seems identical, and semigroups is a good place for it. I've been calling it `Collect` internally. — J. Abrahamson, Mar 08 '14 at 15:05

score 7 · Answer 1 · answered Mar 08 '14 at 03:04

This looks pretty similar to the AccValidation type in the validation package: http://hackage.haskell.org/package/validation-0.3.1/docs/Data-Validation.html

Edit:

In particular the following instance declaration:

instance Semigroup err => Apply (AccValidation err) where
  AccFailure e1 <.> AccFailure e2 =
    AccFailure (e1 <> e2)
  AccFailure e1 <.> AccSuccess _  =
    AccFailure e1
  AccSuccess _  <.> AccFailure e2 =
    AccFailure e2
  AccSuccess f  <.> AccSuccess a  =
    AccSuccess (f a)

That's the same one! I like that this depends only upon `Semigroup` as that's all that's strictly necessary, surely. — J. Abrahamson, Mar 08 '14 at 03:44

Is there a standard name or implementation of the "purely applicative Either"?

1 Answers1

Linked