content: module Data.Tuple.Instances where
  import Data.Foldable
  import Data.Traversable
  import Data.Tuple
  
  -- Dubious instances for tuples
  
  instance Functor Solo where
    fmap f (MkSolo a) = MkSolo (f a)
  
  instance Functor ((,) a1) where
    fmap f (a1, a) = (a1, f a)
  
  instance Functor ((,,) a1 a2) where
    fmap f (a1, a2, a) = (a1, a2, f a)
  
  instance Functor ((,,,) a1 a2 a3) where
    fmap f (a1, a2, a3, a) = (a1, a2, a3, f a)
  
  instance Functor ((,,,,) a1 a2 a3 a4) where
    fmap f (a1, a2, a3, a4, a) = (a1, a2, a3, a4, f a)
  
  instance Functor ((,,,,,) a1 a2 a3 a4 a5) where
    fmap f (a1, a2, a3, a4, a5, a) = (a1, a2, a3, a4, a5, f a)
  
  instance Functor ((,,,,,,) a1 a2 a3 a4 a5 a6) where
    fmap f (a1, a2, a3, a4, a5, a6, a) = (a1, a2, a3, a4, a5, a6, f a)
  
  instance (Monoid a1) => Applicative ((,) a1) where
    pure a = (mempty, a)
    (a1, f) <*> (a1', a) = (a1 <> a1', f a)
  
  instance (Monoid a1, Monoid a2) => Applicative ((,,) a1 a2) where
    pure a = (mempty, mempty, a)
    (a1, a2, f) <*> (a1', a2', a) = (a1 <> a1', a2 <> a2', f a)
  
  instance (Monoid a1, Monoid a2, Monoid a3) => Applicative ((,,,) a1 a2 a3) where
    pure a = (mempty, mempty, mempty, a)
    (a1, a2, a3, f) <*> (a1', a2', a3', a) = (a1 <> a1', a2 <> a2', a3 <> a3', f a)
  
  instance Monoid a1 => Monad ((,) a1) where
    (a1, a) >>= k = case k a of (a1', b) -> (a1 <> a1', b)
  
  instance (Monoid a1, Monoid a2) => Monad ((,,) a1 a2) where
    (a1, a2, a) >>= k = case k a of (a1', a2', b) -> (a1 <> a1', a2 <> a2', b)
  
  instance (Monoid a1, Monoid a2, Monoid a3) => Monad ((,,,) a1 a2 a3) where
    (a1, a2, a3, a) >>= k = case k a of (a1', a2', a3', b) -> (a1 <> a1', a2 <> a2', a3 <> a3', b)
  
  instance Foldable Solo where
    foldMap f (MkSolo a) = f a
    foldr f z (MkSolo a) = f a z
    length _ = 1
    null _ = False
  
  instance Foldable ((,) a) where
    foldMap f (_, y) = f y
    foldr f z (_, y) = f y z
    length _  = 1
    null _ = False
  
  instance Traversable Solo where
    traverse f (MkSolo a) = MkSolo <$> f a
  
  instance Traversable ((,) a) where
    traverse f (x, y) = (,) x <$> f y
      
  