-- |
-- Module      : Foundation.Tuple
-- License     : BSD-style
-- Maintainer  : Vincent Hanquez <vincent@snarc.org>
-- Stability   : experimental
-- Portability : portable
--
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
module Foundation.Tuple
    ( Tuple2(..)
    , Tuple3(..)
    , Tuple4(..)
    , Fstable(..)
    , Sndable(..)
    , Thdable(..)
    ) where

import Basement.Compat.Base
import Basement.Compat.Bifunctor
import Foundation.Primitive

-- | Strict tuple (a,b)
data Tuple2 a b = Tuple2 !a !b
    deriving (Int -> Tuple2 a b -> ShowS
[Tuple2 a b] -> ShowS
Tuple2 a b -> String
(Int -> Tuple2 a b -> ShowS)
-> (Tuple2 a b -> String)
-> ([Tuple2 a b] -> ShowS)
-> Show (Tuple2 a b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. (Show a, Show b) => Int -> Tuple2 a b -> ShowS
forall a b. (Show a, Show b) => [Tuple2 a b] -> ShowS
forall a b. (Show a, Show b) => Tuple2 a b -> String
showList :: [Tuple2 a b] -> ShowS
$cshowList :: forall a b. (Show a, Show b) => [Tuple2 a b] -> ShowS
show :: Tuple2 a b -> String
$cshow :: forall a b. (Show a, Show b) => Tuple2 a b -> String
showsPrec :: Int -> Tuple2 a b -> ShowS
$cshowsPrec :: forall a b. (Show a, Show b) => Int -> Tuple2 a b -> ShowS
Show,Tuple2 a b -> Tuple2 a b -> Bool
(Tuple2 a b -> Tuple2 a b -> Bool)
-> (Tuple2 a b -> Tuple2 a b -> Bool) -> Eq (Tuple2 a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b. (Eq a, Eq b) => Tuple2 a b -> Tuple2 a b -> Bool
/= :: Tuple2 a b -> Tuple2 a b -> Bool
$c/= :: forall a b. (Eq a, Eq b) => Tuple2 a b -> Tuple2 a b -> Bool
== :: Tuple2 a b -> Tuple2 a b -> Bool
$c== :: forall a b. (Eq a, Eq b) => Tuple2 a b -> Tuple2 a b -> Bool
Eq,Eq (Tuple2 a b)
Eq (Tuple2 a b)
-> (Tuple2 a b -> Tuple2 a b -> Ordering)
-> (Tuple2 a b -> Tuple2 a b -> Bool)
-> (Tuple2 a b -> Tuple2 a b -> Bool)
-> (Tuple2 a b -> Tuple2 a b -> Bool)
-> (Tuple2 a b -> Tuple2 a b -> Bool)
-> (Tuple2 a b -> Tuple2 a b -> Tuple2 a b)
-> (Tuple2 a b -> Tuple2 a b -> Tuple2 a b)
-> Ord (Tuple2 a b)
Tuple2 a b -> Tuple2 a b -> Bool
Tuple2 a b -> Tuple2 a b -> Ordering
Tuple2 a b -> Tuple2 a b -> Tuple2 a b
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a b. (Ord a, Ord b) => Eq (Tuple2 a b)
forall a b. (Ord a, Ord b) => Tuple2 a b -> Tuple2 a b -> Bool
forall a b. (Ord a, Ord b) => Tuple2 a b -> Tuple2 a b -> Ordering
forall a b.
(Ord a, Ord b) =>
Tuple2 a b -> Tuple2 a b -> Tuple2 a b
min :: Tuple2 a b -> Tuple2 a b -> Tuple2 a b
$cmin :: forall a b.
(Ord a, Ord b) =>
Tuple2 a b -> Tuple2 a b -> Tuple2 a b
max :: Tuple2 a b -> Tuple2 a b -> Tuple2 a b
$cmax :: forall a b.
(Ord a, Ord b) =>
Tuple2 a b -> Tuple2 a b -> Tuple2 a b
>= :: Tuple2 a b -> Tuple2 a b -> Bool
$c>= :: forall a b. (Ord a, Ord b) => Tuple2 a b -> Tuple2 a b -> Bool
> :: Tuple2 a b -> Tuple2 a b -> Bool
$c> :: forall a b. (Ord a, Ord b) => Tuple2 a b -> Tuple2 a b -> Bool
<= :: Tuple2 a b -> Tuple2 a b -> Bool
$c<= :: forall a b. (Ord a, Ord b) => Tuple2 a b -> Tuple2 a b -> Bool
< :: Tuple2 a b -> Tuple2 a b -> Bool
$c< :: forall a b. (Ord a, Ord b) => Tuple2 a b -> Tuple2 a b -> Bool
compare :: Tuple2 a b -> Tuple2 a b -> Ordering
$ccompare :: forall a b. (Ord a, Ord b) => Tuple2 a b -> Tuple2 a b -> Ordering
$cp1Ord :: forall a b. (Ord a, Ord b) => Eq (Tuple2 a b)
Ord,Typeable,Typeable (Tuple2 a b)
DataType
Constr
Typeable (Tuple2 a b)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Tuple2 a b -> c (Tuple2 a b))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Tuple2 a b))
-> (Tuple2 a b -> Constr)
-> (Tuple2 a b -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Tuple2 a b)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Tuple2 a b)))
-> ((forall b. Data b => b -> b) -> Tuple2 a b -> Tuple2 a b)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r)
-> (forall u. (forall d. Data d => d -> u) -> Tuple2 a b -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Tuple2 a b -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b))
-> Data (Tuple2 a b)
Tuple2 a b -> DataType
Tuple2 a b -> Constr
(forall b. Data b => b -> b) -> Tuple2 a b -> Tuple2 a b
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple2 a b -> c (Tuple2 a b)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple2 a b)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple2 a b))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tuple2 a b -> u
forall u. (forall d. Data d => d -> u) -> Tuple2 a b -> [u]
forall a b. (Data a, Data b) => Typeable (Tuple2 a b)
forall a b. (Data a, Data b) => Tuple2 a b -> DataType
forall a b. (Data a, Data b) => Tuple2 a b -> Constr
forall a b.
(Data a, Data b) =>
(forall b. Data b => b -> b) -> Tuple2 a b -> Tuple2 a b
forall a b u.
(Data a, Data b) =>
Int -> (forall d. Data d => d -> u) -> Tuple2 a b -> u
forall a b u.
(Data a, Data b) =>
(forall d. Data d => d -> u) -> Tuple2 a b -> [u]
forall a b r r'.
(Data a, Data b) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r
forall a b r r'.
(Data a, Data b) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r
forall a b (m :: * -> *).
(Data a, Data b, Monad m) =>
(forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
forall a b (m :: * -> *).
(Data a, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
forall a b (c :: * -> *).
(Data a, Data b) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple2 a b)
forall a b (c :: * -> *).
(Data a, Data b) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple2 a b -> c (Tuple2 a b)
forall a b (t :: * -> *) (c :: * -> *).
(Data a, Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Tuple2 a b))
forall a b (t :: * -> * -> *) (c :: * -> *).
(Data a, Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple2 a b))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple2 a b)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple2 a b -> c (Tuple2 a b)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Tuple2 a b))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple2 a b))
$cTuple2 :: Constr
$tTuple2 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
$cgmapMo :: forall a b (m :: * -> *).
(Data a, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
gmapMp :: (forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
$cgmapMp :: forall a b (m :: * -> *).
(Data a, Data b, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
gmapM :: (forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
$cgmapM :: forall a b (m :: * -> *).
(Data a, Data b, Monad m) =>
(forall d. Data d => d -> m d) -> Tuple2 a b -> m (Tuple2 a b)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Tuple2 a b -> u
$cgmapQi :: forall a b u.
(Data a, Data b) =>
Int -> (forall d. Data d => d -> u) -> Tuple2 a b -> u
gmapQ :: (forall d. Data d => d -> u) -> Tuple2 a b -> [u]
$cgmapQ :: forall a b u.
(Data a, Data b) =>
(forall d. Data d => d -> u) -> Tuple2 a b -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r
$cgmapQr :: forall a b r r'.
(Data a, Data b) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r
$cgmapQl :: forall a b r r'.
(Data a, Data b) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple2 a b -> r
gmapT :: (forall b. Data b => b -> b) -> Tuple2 a b -> Tuple2 a b
$cgmapT :: forall a b.
(Data a, Data b) =>
(forall b. Data b => b -> b) -> Tuple2 a b -> Tuple2 a b
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple2 a b))
$cdataCast2 :: forall a b (t :: * -> * -> *) (c :: * -> *).
(Data a, Data b, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple2 a b))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Tuple2 a b))
$cdataCast1 :: forall a b (t :: * -> *) (c :: * -> *).
(Data a, Data b, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Tuple2 a b))
dataTypeOf :: Tuple2 a b -> DataType
$cdataTypeOf :: forall a b. (Data a, Data b) => Tuple2 a b -> DataType
toConstr :: Tuple2 a b -> Constr
$ctoConstr :: forall a b. (Data a, Data b) => Tuple2 a b -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple2 a b)
$cgunfold :: forall a b (c :: * -> *).
(Data a, Data b) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple2 a b)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple2 a b -> c (Tuple2 a b)
$cgfoldl :: forall a b (c :: * -> *).
(Data a, Data b) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple2 a b -> c (Tuple2 a b)
$cp1Data :: forall a b. (Data a, Data b) => Typeable (Tuple2 a b)
Data,(forall x. Tuple2 a b -> Rep (Tuple2 a b) x)
-> (forall x. Rep (Tuple2 a b) x -> Tuple2 a b)
-> Generic (Tuple2 a b)
forall x. Rep (Tuple2 a b) x -> Tuple2 a b
forall x. Tuple2 a b -> Rep (Tuple2 a b) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a b x. Rep (Tuple2 a b) x -> Tuple2 a b
forall a b x. Tuple2 a b -> Rep (Tuple2 a b) x
$cto :: forall a b x. Rep (Tuple2 a b) x -> Tuple2 a b
$cfrom :: forall a b x. Tuple2 a b -> Rep (Tuple2 a b) x
Generic)

