module Faktory.Prelude
  ( module X
  , module Faktory.Prelude
  )
where

import Prelude as X

import Control.Concurrent (ThreadId, forkIO, myThreadId, threadDelay)
import Control.Exception.Safe as X
import Control.Monad as X
import Data.Foldable as X
import Data.Text as X (Text, pack, unpack)
import Data.Traversable as X

threadDelaySeconds :: Int -> IO ()
threadDelaySeconds :: Int -> IO ()
threadDelaySeconds Int
n = Int -> IO ()
threadDelay forall a b. (a -> b) -> a -> b
$ Int
n forall a. Num a => a -> a -> a
* Int
1000000

forkIOWithThrowToParent :: IO () -> IO ThreadId
forkIOWithThrowToParent :: IO () -> IO ThreadId
forkIOWithThrowToParent IO ()
action = do
  ThreadId
parent <- IO ThreadId
myThreadId
  IO () -> IO ThreadId
forkIO forall a b. (a -> b) -> a -> b
$ IO ()
action forall (m :: * -> *) a.
MonadCatch m =>
m a -> (SomeException -> m a) -> m a
`X.catchAny` \SomeException
err -> forall e (m :: * -> *).
(Exception e, MonadIO m) =>
ThreadId -> e -> m ()
throwTo ThreadId
parent SomeException
err

fromRightThrows :: MonadThrow m => Either String a -> m a
fromRightThrows :: forall (m :: * -> *) a. MonadThrow m => Either String a -> m a
fromRightThrows = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall (m :: * -> *) a.
(MonadThrow m, HasCallStack) =>
String -> m a
throwString forall (f :: * -> *) a. Applicative f => a -> f a
pure