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


-- | Run computations that depend on one or more elements in a stream.
--   
--   Run computations that depend on one or more elements in a stream. It
--   lets you model dependencies as an applicative functor.
@package withdependencies
@version 0.3.1


-- | This module is a glorified wrapper over <a>lookup</a>. It let you
--   define computations in an applicative way that "require" some optional
--   values, defined by an identifier.
--   
--   Once defined, it is possible to extract the list of identifiers, and
--   also to evaluate the computation.
--   
--   <pre>
--   let computation = ( (+) &lt;$&gt; require "a" &lt;*&gt; require "b" )
--   &gt; computeRequire M.empty computation :: Maybe Int
--   Nothing
--   &gt; computeRequire (M.fromList [("a", 12), ("b", 15)]) computation :: Maybe Int
--   Just 27
--   &gt; computeRequire (M.fromList [("a", 12), ("c", 15)]) computation :: Maybe Int
--   Nothing
--   </pre>
module Control.Dependency

-- | The main data type, used to model a computation that requires a list
--   of named parameters (the "identifier"), that are linked to a
--   "content", and that will yield a result of type "a".
data Require identifier content a

-- | This operator let you "require" a value in a computation.
require :: Eq identifier => identifier -> Require identifier content content
requireFilter :: (identifier -> Bool) -> Require identifier content (identifier, content)

-- | Will drop the result unless the predicate is true.
guardResult :: (result -> Bool) -> Require identifier content result -> Require identifier content result

-- | Evaluate a computation, given a map of key/values for possible
--   parameters.
computeRequire :: forall identifier content f a. (Ord identifier, Eq identifier, Monad f, Alternative f) => [(identifier, content)] -> Require identifier content a -> f a

-- | Evaluate a computation, given a map of key/values for possible
--   parameters. Returns an empty result when alternatives are present and
--   the first choice failed.
computeRequireIntermediate :: forall identifier content f a. (Ord identifier, Eq identifier, Monad f, Alternative f) => [(identifier, content)] -> Require identifier content a -> f a

-- | Checks if a computation can be completed given a set of known
--   identifiers.
isComputable :: (Ord identifier, Eq identifier) => Set identifier -> Require identifier content a -> Bool
triggersAnalyzer :: identifier -> Require identifier content a -> Bool
instance GHC.Enum.Bounded Control.Dependency.ComputeMode
instance GHC.Enum.Enum Control.Dependency.ComputeMode
instance GHC.Classes.Ord Control.Dependency.ComputeMode
instance GHC.Classes.Eq Control.Dependency.ComputeMode
instance GHC.Show.Show Control.Dependency.ComputeMode
instance GHC.Base.Functor (Control.Dependency.Require identifier content)
instance GHC.Base.Applicative (Control.Dependency.Require identifier content)
instance GHC.Base.Alternative (Control.Dependency.Require identifier content)
instance Data.Profunctor.Unsafe.Profunctor (Control.Dependency.Require identifier)


-- | Runs computations depending on some values coming from a conduit. The
--   computations are defined in applicative fashion.
--   
--   <pre>
--   test :: IO [Int]
--   test = inp =$ cnd $$ CL.consume
--       where
--           inp = sourceDirectory "/etc"
--           cnd :: ConduitT String Int IO ()
--           cnd = withRequirement (map Once comps) id (fmap length . readFile)
--           comps :: [Require String Int Int]
--           comps = [ (+) &lt;$&gt; require "/etc/passwd" &lt;*&gt; require "/etc/passwd"
--                   , (-) &lt;$&gt; require "/etc/resolv.conf" &lt;*&gt; require "/etc/nonexistent"
--                   , require "/etc/hosts"
--                   ]
--   </pre>
module Data.Conduit.Require

-- | Given a stream of values, from which an identifier and a content can
--   be extracted, runs a list of computation that depend on these.
--   
--   Each computation's output is <a>yield</a>ed downstream.
--   
--   When all computations have been run, the conduit finishes processing.
withRequirement :: (Ord identifier, Eq identifier, Monad m, Functor m) => [(RunMode, Require identifier content x)] -> (a -> identifier) -> (a -> m content) -> ConduitT a x m ()

-- | This allows the user to parameter what happends once a requirement is
--   fulfilled.
data RunMode

-- | The requirement will be reset, and can be run multiple times
Reset :: RunMode

-- | The requirement can only run once, first answer is kept on alts
Once :: RunMode

-- | The requirement can only run once, best answer is kept on alts
OnceCorrect :: RunMode
instance GHC.Show.Show Data.Conduit.Require.RunMode