instance (NormalForm a, NormalForm b) => NormalForm (Tuple2 a b) where
    toNormalForm :: Tuple2 a b -> ()
toNormalForm (Tuple2 a
a b
b) = a -> ()
forall a. NormalForm a => a -> ()
toNormalForm a
a () -> () -> ()
`seq` b -> ()
forall a. NormalForm a => a -> ()
toNormalForm b
b
instance Bifunctor Tuple2 where
  bimap :: (a -> b) -> (c -> d) -> Tuple2 a c -> Tuple2 b d
bimap a -> b
f c -> d
g (Tuple2 a
a c
b) = b -> d -> Tuple2 b d
forall a b. a -> b -> Tuple2 a b
Tuple2 (a -> b
f a
a) (c -> d
g c
b)

-- | Strict tuple (a,b,c)
data Tuple3 a b c = Tuple3 !a !b !c
    deriving (Int -> Tuple3 a b c -> ShowS
[Tuple3 a b c] -> ShowS
Tuple3 a b c -> String
(Int -> Tuple3 a b c -> ShowS)
-> (Tuple3 a b c -> String)
-> ([Tuple3 a b c] -> ShowS)
-> Show (Tuple3 a b c)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b c.
(Show a, Show b, Show c) =>
Int -> Tuple3 a b c -> ShowS
forall a b c. (Show a, Show b, Show c) => [Tuple3 a b c] -> ShowS
forall a b c. (Show a, Show b, Show c) => Tuple3 a b c -> String
showList :: [Tuple3 a b c] -> ShowS
$cshowList :: forall a b c. (Show a, Show b, Show c) => [Tuple3 a b c] -> ShowS
show :: Tuple3 a b c -> String
$cshow :: forall a b c. (Show a, Show b, Show c) => Tuple3 a b c -> String
showsPrec :: Int -> Tuple3 a b c -> ShowS
$cshowsPrec :: forall a b c.
(Show a, Show b, Show c) =>
Int -> Tuple3 a b c -> ShowS
Show,Tuple3 a b c -> Tuple3 a b c -> Bool
(Tuple3 a b c -> Tuple3 a b c -> Bool)
-> (Tuple3 a b c -> Tuple3 a b c -> Bool) -> Eq (Tuple3 a b c)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b c.
(Eq a, Eq b, Eq c) =>
Tuple3 a b c -> Tuple3 a b c -> Bool
/= :: Tuple3 a b c -> Tuple3 a b c -> Bool
$c/= :: forall a b c.
(Eq a, Eq b, Eq c) =>
Tuple3 a b c -> Tuple3 a b c -> Bool
== :: Tuple3 a b c -> Tuple3 a b c -> Bool
$c== :: forall a b c.
(Eq a, Eq b, Eq c) =>
Tuple3 a b c -> Tuple3 a b c -> Bool
Eq,Eq (Tuple3 a b c)
Eq (Tuple3 a b c)
-> (Tuple3 a b c -> Tuple3 a b c -> Ordering)
-> (Tuple3 a b c -> Tuple3 a b c -> Bool)
-> (Tuple3 a b c -> Tuple3 a b c -> Bool)
-> (Tuple3 a b c -> Tuple3 a b c -> Bool)
-> (Tuple3 a b c -> Tuple3 a b c -> Bool)
-> (Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c)
-> (Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c)
-> Ord (Tuple3 a b c)
Tuple3 a b c -> Tuple3 a b c -> Bool
Tuple3 a b c -> Tuple3 a b c -> Ordering
Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a b c. (Ord a, Ord b, Ord c) => Eq (Tuple3 a b c)
forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Bool
forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Ordering
forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c
min :: Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c
$cmin :: forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c
max :: Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c
$cmax :: forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Tuple3 a b c
>= :: Tuple3 a b c -> Tuple3 a b c -> Bool
$c>= :: forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Bool
> :: Tuple3 a b c -> Tuple3 a b c -> Bool
$c> :: forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Bool
<= :: Tuple3 a b c -> Tuple3 a b c -> Bool
$c<= :: forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Bool
< :: Tuple3 a b c -> Tuple3 a b c -> Bool
$c< :: forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Bool
compare :: Tuple3 a b c -> Tuple3 a b c -> Ordering
$ccompare :: forall a b c.
(Ord a, Ord b, Ord c) =>
Tuple3 a b c -> Tuple3 a b c -> Ordering
$cp1Ord :: forall a b c. (Ord a, Ord b, Ord c) => Eq (Tuple3 a b c)
Ord,Typeable,Typeable (Tuple3 a b c)
DataType
Constr
Typeable (Tuple3 a b c)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Tuple3 a b c -> c (Tuple3 a b c))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Tuple3 a b c))
-> (Tuple3 a b c -> Constr)
-> (Tuple3 a b c -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Tuple3 a b c)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Tuple3 a b c)))
-> ((forall b. Data b => b -> b) -> Tuple3 a b c -> Tuple3 a b c)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r)
-> (forall u. (forall d. Data d => d -> u) -> Tuple3 a b c -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Tuple3 a b c -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c))
-> Data (Tuple3 a b c)
Tuple3 a b c -> DataType
Tuple3 a b c -> Constr
(forall b. Data b => b -> b) -> Tuple3 a b c -> Tuple3 a b c
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple3 a b c -> c (Tuple3 a b c)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple3 a b c)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tuple3 a b c -> u
forall u. (forall d. Data d => d -> u) -> Tuple3 a b c -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r
forall a b c. (Data a, Data b, Data c) => Typeable (Tuple3 a b c)
forall a b c. (Data a, Data b, Data c) => Tuple3 a b c -> DataType
forall a b c. (Data a, Data b, Data c) => Tuple3 a b c -> Constr
forall a b c.
(Data a, Data b, Data c) =>
(forall b. Data b => b -> b) -> Tuple3 a b c -> Tuple3 a b c
forall a b c u.
(Data a, Data b, Data c) =>
Int -> (forall d. Data d => d -> u) -> Tuple3 a b c -> u
forall a b c u.
(Data a, Data b, Data c) =>
(forall d. Data d => d -> u) -> Tuple3 a b c -> [u]
forall a b c r r'.
(Data a, Data b, Data c) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r
forall a b c r r'.
(Data a, Data b, Data c) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r
forall a b c (m :: * -> *).
(Data a, Data b, Data c, Monad m) =>
(forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
forall a b c (m :: * -> *).
(Data a, Data b, Data c, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
forall a b c (c :: * -> *).
(Data a, Data b, Data c) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple3 a b c)
forall a b c (c :: * -> *).
(Data a, Data b, Data c) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple3 a b c -> c (Tuple3 a b c)
forall a b c (t :: * -> *) (c :: * -> *).
(Data a, Data b, Data c, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Tuple3 a b c))
forall a b c (t :: * -> * -> *) (c :: * -> *).
(Data a, Data b, Data c, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple3 a b c))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple3 a b c)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple3 a b c -> c (Tuple3 a b c)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Tuple3 a b c))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple3 a b c))
$cTuple3 :: Constr
$tTuple3 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
$cgmapMo :: forall a b c (m :: * -> *).
(Data a, Data b, Data c, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
gmapMp :: (forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
$cgmapMp :: forall a b c (m :: * -> *).
(Data a, Data b, Data c, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
gmapM :: (forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
$cgmapM :: forall a b c (m :: * -> *).
(Data a, Data b, Data c, Monad m) =>
(forall d. Data d => d -> m d) -> Tuple3 a b c -> m (Tuple3 a b c)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Tuple3 a b c -> u
$cgmapQi :: forall a b c u.
(Data a, Data b, Data c) =>
Int -> (forall d. Data d => d -> u) -> Tuple3 a b c -> u
gmapQ :: (forall d. Data d => d -> u) -> Tuple3 a b c -> [u]
$cgmapQ :: forall a b c u.
(Data a, Data b, Data c) =>
(forall d. Data d => d -> u) -> Tuple3 a b c -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r
$cgmapQr :: forall a b c r r'.
(Data a, Data b, Data c) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r
$cgmapQl :: forall a b c r r'.
(Data a, Data b, Data c) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple3 a b c -> r
gmapT :: (forall b. Data b => b -> b) -> Tuple3 a b c -> Tuple3 a b c
$cgmapT :: forall a b c.
(Data a, Data b, Data c) =>
(forall b. Data b => b -> b) -> Tuple3 a b c -> Tuple3 a b c
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple3 a b c))
$cdataCast2 :: forall a b c (t :: * -> * -> *) (c :: * -> *).
(Data a, Data b, Data c, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple3 a b c))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Tuple3 a b c))
$cdataCast1 :: forall a b c (t :: * -> *) (c :: * -> *).
(Data a, Data b, Data c, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Tuple3 a b c))
dataTypeOf :: Tuple3 a b c -> DataType
$cdataTypeOf :: forall a b c. (Data a, Data b, Data c) => Tuple3 a b c -> DataType
toConstr :: Tuple3 a b c -> Constr
$ctoConstr :: forall a b c. (Data a, Data b, Data c) => Tuple3 a b c -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple3 a b c)
$cgunfold :: forall a b c (c :: * -> *).
(Data a, Data b, Data c) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple3 a b c)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple3 a b c -> c (Tuple3 a b c)
$cgfoldl :: forall a b c (c :: * -> *).
(Data a, Data b, Data c) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple3 a b c -> c (Tuple3 a b c)
$cp1Data :: forall a b c. (Data a, Data b, Data c) => Typeable (Tuple3 a b c)
Data,(forall x. Tuple3 a b c -> Rep (Tuple3 a b c) x)
-> (forall x. Rep (Tuple3 a b c) x -> Tuple3 a b c)
-> Generic (Tuple3 a b c)
forall x. Rep (Tuple3 a b c) x -> Tuple3 a b c
forall x. Tuple3 a b c -> Rep (Tuple3 a b c) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a b c x. Rep (Tuple3 a b c) x -> Tuple3 a b c
forall a b c x. Tuple3 a b c -> Rep (Tuple3 a b c) x
$cto :: forall a b c x. Rep (Tuple3 a b c) x -> Tuple3 a b c
$cfrom :: forall a b c x. Tuple3 a b c -> Rep (Tuple3 a b c) x
Generic)

