setKey,

  runHTTP

  runHTTP,
  runSign,
  Sign,

import Effectful.Fail (Fail)
import Effectful.Reader.Static (Reader, ask, runReader, local)

import Effectful.Fail (Fail, runFail)

  }
data Req 
  = POST {
    url :: Text,
    payload :: LBS.ByteString
  }
  | GET {
    url :: Text

data Sign :: Effect where
  GetKey :: Sign m S.Signer
type instance DispatchOf Sign = 'Dynamic
runSign :: S.KeySource s => s -> Eff (Sign : es) a -> Eff es a
runSign key = interpret $ \_ -> \case
  GetKey -> return (S.toSigner key)

  SetKey :: S.Signer -> m a -> HTTP m a
  Post   :: LBS.ByteString -> Text -> HTTP m Response
  Get    :: Text -> HTTP m Response

  Exec :: Req -> S.Signer -> HTTP m (Either String Response)

post :: (HTTP :> es, JSON.ToJSON body) => body -> Text -> Eff es Response
post body = send . Post (JSON.encode body)

post :: (HTTP :> es, Fail :> es, Sign :> es, JSON.ToJSON body) => body -> Text -> Eff es Response
post body url = do
  key <- send GetKey
  res <- send (Exec (POST { payload = JSON.encode body, url }) key)
  either fail return res

get :: (HTTP :> es) => Text -> Eff es Response
get = send . Get
setKey :: (S.KeySource s, HTTP :> es) => s -> Eff es a -> Eff es a
setKey key rest = send (SetKey (S.toSigner key) rest)

get :: (HTTP :> es, Fail :> es, Sign :> es) => Text -> Eff es Response
get url = do
  key <- send GetKey
  res <- send (Exec (GET { url }) key)
  either fail return res

  :: (IOE :> es, Log :> es, Fail :> es, Reader Manager :> es)
  => (S.KeySource k)
  => k

  :: (IOE :> es, Log :> es)
  => Manager

runHTTP src = reinterpret (runReader (S.toSigner src)) $ \env -> \case
  SetKey key rest -> localSeqUnlift env $ \unlift ->
    local (const key) (unlift rest)
  Post payload url -> do
    signer <- ask
    req <- withSeqEffToIO (parse url)
    ask >>= execute signer
      (req { method = "POST" })
      (Just $ BS.toStrict payload)
  Get url -> do
    signer <- ask
    req <- withSeqEffToIO (parse url)
    ask >>= execute signer req Nothing
  where 

runHTTP manager = interpret $ \_ -> \case
  Exec req signer -> runFail $ do
    request <- withSeqEffToIO (parse req.url)
    case req of
      GET {} -> execute signer request Nothing manager
      POST { payload } -> execute signer
        (request { method = "POST" })
        (Just $ BS.toStrict payload)
        manager
  where

  res <- httpLbs req client

  res <- withSeqEffToIO $ \unlift -> do
    httpLbs req client `catch` \(exc :: HttpException) -> do
      unlift (fail ("HTTP exception: " <> show exc))

import Puppy.Protocol.HTTP (HTTP, post, get, Response (..))

import Puppy.Protocol.HTTP (HTTP, post, get, Response (..), Sign)

    Sign :> es,

    Sign :> es,

  = Fetch { eff :: Eff '[Reader State, NonDet, HTTP, Fail] o }

  = Fetch { eff :: Eff '[Reader State, NonDet, Sign, HTTP, Fail] o }

  :: (HTTP :> es, Fail :> es)

  :: (HTTP :> es, Sign :> es, Fail :> es)

import Effectful.Reader.Static (runReader, Reader)
import Network.HTTP.Conduit (tlsManagerSettings, newManager, Manager)

import Network.HTTP.Conduit (tlsManagerSettings, newManager)

import Puppy.Protocol.HTTP (runHTTP)

import Puppy.Protocol.HTTP (runHTTP, HTTP, runSign)

              -- Share a single HTTP client between all threads using the HTTP effect.
              -- We don't evaluate the HTTP effect in the global handler, because we
              -- don't want failures to propagate to the main thread. This handler must
              -- not fail unless there is something catastrophically wrong.
              . runReader manager

              -- This handler does not fail if an error is encountered, so we can safely
              -- run it here
              . runHTTP manager

                    -- HTTP handler needs to be set within the loop, because
                    -- it is fallible, so we need the `Fail` handler that is
                    -- built into `loop`.
                    . runHTTP channel

                    . runSign channel

                    -- HTTP handler needs to be set within the loop, because
                    -- it is fallible, so we need the `Fail` handler that is
                    -- built into `loop`.
                    . runHTTP channel

                    . runSign channel

    HTTP :> es,

    Reader Manager :> es,

                -- Set up the HTTP effect handler so failures are caught by `handleFail`
                . runHTTP (Server config)

                -- Set the key to sign requests with
                . runSign (Server config)