{-# LANGUAGE AllowAmbiguousTypes #-}
-- | Convenience functions for the 'Labeled' 'ProviderList' effect.
--
-- @since 2.7.0.0
module Effectful.Labeled.Provider.List
  ( -- * Effect
    ProviderList(..)
  , ProviderList_

    -- ** Handlers
  , runProviderList
  , runProviderList_

    -- ** Operations
  , provideList
  , provideList_
  , provideListWith
  , provideListWith_

    -- * Re-exports
  , Labeled(..)
  , type (++)
  , KnownSubset
  ) where

import Data.Coerce
import Data.Functor.Identity

import Effectful
import Effectful.Dispatch.Dynamic
import Effectful.Labeled
import Effectful.Provider.List (ProviderList(..), ProviderList_)
import Effectful.Provider.List qualified as P

-- | Run the labeled 'ProviderList' effect with a given handler.
runProviderList
  :: forall label providedEs input f es a
   . (HasCallStack, KnownSubset providedEs (providedEs ++ es))
  => (forall r. HasCallStack => input -> Eff (providedEs ++ es) r -> Eff es (f r))
  -- ^ The handler.
  -> Eff (Labeled label (ProviderList providedEs input f) : es) a
  -> Eff es a
runProviderList :: forall {k} (label :: k) (providedEs :: [Effect]) input
       (f :: Type -> Type) (es :: [Effect]) a.
(HasCallStack, KnownSubset providedEs (providedEs ++ es)) =>
(forall r.
 HasCallStack =>
 input -> Eff (providedEs ++ es) r -> Eff es (f r))
-> Eff (Labeled label (ProviderList providedEs input f) : es) a
-> Eff es a
runProviderList forall r.
HasCallStack =>
input -> Eff (providedEs ++ es) r -> Eff es (f r)
provider = forall (label :: k) (e :: Effect) (es :: [Effect]) a b.
HasCallStack =>
(Eff (e : es) a -> Eff es b)
-> Eff (Labeled label e : es) a -> Eff es b
forall {k} (label :: k) (e :: Effect) (es :: [Effect]) a b.
HasCallStack =>
(Eff (e : es) a -> Eff es b)
-> Eff (Labeled label e : es) a -> Eff es b
runLabeled @label ((forall r.
 HasCallStack =>
 input -> Eff (providedEs ++ es) r -> Eff es (f r))
-> Eff (ProviderList providedEs input f : es) a -> Eff es a
forall (providedEs :: [Effect]) input (f :: Type -> Type)
       (es :: [Effect]) a.
(HasCallStack, KnownSubset providedEs (providedEs ++ es)) =>
(forall r.
 HasCallStack =>
 input -> Eff (providedEs ++ es) r -> Eff es (f r))
-> Eff (ProviderList providedEs input f : es) a -> Eff es a
P.runProviderList input -> Eff (providedEs ++ es) r -> Eff es (f r)
forall r.
HasCallStack =>
input -> Eff (providedEs ++ es) r -> Eff es (f r)
provider)

-- | Run the labeled 'ProviderList' effect with a given handler that doesn't
-- change its return type.
runProviderList_
  :: forall label providedEs input es a
   . (HasCallStack, KnownSubset providedEs (providedEs ++ es))
  => (forall r. HasCallStack => input -> Eff (providedEs ++ es) r -> Eff es r)
  -- ^ The handler.
  -> Eff (Labeled label (ProviderList_ providedEs input) : es) a
  -> Eff es a
runProviderList_ :: forall {k} (label :: k) (providedEs :: [Effect]) input
       (es :: [Effect]) a.
(HasCallStack, KnownSubset providedEs (providedEs ++ es)) =>
(forall r.
 HasCallStack =>
 input -> Eff (providedEs ++ es) r -> Eff es r)
-> Eff (Labeled label (ProviderList_ providedEs input) : es) a
-> Eff es a
runProviderList_ forall r.
HasCallStack =>
input -> Eff (providedEs ++ es) r -> Eff es r
provider = forall (label :: k) (e :: Effect) (es :: [Effect]) a b.
HasCallStack =>
(Eff (e : es) a -> Eff es b)
-> Eff (Labeled label e : es) a -> Eff es b
forall {k} (label :: k) (e :: Effect) (es :: [Effect]) a b.
HasCallStack =>
(Eff (e : es) a -> Eff es b)
-> Eff (Labeled label e : es) a -> Eff es b
runLabeled @label ((forall r.
 HasCallStack =>
 input -> Eff (providedEs ++ es) r -> Eff es r)
-> Eff (ProviderList_ providedEs input : es) a -> Eff es a
forall (providedEs :: [Effect]) input (es :: [Effect]) a.
(HasCallStack, KnownSubset providedEs (providedEs ++ es)) =>
(forall r.
 HasCallStack =>
 input -> Eff (providedEs ++ es) r -> Eff es r)
-> Eff (ProviderList_ providedEs input : es) a -> Eff es a
P.runProviderList_ input -> Eff (providedEs ++ es) r -> Eff es r
forall r.
HasCallStack =>
input -> Eff (providedEs ++ es) r -> Eff es r
provider)

----------------------------------------
-- Operations

-- | Run the handler.
provideList
  :: forall label providedEs f es a
   . (HasCallStack, Labeled label (ProviderList providedEs () f) :> es)
  => Eff (providedEs ++ es) a
  -> Eff es (f a)
provideList :: forall {k} (label :: k) (providedEs :: [Effect])
       (f :: Type -> Type) (es :: [Effect]) a.
(HasCallStack,
 Labeled label (ProviderList providedEs () f) :> es) =>
Eff (providedEs ++ es) a -> Eff es (f a)
provideList = Labeled label (ProviderList providedEs () f) (Eff es) (f a)
-> Eff es (f a)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Labeled label (ProviderList providedEs () f) (Eff es) (f a)
 -> Eff es (f a))