instance (NormalForm a, NormalForm b, NormalForm c) => NormalForm (Tuple3 a b c) where
    toNormalForm :: Tuple3 a b c -> ()
toNormalForm (Tuple3 a
a b
b c
c) = a -> ()
forall a. NormalForm a => a -> ()
toNormalForm a
a () -> () -> ()
`seq` b -> ()
forall a. NormalForm a => a -> ()
toNormalForm b
b () -> () -> ()
`seq` c -> ()
forall a. NormalForm a => a -> ()
toNormalForm c
c

-- | Strict tuple (a,b,c,d)
data Tuple4 a b c d = Tuple4 !a !b !c !d
    deriving (Int -> Tuple4 a b c d -> ShowS
[Tuple4 a b c d] -> ShowS
Tuple4 a b c d -> String
(Int -> Tuple4 a b c d -> ShowS)
-> (Tuple4 a b c d -> String)
-> ([Tuple4 a b c d] -> ShowS)
-> Show (Tuple4 a b c d)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b c d.
(Show a, Show b, Show c, Show d) =>
Int -> Tuple4 a b c d -> ShowS
forall a b c d.
(Show a, Show b, Show c, Show d) =>
[Tuple4 a b c d] -> ShowS
forall a b c d.
(Show a, Show b, Show c, Show d) =>
Tuple4 a b c d -> String
showList :: [Tuple4 a b c d] -> ShowS
$cshowList :: forall a b c d.
(Show a, Show b, Show c, Show d) =>
[Tuple4 a b c d] -> ShowS
show :: Tuple4 a b c d -> String
$cshow :: forall a b c d.
(Show a, Show b, Show c, Show d) =>
Tuple4 a b c d -> String
showsPrec :: Int -> Tuple4 a b c d -> ShowS
$cshowsPrec :: forall a b c d.
(Show a, Show b, Show c, Show d) =>
Int -> Tuple4 a b c d -> ShowS
Show,Tuple4 a b c d -> Tuple4 a b c d -> Bool
(Tuple4 a b c d -> Tuple4 a b c d -> Bool)
-> (Tuple4 a b c d -> Tuple4 a b c d -> Bool)
-> Eq (Tuple4 a b c d)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b c d.
(Eq a, Eq b, Eq c, Eq d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Bool
/= :: Tuple4 a b c d -> Tuple4 a b c d -> Bool
$c/= :: forall a b c d.
(Eq a, Eq b, Eq c, Eq d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Bool
== :: Tuple4 a b c d -> Tuple4 a b c d -> Bool
$c== :: forall a b c d.
(Eq a, Eq b, Eq c, Eq d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Bool
Eq,Eq (Tuple4 a b c d)
Eq (Tuple4 a b c d)
-> (Tuple4 a b c d -> Tuple4 a b c d -> Ordering)
-> (Tuple4 a b c d -> Tuple4 a b c d -> Bool)
-> (Tuple4 a b c d -> Tuple4 a b c d -> Bool)
-> (Tuple4 a b c d -> Tuple4 a b c d -> Bool)
-> (Tuple4 a b c d -> Tuple4 a b c d -> Bool)
-> (Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d)
-> (Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d)
-> Ord (Tuple4 a b c d)
Tuple4 a b c d -> Tuple4 a b c d -> Bool
Tuple4 a b c d -> Tuple4 a b c d -> Ordering
Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a b c d. (Ord a, Ord b, Ord c, Ord d) => Eq (Tuple4 a b c d)
forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Bool
forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Ordering
forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d
min :: Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d
$cmin :: forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d
max :: Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d
$cmax :: forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Tuple4 a b c d
>= :: Tuple4 a b c d -> Tuple4 a b c d -> Bool
$c>= :: forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Bool
> :: Tuple4 a b c d -> Tuple4 a b c d -> Bool
$c> :: forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Bool
<= :: Tuple4 a b c d -> Tuple4 a b c d -> Bool
$c<= :: forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Bool
< :: Tuple4 a b c d -> Tuple4 a b c d -> Bool
$c< :: forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Bool
compare :: Tuple4 a b c d -> Tuple4 a b c d -> Ordering
$ccompare :: forall a b c d.
(Ord a, Ord b, Ord c, Ord d) =>
Tuple4 a b c d -> Tuple4 a b c d -> Ordering
$cp1Ord :: forall a b c d. (Ord a, Ord b, Ord c, Ord d) => Eq (Tuple4 a b c d)
Ord,Typeable,Typeable (Tuple4 a b c d)
DataType
Constr
Typeable (Tuple4 a b c d)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Tuple4 a b c d -> c (Tuple4 a b c d))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Tuple4 a b c d))
-> (Tuple4 a b c d -> Constr)
-> (Tuple4 a b c d -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Tuple4 a b c d)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Tuple4 a b c d)))
-> ((forall b. Data b => b -> b)
    -> Tuple4 a b c d -> Tuple4 a b c d)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Tuple4 a b c d -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Tuple4 a b c d -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Tuple4 a b c d -> m (Tuple4 a b c d))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Tuple4 a b c d -> m (Tuple4 a b c d))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Tuple4 a b c d -> m (Tuple4 a b c d))
