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 (Int -> IO ()) -> Int -> IO ()
forall a b. (a -> b) -> a -> b
$ Int
n Int -> Int -> Int
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 (IO () -> IO ThreadId) -> IO () -> IO ThreadId
forall a b. (a -> b) -> a -> b
$ IO ()
action IO () -> (SomeException -> IO ()) -> IO ()
forall (m :: * -> *) a.
MonadCatch m =>
m a -> (SomeException -> m a) -> m a
`X.catchAny` \SomeException
err -> ThreadId -> SomeException -> IO ()
forall e (m :: * -> *).
(Exception e, MonadIO m) =>
ThreadId -> e -> m ()
throwTo ThreadId
parent SomeException
err

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