-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Abstractions for working with variadic functions
--   
--   Please see the README on GitHub at
--   <a>https://github.com/estatico/variadic#readme</a>
@package variadic
@version 0.0.0.0

module Control.Variadic.Varargs

-- | Glorified HList representing variadic arguments.
data family Varargs (l :: [*])
infixr 2 `Cons`

module Control.Variadic

-- | Same as <a>Variadic</a> but captures the higher-kinded type parameter
--   in the return type. Useful so we can use <a>Monad</a> and friends with
--   <a>Variadic</a> functions.
newtype VariadicT args (m :: * -> *) a
VariadicT :: Variadic args (m a) -> VariadicT args (m :: * -> *) a
[unVariadicT] :: VariadicT args (m :: * -> *) a -> Variadic args (m a)

-- | Converts a function to a <a>VariadicT</a>. Analogous to
--   <a>toVariadic</a>.
toVariadicT :: (ToVariadic x, args ~ ToVariadicArgs x, m r ~ ToVariadicReturn x) => x -> VariadicT args m r

-- | Converts a <a>VariadicT</a> to a normal function. Analogous to
--   <a>fromVariadic</a>.
fromVariadicT :: FromVariadic args (m r) => VariadicT args m r -> FromVariadicSignature args (m r)

-- | A function whose argument list is collapsed into <a>Varargs</a> and
--   shows its return type.
newtype Variadic args a
Variadic :: (Varargs args -> a) -> Variadic args a
[runVariadic] :: Variadic args a -> Varargs args -> a

-- | Resolves the argument list for a function of arbitrary arity.
type family ToVariadicArgs x :: [*]

-- | Resolves the return type for a function of arbitrary arity.
type family ToVariadicReturn x :: *

-- | Converts a function of arbitrary arity to <a>Variadic</a>.
class ToVariadic x
toVariadic :: ToVariadic x => x -> Variadic (ToVariadicArgs x) (ToVariadicReturn x)

-- | Builds a function signature given the <tt>args</tt> and return type
--   <tt>r</tt>.
type family FromVariadicSignature (args :: [*]) (r :: *) :: *

-- | Converts a <a>Variadic</a> to a normal function.
class FromVariadic args r
fromVariadic :: FromVariadic args r => Variadic args r -> FromVariadicSignature args r

-- | Convenience constraint enabling variadic.
--   
--   <tt>x</tt> is the Haskell function type, <tt>args</tt> is a type-level
--   list of arguments, <tt>r</tt> is the return type.
--   
--   Usually you'll want to use these type arguments polymorphically, e.g.
--   -
--   
--   <pre>
--   (...*&gt;)
--     :: ( Applicative m
--        , IsVariadic va args (m a)
--        , IsVariadic vb args (m b)
--        )
--     =&gt; va -&gt; vb -&gt; vb
--   va ...*&gt; vb = fromVariadicT $ toVariadicT va *&gt; toVariadicT vb
--   </pre>
type IsVariadic x args r = (ToVariadic x, args ~ ToVariadicArgs x, r ~ ToVariadicReturn x, x ~ FromVariadicSignature args r, FromVariadic args r)

-- | Analogous to <a>fmap</a> for <a>VariadicT</a> but works on vanilla
--   functions.
vmap :: (Functor f, IsVariadic va args (f a), IsVariadic vb args (f b)) => (a -> b) -> va -> vb

-- | Analogous to <a>fmap</a> for <a>VariadicT</a> but works on vanilla
--   functions.
(<$>...) :: (Functor f, IsVariadic va args (f a), IsVariadic vb args (f b)) => (a -> b) -> va -> vb

-- | Analogous to <a>void</a> for <a>VariadicT</a> but works on vanilla
--   functions.
vvoid :: (Functor f, IsVariadic va args (f a), IsVariadic vu args (f ())) => va -> vu

-- | Analogous to <a>*&gt;</a> for <a>VariadicT</a> but works on vanilla
--   functions.
(...*>) :: (Applicative m, IsVariadic va args (m a), IsVariadic vb args (m b)) => va -> vb -> vb

-- | Analogous to <a>&lt;*</a> for <a>VariadicT</a> but works on vanilla
--   functions.
(<*...) :: (Applicative m, IsVariadic va args (m a), IsVariadic vb args (m b)) => va -> vb -> va

-- | Analogous to <a>&gt;&gt;=</a> for <a>VariadicT</a> but works on
--   vanilla functions.
(...>>=) :: (Monad m, IsVariadic va args (m a), IsVariadic vb args (m b)) => va -> (a -> vb) -> vb

-- | Analogous to <a>=&lt;&lt;</a> for <a>VariadicT</a> but works on
--   vanilla functions.
(=<<...) :: (Monad m, IsVariadic va args (m a), IsVariadic vb args (m b)) => (a -> vb) -> va -> vb