-> Data (Tuple4 a b c d)
Tuple4 a b c d -> DataType
Tuple4 a b c d -> Constr
(forall b. Data b => b -> b) -> Tuple4 a b c d -> Tuple4 a b c d
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple4 a b c d -> c (Tuple4 a b c d)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple4 a b c d)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> Tuple4 a b c d -> u
forall u. (forall d. Data d => d -> u) -> Tuple4 a b c d -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r
forall a b c d.
(Data a, Data b, Data c, Data d) =>
Typeable (Tuple4 a b c d)
forall a b c d.
(Data a, Data b, Data c, Data d) =>
Tuple4 a b c d -> DataType
forall a b c d.
(Data a, Data b, Data c, Data d) =>
Tuple4 a b c d -> Constr
forall a b c d.
(Data a, Data b, Data c, Data d) =>
(forall b. Data b => b -> b) -> Tuple4 a b c d -> Tuple4 a b c d
forall a b c d u.
(Data a, Data b, Data c, Data d) =>
Int -> (forall d. Data d => d -> u) -> Tuple4 a b c d -> u
forall a b c d u.
(Data a, Data b, Data c, Data d) =>
(forall d. Data d => d -> u) -> Tuple4 a b c d -> [u]
forall a b c d r r'.
(Data a, Data b, Data c, Data d) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r
forall a b c d r r'.
(Data a, Data b, Data c, Data d) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r
forall a b c d (m :: * -> *).
(Data a, Data b, Data c, Data d, Monad m) =>
(forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
forall a b c d (m :: * -> *).
(Data a, Data b, Data c, Data d, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
forall a b c d (c :: * -> *).
(Data a, Data b, Data c, Data d) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple4 a b c d)
forall a b c d (c :: * -> *).
(Data a, Data b, Data c, Data d) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple4 a b c d -> c (Tuple4 a b c d)
forall a b c d (t :: * -> *) (c :: * -> *).
(Data a, Data b, Data c, Data d, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Tuple4 a b c d))
forall a b c d (t :: * -> * -> *) (c :: * -> *).
(Data a, Data b, Data c, Data d, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple4 a b c d))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple4 a b c d)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple4 a b c d -> c (Tuple4 a b c d)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Tuple4 a b c d))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple4 a b c d))
$cTuple4 :: Constr
$tTuple4 :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
$cgmapMo :: forall a b c d (m :: * -> *).
(Data a, Data b, Data c, Data d, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
gmapMp :: (forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
$cgmapMp :: forall a b c d (m :: * -> *).
(Data a, Data b, Data c, Data d, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
gmapM :: (forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
$cgmapM :: forall a b c d (m :: * -> *).
(Data a, Data b, Data c, Data d, Monad m) =>
(forall d. Data d => d -> m d)
-> Tuple4 a b c d -> m (Tuple4 a b c d)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Tuple4 a b c d -> u
$cgmapQi :: forall a b c d u.
(Data a, Data b, Data c, Data d) =>
Int -> (forall d. Data d => d -> u) -> Tuple4 a b c d -> u
gmapQ :: (forall d. Data d => d -> u) -> Tuple4 a b c d -> [u]
$cgmapQ :: forall a b c d u.
(Data a, Data b, Data c, Data d) =>
(forall d. Data d => d -> u) -> Tuple4 a b c d -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r
$cgmapQr :: forall a b c d r r'.
(Data a, Data b, Data c, Data d) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r
$cgmapQl :: forall a b c d r r'.
(Data a, Data b, Data c, Data d) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tuple4 a b c d -> r
gmapT :: (forall b. Data b => b -> b) -> Tuple4 a b c d -> Tuple4 a b c d
$cgmapT :: forall a b c d.
(Data a, Data b, Data c, Data d) =>
(forall b. Data b => b -> b) -> Tuple4 a b c d -> Tuple4 a b c d
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple4 a b c d))
$cdataCast2 :: forall a b c d (t :: * -> * -> *) (c :: * -> *).
(Data a, Data b, Data c, Data d, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Tuple4 a b c d))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Tuple4 a b c d))
$cdataCast1 :: forall a b c d (t :: * -> *) (c :: * -> *).
(Data a, Data b, Data c, Data d, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Tuple4 a b c d))
dataTypeOf :: Tuple4 a b c d -> DataType
$cdataTypeOf :: forall a b c d.
(Data a, Data b, Data c, Data d) =>
Tuple4 a b c d -> DataType
toConstr :: Tuple4 a b c d -> Constr
$ctoConstr :: forall a b c d.
(Data a, Data b, Data c, Data d) =>
Tuple4 a b c d -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple4 a b c d)
$cgunfold :: forall a b c d (c :: * -> *).
(Data a, Data b, Data c, Data d) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tuple4 a b c d)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple4 a b c d -> c (Tuple4 a b c d)
$cgfoldl :: forall a b c d (c :: * -> *).
(Data a, Data b, Data c, Data d) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tuple4 a b c d -> c (Tuple4 a b c d)
$cp1Data :: forall a b c d.
(Data a, Data b, Data c, Data d) =>
Typeable (Tuple4 a b c d)
Data,(forall x. Tuple4 a b c d -> Rep (Tuple4 a b c d) x)
-> (forall x. Rep (Tuple4 a b c d) x -> Tuple4 a b c d)
-> Generic (Tuple4 a b c d)
forall x. Rep (Tuple4 a b c d) x -> Tuple4 a b c d
forall x. Tuple4 a b c d -> Rep (Tuple4 a b c d) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a b c d x. Rep (Tuple4 a b c d) x -> Tuple4 a b c d
forall a b c d x. Tuple4 a b c d -> Rep (Tuple4 a b c d) x
$cto :: forall a b c d x. Rep (Tuple4 a b c d) x -> Tuple4 a b c d
$cfrom :: forall a b c d x. Tuple4 a b c d -> Rep (Tuple4 a b c d) x
Generic)

