{-# LANGUAGE CPP #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE Safe #-}
{-# LANGUAGE TypeFamilies #-}
module Data.Tuple.Append.Class
(
TupleAddL ((<++)),
TupleAddR ((++>)),
TupleAppend ((+++)),
SequenceTuple (sequenceTupleA, sequenceTupleA_),
)
where
import Data.Foldable (sequenceA_)
#if MIN_VERSION_base(4,9,0)
import Data.List.NonEmpty(NonEmpty((:|)), (<|))
#endif
#if MIN_VERSION_base(4,11,0)
#elif MIN_VERSION_base(4,9,0)
import Data.Semigroup((<>))
#endif
import Data.Functor (($>))
class TupleAddL x 𝐯 x𝐯 | x 𝐯 -> x𝐯, x𝐯 -> x, x𝐯 -> 𝐯 where
infixr 5 <++
(<++) ::
x ->
𝐯 ->
x𝐯
class TupleAddR 𝐯 x 𝐯x | 𝐯 x -> 𝐯x, 𝐯x -> 𝐯, 𝐯x -> x where
infixl 5 ++>
(++>) ::
𝐯 ->
x ->
𝐯x
class TupleAppend 𝐮 𝐯 𝐮𝐯 | 𝐮 𝐯 -> 𝐮𝐯, 𝐮 𝐮𝐯 -> 𝐯, 𝐯 𝐮𝐯 -> 𝐮 where
infixr 5 +++
(+++) ::
𝐮 ->
𝐯 ->
𝐮𝐯
class Applicative f => SequenceTuple f f𝐮 𝐮 | f𝐮 -> f 𝐮, f f𝐮 -> 𝐮, f 𝐮 -> f𝐮 where
sequenceTupleA ::
f𝐮 ->
f 𝐮
default sequenceTupleA :: (Traversable t, 𝐮 ~ t b, f𝐮 ~ t (f b)) => f𝐮 -> f 𝐮
sequenceTupleA = forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA
sequenceTupleA_ ::
f𝐮 ->
f ()
sequenceTupleA_ f𝐮
x = forall (f :: * -> *) f𝐮 𝐮. SequenceTuple f f𝐮 𝐮 => f𝐮 -> f 𝐮
sequenceTupleA f𝐮
x forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ()
{-# MINIMAL sequenceTupleA #-}
instance Applicative f => SequenceTuple f [f a] [a] where
sequenceTupleA :: [f a] -> f [a]
sequenceTupleA = forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA
sequenceTupleA_ :: [f a] -> f ()
sequenceTupleA_ = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Applicative f) =>
t (f a) -> f ()
sequenceA_
instance TupleAddL x [x] [x] where
<++ :: x -> [x] -> [x]
(<++) = (:)
instance TupleAddR [x] x [x] where
[x]
xs ++> :: [x] -> x -> [x]
++> x
x = [x]
xs forall a. [a] -> [a] -> [a]
++ [x
x]
instance TupleAppend [u] [u] [u] where
+++ :: [u] -> [u] -> [u]
(+++) = forall a. [a] -> [a] -> [a]
(++)
#if MIN_VERSION_base(4,9,0)
instance TupleAddL x (NonEmpty x) (NonEmpty x) where
<++ :: x -> NonEmpty x -> NonEmpty x
(<++) = forall x. x -> NonEmpty x -> NonEmpty x
(<|)
instance TupleAddR (NonEmpty x) x (NonEmpty x) where
~(x
x :| [x]
xs) ++> :: NonEmpty x -> x -> NonEmpty x
++> x
xn = x
x forall a. a -> [a] -> NonEmpty a
:| ([x]
xs forall 𝐯 x 𝐯x. TupleAddR 𝐯 x 𝐯x => 𝐯 -> x -> 𝐯x
++> x
xn)
instance TupleAppend (NonEmpty x) (NonEmpty x) (NonEmpty x) where
+++ :: NonEmpty x -> NonEmpty x -> NonEmpty x
(+++) = forall a. Semigroup a => a -> a -> a
(<>)
instance Applicative f => SequenceTuple f (NonEmpty (f a)) (NonEmpty a) where
sequenceTupleA :: NonEmpty (f a) -> f (NonEmpty a)
sequenceTupleA = forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA
sequenceTupleA_ :: NonEmpty (f a) -> f ()
sequenceTupleA_ = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Applicative f) =>
t (f a) -> f ()
sequenceA_
#endif