oh yeah zipwith is just fundamentally incompatible with Alternative lmao

Author: UnrelatedString

src/Data/Unfoldable/Trivial/Internal.purs

@@ -42,7 +42,7 @@ import Data.Filterable
   , filterMapDefault
   )
 import Data.Either (Either(..), either)
-import Control.Alternative (class Alt, class Plus, class Alternative, (<|>))
+import Control.Alternative (class Alt, class Plus, (<|>))
 import Control.Lazy (class Lazy)
 import Test.QuickCheck.Arbitrary (class Arbitrary, class Coarbitrary, arbitrary)
 import Test.QuickCheck.Gen (sized)
@@ -210,11 +210,13 @@ instance trivialSemigroup :: Semigroup (Trivial a) where
 instance trivialMonoid :: Monoid (Trivial a) where
   mempty = none
 
--- | Zipwith; chosen over the `Monad`-compatible nondet choice used for `Array` etc.
+-- | Zipwith; chosen over the `Monad`- and `Alternative`-compatible
+-- | nondet choice used for `Array` etc.
 -- | because that would require effectively forcing one argument and either
 -- | re-evaluating it constantly or storing its elements in a real container
 -- | at which point please please please just do that without using `Trivial`.
 -- | Length is the minimum of the arguments' lengths.
+-- | (The violated `Alternative` law is distributivity.)
 instance trivialApply :: Apply Trivial where
   apply :: forall a c. Trivial (a -> c) -> Trivial a -> Trivial c
   apply tg = untrivial (untrivial eApply tg)
@@ -231,8 +233,6 @@ instance trivialApply :: Apply Trivial where
 instance trivialApplicative :: Applicative Trivial where
   pure a = unfoldr (const $ Just $ a /\ unit) unit
 
-instance trivialAlternative :: Alternative Trivial
-
 -- | Does not and cannot memoize the values being produced to compare.
 -- | Please consider using Data.List.Lazy or your strict container of choice
 -- | instead if you have any intention of using this for anything else.

test/Main.purs

@@ -61,7 +61,7 @@ import Data.Unfoldable.MaybeEmpty
   )
 
 import Data.Maybe (Maybe(..), isJust, isNothing)
-import Control.Alternative ((<|>), guard, empty, class Alternative, class Alt)
+import Control.Alternative ((<|>), guard, empty, class Alternative, class Plus, class Alt)
 import Data.Enum (class Enum, class BoundedEnum, succ, pred, upFrom, downFrom, upFromIncluding, enumFromTo)
 import Data.Tuple (snd)
 import Data.Tuple.Nested ((/\), type (/\))
@@ -216,7 +216,7 @@ appendSuite = describe "Semigroup and Alternative" do
     qc \(a :: Trivial1 Char) (b :: Trivial Char) -> arrgh1 (a `append1` b) === arrgh1 a <|> arrgh b
   it "append1' agrees with Alt Array" do
     qc \(a :: Trivial Char) (b :: Trivial1 Char) -> arrgh1 (a `append1'` b) === arrgh a <|> arrgh1 b
-  genericAlternativeLaws "Trivial" qc (Proxy :: Proxy (Trivial Int))
+  genericPlusLaws "Trivial" qc (Proxy :: Proxy (Trivial Int))
   genericAltLaws "Trivial1" qc (Proxy :: Proxy (Trivial1 Int))
   genericAlternativeLaws "MaybeEmpty NonEmptyList" qc (Proxy :: Proxy (MaybeEmpty NEL.NonEmptyList Int))
 
@@ -234,16 +234,16 @@ genericAltLaws name qc _ = describe ("Alt " <> name <> " laws") do
   it "Distributivity: f <$> (x <|> y) ≡ (f <$> x) <|> (f <$> y)" do
     qc \(f :: a -> a) (x :: t a) y -> f <$> (x <|> y) === (f <$> x) <|> (f <$> y)
 
-genericAlternativeLaws :: forall t a.
+genericPlusLaws :: forall t a.
   Eq (t a) =>
   Show (t a) =>
-  Alternative t =>
+  Plus t =>
   Arbitrary a =>
   Coarbitrary a => 
   Arbitrary (t a) =>
   Arbitrary (t (a -> a)) =>
   String -> (forall p. Testable p => p -> Aff Unit) -> Proxy (t a) -> Spec Unit
-genericAlternativeLaws name qc proxy = do
+genericPlusLaws name qc proxy = do
   genericAltLaws name qc proxy
   describe ("Plus " <> name <> " laws") do
     it "Left identity: empty <|> x ≡ x" do
@@ -252,6 +252,19 @@ genericAlternativeLaws name qc proxy = do
       qc \(x :: t a) -> x <|> empty === x
     it "Annihilation: f <$> empty ≡ empty" do
       qc \(f :: a -> a) -> f <$> empty === (empty :: t a)
+
+genericAlternativeLaws :: forall t a.
+  Eq (t a) =>
+  Show (t a) =>
+  Alternative t =>
+  Arbitrary a =>
+  Coarbitrary a => 
+  Arbitrary (t a) =>
+  Arbitrary (t (a -> a)) =>
+  String -> (forall p. Testable p => p -> Aff Unit) -> Proxy (t a) -> Spec Unit
+genericAlternativeLaws name qc proxy = do
+  genericAltLaws name qc proxy
+  genericPlusLaws name qc proxy
   describe ("Alternative " <> name <> " laws") do
     it "Distributivity: (f <|> g) <*> x ≡ (f <*> x) <|> (g <*> x)" do
       qc \(f :: t (a -> a)) g x -> (f <|> g) <*> x === (f <*> x) <|> (g <*> x)