instance (NormalForm a, NormalForm b, NormalForm c, NormalForm d)
      => NormalForm (Tuple4 a b c d) where
    toNormalForm :: Tuple4 a b c d -> ()
toNormalForm (Tuple4 a
a b
b c
c d
d) = a -> ()
forall a. NormalForm a => a -> ()
toNormalForm a
a () -> () -> ()
`seq` b -> ()
forall a. NormalForm a => a -> ()
toNormalForm b
b () -> () -> ()
`seq` c -> ()
forall a. NormalForm a => a -> ()
toNormalForm c
c () -> () -> ()
`seq` d -> ()
forall a. NormalForm a => a -> ()
toNormalForm d
d

-- | Class of product types that have a first element
class Fstable a where
    type ProductFirst a
    fst :: a -> ProductFirst a

-- | Class of product types that have a second element
class Sndable a where
    type ProductSecond a
    snd :: a -> ProductSecond a

-- | Class of product types that have a third element
class Thdable a where
    type ProductThird a
    thd :: a -> ProductThird a

instance Fstable (a,b) where
    type ProductFirst (a,b) = a
    fst :: (a, b) -> ProductFirst (a, b)
fst (a
a,b
_) = a
ProductFirst (a, b)
a
instance Fstable (a,b,c) where
    type ProductFirst (a,b,c) = a
    fst :: (a, b, c) -> ProductFirst (a, b, c)