-- | Analogous to <a>hoist</a> for <a>VariadicT</a> but works on vanilla
--   functions.
vhoist :: (Monad f, IsVariadic vf args (f a), IsVariadic vg args (g a)) => (forall x. f x -> g x) -> vf -> vg
instance Control.Monad.Trans.Class.MonadTrans (Control.Variadic.VariadicT args)
instance Control.Monad.Morph.MMonad (Control.Variadic.VariadicT args)
instance Control.Monad.Morph.MFunctor (Control.Variadic.VariadicT args)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Variadic.VariadicT args m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Variadic.VariadicT args m)
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Variadic.VariadicT args m)
instance Control.Variadic.FromVariadic '[] a
instance Control.Variadic.FromVariadic args a => Control.Variadic.FromVariadic (arg : args) a
instance (Control.Variadic.ToVariadicArgs a GHC.Types.~ '[], Control.Variadic.ToVariadicReturn a GHC.Types.~ a) => Control.Variadic.ToVariadic a
instance (Control.Variadic.ToVariadic o, Control.Variadic.ToVariadicArgs (i -> o) GHC.Types.~ (i : args), Control.Variadic.ToVariadicArgs o GHC.Types.~ args, Control.Variadic.ToVariadicReturn (i -> o) GHC.Types.~ Control.Variadic.ToVariadicReturn o) => Control.Variadic.ToVariadic (i -> o)

module Control.Variadic.Generic.Internal

-- | Runs <tt>hoist</tt> on the return values each field of <tt>r</tt> with
--   the given natural transformation function, ignoring the <tt>close</tt>
--   field, if it exists.
ghoist :: (Generic (r f), Generic (r g), GHoist (Rep (r f)) (Rep (r g)) f g '["close"]) => (forall x. f x -> g x) -> r f -> r g

-- | Runs <tt>hoist</tt> on the return values each field of <tt>r</tt> with
--   the given natural transformation function; no fields are ignored.
ghoist0 :: (Generic (r f), Generic (r g), GHoist (Rep (r f)) (Rep (r g)) f g '[]) => (forall x. f x -> g x) -> r f -> r g

-- | Runs <tt>hoist</tt> on the return values each field of <tt>r</tt> with
--   the given natural transformation function. A supplied of
--   <tt>ignored</tt> fields is provided to signal which fields should not
--   be transformed.
ghoist' :: (Generic (r f), Generic (r g), GHoist (Rep (r f)) (Rep (r g)) f g ignored) => proxy ignored -> (forall x. f x -> g x) -> r f -> r g
class GHoist (i :: * -> *) (o :: * -> *) (f :: * -> *) (g :: * -> *) (ignored :: [Symbol])
gghoist :: GHoist i o f g ignored => proxy ignored -> (forall x. f x -> g x) -> i p -> o p
type VerifyIgnored e a es = VerifyIgnoredGo e a es es
type family VerifyIgnoredGo e a es orig :: Constraint
type VerifyNotIgnored e a es = VerifyNotIgnoredGo e a es es
type family VerifyNotIgnoredGo e a es orig :: Constraint
instance (Control.Variadic.Generic.Internal.GHoist (GHC.Generics.K1 GHC.Generics.R i) (GHC.Generics.K1 GHC.Generics.R o) f g ignored, Control.Variadic.Generic.Internal.VerifyNotIgnored n i ignored) => Control.Variadic.Generic.Internal.GHoist (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel ('GHC.Maybe.Just n) su ss ds) (GHC.Generics.K1 GHC.Generics.R i)) (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel ('GHC.Maybe.Just n) su ss ds) (GHC.Generics.K1 GHC.Generics.R o)) f g ignored
instance Control.Variadic.Generic.Internal.VerifyIgnored n a ignored => Control.Variadic.Generic.Internal.GHoist (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel ('GHC.Maybe.Just n) su ss ds) (GHC.Generics.K1 GHC.Generics.R a)) (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel ('GHC.Maybe.Just n) su ss ds) (GHC.Generics.K1 GHC.Generics.R a)) f g ignored
instance Control.Variadic.Generic.Internal.GHoist i o f g ignored => Control.Variadic.Generic.Internal.GHoist (GHC.Generics.M1 GHC.Generics.D c i) (GHC.Generics.M1 GHC.Generics.D c o) f g ignored
instance Control.Variadic.Generic.Internal.GHoist i o f g ignored => Control.Variadic.Generic.Internal.GHoist (GHC.Generics.M1 GHC.Generics.C c i) (GHC.Generics.M1 GHC.Generics.C c o) f g ignored
instance (Control.Variadic.Generic.Internal.GHoist i1 o1 f g ignored, Control.Variadic.Generic.Internal.GHoist i2 o2 f g ignored) => Control.Variadic.Generic.Internal.GHoist (i1 GHC.Generics.:*: i2) (o1 GHC.Generics.:*: o2) f g ignored
instance (GHC.Base.Monad f, Control.Variadic.IsVariadic vf args (f a), Control.Variadic.IsVariadic vg args (g a)) => Control.Variadic.Generic.Internal.GHoist (GHC.Generics.K1 GHC.Generics.R vf) (GHC.Generics.K1 GHC.Generics.R vg) f g ignored

module Control.Variadic.Generic

-- | Runs <tt>hoist</tt> on the return values each field of <tt>r</tt> with
--   the given natural transformation function, ignoring the <tt>close</tt>
--   field, if it exists.
ghoist :: (Generic (r f), Generic (r g), GHoist (Rep (r f)) (Rep (r g)) f g '["close"]) => (forall x. f x -> g x) -> r f -> r g

-- | Runs <tt>hoist</tt> on the return values each field of <tt>r</tt> with
--   the given natural transformation function; no fields are ignored.
ghoist0 :: (Generic (r f), Generic (r g), GHoist (Rep (r f)) (Rep (r g)) f g '[]) => (forall x. f x -> g x) -> r f -> r g

-- | Runs <tt>hoist</tt> on the return values each field of <tt>r</tt> with
--   the given natural transformation function. A supplied of
--   <tt>ignored</tt> fields is provided to signal which fields should not
--   be transformed.
ghoist' :: (Generic (r f), Generic (r g), GHoist (Rep (r f)) (Rep (r g)) f g ignored) => proxy ignored -> (forall x. f x -> g x) -> r f -> r g