-> (Eff (providedEs ++ es) a
    -> Labeled label (ProviderList providedEs () f) (Eff es) (f a))
-> Eff (providedEs ++ es) a
-> Eff es (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (label :: k) (e :: Effect) (a :: Type -> Type) b.
e a b -> Labeled label e a b
forall {k} (label :: k) (e :: Effect) (a :: Type -> Type) b.
e a b -> Labeled label e a b
Labeled @label (ProviderList providedEs () f (Eff es) (f a)
 -> Labeled label (ProviderList providedEs () f) (Eff es) (f a))
-> (Eff (providedEs ++ es) a
    -> ProviderList providedEs () f (Eff es) (f a))
-> Eff (providedEs ++ es) a
-> Labeled label (ProviderList providedEs () f) (Eff es) (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (providedEs :: [Effect]) input (f :: Type -> Type)
       (es :: [Effect]) a1.
input
-> Eff (providedEs ++ es) a1
-> ProviderList providedEs input f (Eff es) (f a1)
P.ProvideListWith @providedEs ()

-- | Run the handler with unchanged return type.
provideList_
  :: forall label providedEs es a
   . (HasCallStack, Labeled label (ProviderList_ providedEs ()) :> es)
  => Eff (providedEs ++ es) a
  -> Eff es a
provideList_ :: forall {k} (label :: k) (providedEs :: [Effect]) (es :: [Effect])
       a.
(HasCallStack,
 Labeled label (ProviderList_ providedEs ()) :> es) =>
Eff (providedEs ++ es) a -> Eff es a
provideList_ = Eff es (Identity a) -> Eff es a
forall (es :: [Effect]) a. Eff es (Identity a) -> Eff es a
dropIdentity (Eff es (Identity a) -> Eff es a)
-> (Eff (providedEs ++ es) a -> Eff es (Identity a))
-> Eff (providedEs ++ es) a
-> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Labeled label (ProviderList_ providedEs ()) (Eff es) (Identity a)
-> Eff es (Identity a)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Labeled label (ProviderList_ providedEs ()) (Eff es) (Identity a)
 -> Eff es (Identity a))
-> (Eff (providedEs ++ es) a
    -> Labeled
         label (ProviderList_ providedEs ()) (Eff es) (Identity a))
-> Eff (providedEs ++ es) a
-> Eff es (Identity a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (label :: k) (e :: Effect) (a :: Type -> Type) b.
e a b -> Labeled label e a b
forall {k} (label :: k) (e :: Effect) (a :: Type -> Type) b.
e a b -> Labeled label e a b
Labeled @label (ProviderList providedEs () Identity (Eff es) (Identity a)
 -> Labeled
      label (ProviderList_ providedEs ()) (Eff es) (Identity a))
-> (Eff (providedEs ++ es) a
    -> ProviderList providedEs () Identity (Eff es) (Identity a))
-> Eff (providedEs ++ es) a
-> Labeled
     label (ProviderList_ providedEs ()) (Eff es) (Identity a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (providedEs :: [Effect]) input (f :: Type -> Type)
       (es :: [Effect]) a1.
input
-> Eff (providedEs ++ es) a1
-> ProviderList providedEs input f (Eff es) (f a1)
P.ProvideListWith @providedEs ()

-- | Run the handler with a given input.
provideListWith
  :: forall label providedEs input f es a
   . (HasCallStack, Labeled label (ProviderList providedEs input f) :> es)
  => input
  -- ^ The input to the handler.
  -> Eff (providedEs ++ es) a
  -> Eff es (f a)
provideListWith :: forall {k} (label :: k) (providedEs :: [Effect]) input
       (f :: Type -> Type) (es :: [Effect]) a.
(HasCallStack,
 Labeled label (ProviderList providedEs input f) :> es) =>
input -> Eff (providedEs ++ es) a -> Eff es (f a)
provideListWith input
input = Labeled label (ProviderList providedEs input f) (Eff es) (f a)
-> Eff es (f a)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Labeled label (ProviderList providedEs input f) (Eff es) (f a)
 -> Eff es (f a))
-> (Eff (providedEs ++ es) a
    -> Labeled label (ProviderList providedEs input f) (Eff es) (f a))
-> Eff (providedEs ++ es) a
-> Eff es (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (label :: k) (e :: Effect) (a :: Type -> Type) b.
e a b -> Labeled label e a b
forall {k} (label :: k) (e :: Effect) (a :: Type -> Type) b.
e a b -> Labeled label e a b
Labeled @label (ProviderList providedEs input f (Eff es) (f a)
 -> Labeled label (ProviderList providedEs input f) (Eff es) (f a))
-> (Eff (providedEs ++ es) a
    -> ProviderList providedEs input f (Eff es) (f a))
-> Eff (providedEs ++ es) a
-> Labeled label (ProviderList providedEs input f) (Eff es) (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (providedEs :: [Effect]) input (f :: Type -> Type)
       (es :: [Effect]) a1.
input
-> Eff (providedEs ++ es) a1
-> ProviderList providedEs input f (Eff es) (f a1)
P.ProvideListWith @providedEs input
input

-- | Run the handler that doesn't change its return type with a given input.
provideListWith_
  :: forall label providedEs input es a
   . (HasCallStack, Labeled label (ProviderList_ providedEs input) :> es)
  => input
  -- ^ The input to the handler.
  -> Eff (providedEs ++ es) a
  -> Eff es a
provideListWith_ :: forall {k} (label :: k) (providedEs :: [Effect]) input
       (es :: [Effect]) a.
(HasCallStack,
 Labeled label (ProviderList_ providedEs input) :> es) =>
input -> Eff (providedEs ++ es) a -> Eff es a
provideListWith_ input
input =
  Eff es (Identity a) -> Eff es a
forall (es :: [Effect]) a. Eff es (Identity a) -> Eff es a
dropIdentity (Eff es (Identity a) -> Eff es a)
-> (Eff (providedEs ++ es) a -> Eff es (Identity a))
-> Eff (providedEs ++ es) a
-> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Labeled
  label (ProviderList_ providedEs input) (Eff es) (Identity a)
-> Eff es (Identity a)
forall (e :: Effect) (es :: [Effect]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Labeled
   label (ProviderList_ providedEs input) (Eff es) (Identity a)
 -> Eff es (Identity a))
-> (Eff (providedEs ++ es) a
    -> Labeled
         label (ProviderList_ providedEs input) (Eff es) (Identity a))
-> Eff (providedEs ++ es) a
-> Eff es (Identity a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (label :: k) (e :: Effect) (a :: Type -> Type) b.
e a b -> Labeled label e a b
forall {k} (label :: k) (e :: Effect) (a :: Type -> Type) b.
e a b -> Labeled label e a b
Labeled @label (ProviderList providedEs input Identity (Eff es) (Identity a)
 -> Labeled
      label (ProviderList_ providedEs input) (Eff es) (Identity a))
-> (Eff (providedEs ++ es) a
    -> ProviderList providedEs input Identity (Eff es) (Identity a))
-> Eff (providedEs ++ es) a
-> Labeled
     label (ProviderList_ providedEs input) (Eff es) (Identity a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (providedEs :: [Effect]) input (f :: Type -> Type)
       (es :: [Effect]) a1.
input
-> Eff (providedEs ++ es) a1
-> ProviderList providedEs input f (Eff es) (f a1)
P.ProvideListWith @providedEs input
input

----------------------------------------
-- Helpers

dropIdentity :: Eff es (Identity a) -> Eff es a
dropIdentity :: forall (es :: [Effect]) a. Eff es (Identity a) -> Eff es a
dropIdentity = Eff es (Identity a) -> Eff es a
forall a b. Coercible a b => a -> b
coerce