fst (a
a,b
_,c
_) = a
ProductFirst (a, b, c)
a
instance Fstable (a,b,c,d) where
    type ProductFirst (a,b,c,d) = a
    fst :: (a, b, c, d) -> ProductFirst (a, b, c, d)
fst (a
a,b
_,c
_,d
_) = a
ProductFirst (a, b, c, d)
a
instance Fstable (Tuple2 a b) where
    type ProductFirst (Tuple2 a b) = a
    fst :: Tuple2 a b -> ProductFirst (Tuple2 a b)
fst (Tuple2 a
a b
_) = a
ProductFirst (Tuple2 a b)
a
instance Fstable (Tuple3 a b c) where
    type ProductFirst (Tuple3 a b c) = a
    fst :: Tuple3 a b c -> ProductFirst (Tuple3 a b c)
fst (Tuple3 a
a b
_ c
_) = a
ProductFirst (Tuple3 a b c)
a
instance Fstable (Tuple4 a b c d) where
    type ProductFirst (Tuple4 a b c d) = a
    fst :: Tuple4 a b c d -> ProductFirst (Tuple4 a b c d)
fst (Tuple4 a
a b
_ c
_ d
_) = a
ProductFirst (Tuple4 a b c d)
a

instance Sndable (a,b) where
    type ProductSecond (a,b) = b
    snd :: (a, b) -> ProductSecond (a, b)
snd (a
_,b
b) = b
ProductSecond (a, b)
b
instance Sndable (a,b,c) where
    type ProductSecond (a,b,c) = b
    snd :: (a, b, c) -> ProductSecond (a, b, c)
snd (a
_,b
b,c
_) = b
ProductSecond (a, b, c)
b
instance Sndable (a,b,c,d) where
    type ProductSecond (a,b,c,d) = b
    snd :: (a, b, c, d) -> ProductSecond (a, b, c, d)
snd (a
_,b
b,c
_,d
_) = b
ProductSecond (a, b, c, d)
b
instance Sndable (Tuple2 a b) where
    type ProductSecond (Tuple2 a b) = b
    snd :: Tuple2 a b -> ProductSecond (Tuple2 a b)
snd (Tuple2 a
_ b
b) = b
ProductSecond (Tuple2 a b)
b
instance Sndable (Tuple3 a b c) where
    type ProductSecond (Tuple3 a b c) = b
    snd :: Tuple3 a b c -> ProductSecond (Tuple3 a b c)
snd (Tuple3 a
_ b
b c
_) = b
ProductSecond (Tuple3 a b c)
b
instance Sndable (Tuple4 a b c d) where
    type ProductSecond (Tuple4 a b c d) = b
    snd :: Tuple4 a b c d -> ProductSecond (Tuple4 a b c d)
snd (Tuple4 a
_ b
b c
_ d
_) = b
ProductSecond (Tuple4 a b c d)
b

instance Thdable (a,b,c) where
    type ProductThird (a,b,c) = c
    thd :: (a, b, c) -> ProductThird (a, b, c)
thd (a
_,b
_,c
c) = c
ProductThird (a, b, c)
c
instance Thdable (a,b,c,d) where
    type ProductThird (a,b,c,d) = c
    thd :: (a, b, c, d) -> ProductThird (a, b, c, d)
thd (a
_,b
_,c
c,d
_) = c
ProductThird (a, b, c, d)
c
instance Thdable (Tuple3 a b c) where
    type ProductThird (Tuple3 a b c) = c
    thd :: Tuple3 a b c -> ProductThird (Tuple3 a b c)
thd (Tuple3 a
_ b
_ c
c) = c
ProductThird (Tuple3 a b c)
c
instance Thdable (Tuple4 a b c d) where
    type ProductThird (Tuple4 a b c d) = c
    thd :: Tuple4 a b c d -> ProductThird (Tuple4 a b c d)
thd (Tuple4 a
_ b
_ c
c d
_) = c
ProductThird (Tuple4 a b c d)
c