mirror of
https://github.com/simplex-chat/simplexmq.git
synced 2026-04-25 22:52:15 +00:00
d9a0e78b04
* add optional auxiliary data field to ConnectionRequestUri * remove import * fix, test * fix StrEncoding Char * data only in sync command, type * fixing * queryParamStr * safeDecodeUtf8 Co-authored-by: Evgeny Poberezkin <2769109+epoberezkin@users.noreply.github.com>
101 lines
2.8 KiB
Haskell
101 lines
2.8 KiB
Haskell
{-# LANGUAGE OverloadedStrings #-}
|
|
{-# LANGUAGE ScopedTypeVariables #-}
|
|
|
|
module Simplex.Messaging.Util where
|
|
|
|
import qualified Control.Exception as E
|
|
import Control.Monad.Except
|
|
import Control.Monad.IO.Unlift
|
|
import Control.Monad.Trans.Except
|
|
import Data.Bifunctor (first)
|
|
import Data.ByteString.Char8 (ByteString)
|
|
import qualified Data.ByteString.Char8 as B
|
|
import Data.Text (Text)
|
|
import qualified Data.Text as T
|
|
import Data.Text.Encoding (decodeUtf8With)
|
|
import UnliftIO.Async
|
|
|
|
raceAny_ :: MonadUnliftIO m => [m a] -> m ()
|
|
raceAny_ = r []
|
|
where
|
|
r as (m : ms) = withAsync m $ \a -> r (a : as) ms
|
|
r as [] = void $ waitAnyCancel as
|
|
|
|
infixl 4 <$$>, <$?>
|
|
|
|
(<$$>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
|
|
(<$$>) = fmap . fmap
|
|
{-# INLINE (<$$>) #-}
|
|
|
|
(<$?>) :: MonadFail m => (a -> Either String b) -> m a -> m b
|
|
f <$?> m = either fail pure . f =<< m
|
|
{-# INLINE (<$?>) #-}
|
|
|
|
bshow :: Show a => a -> ByteString
|
|
bshow = B.pack . show
|
|
{-# INLINE bshow #-}
|
|
|
|
tshow :: Show a => a -> Text
|
|
tshow = T.pack . show
|
|
{-# INLINE tshow #-}
|
|
|
|
maybeWord :: (a -> ByteString) -> Maybe a -> ByteString
|
|
maybeWord f = maybe "" $ B.cons ' ' . f
|
|
{-# INLINE maybeWord #-}
|
|
|
|
liftIOEither :: (MonadIO m, MonadError e m) => IO (Either e a) -> m a
|
|
liftIOEither a = liftIO a >>= liftEither
|
|
{-# INLINE liftIOEither #-}
|
|
|
|
liftError :: (MonadIO m, MonadError e' m) => (e -> e') -> ExceptT e IO a -> m a
|
|
liftError f = liftEitherError f . runExceptT
|
|
{-# INLINE liftError #-}
|
|
|
|
liftEitherError :: (MonadIO m, MonadError e' m) => (e -> e') -> IO (Either e a) -> m a
|
|
liftEitherError f a = liftIOEither (first f <$> a)
|
|
{-# INLINE liftEitherError #-}
|
|
|
|
tryError :: MonadError e m => m a -> m (Either e a)
|
|
tryError action = (Right <$> action) `catchError` (pure . Left)
|
|
{-# INLINE tryError #-}
|
|
|
|
tryE :: Monad m => ExceptT e m a -> ExceptT e m (Either e a)
|
|
tryE m = (Right <$> m) `catchE` (pure . Left)
|
|
{-# INLINE tryE #-}
|
|
|
|
liftE :: (e -> e') -> ExceptT e IO a -> ExceptT e' IO a
|
|
liftE f a = ExceptT $ first f <$> runExceptT a
|
|
{-# INLINE liftE #-}
|
|
|
|
ifM :: Monad m => m Bool -> m a -> m a -> m a
|
|
ifM ba t f = ba >>= \b -> if b then t else f
|
|
{-# INLINE ifM #-}
|
|
|
|
whenM :: Monad m => m Bool -> m () -> m ()
|
|
whenM b a = ifM b a $ pure ()
|
|
{-# INLINE whenM #-}
|
|
|
|
unlessM :: Monad m => m Bool -> m () -> m ()
|
|
unlessM b = ifM b $ pure ()
|
|
{-# INLINE unlessM #-}
|
|
|
|
($>>=) :: (Monad m, Monad f, Traversable f) => m (f a) -> (a -> m (f b)) -> m (f b)
|
|
f $>>= g = f >>= fmap join . mapM g
|
|
|
|
catchAll :: IO a -> (E.SomeException -> IO a) -> IO a
|
|
catchAll = E.catch
|
|
{-# INLINE catchAll #-}
|
|
|
|
catchAll_ :: IO a -> IO a -> IO a
|
|
catchAll_ a = catchAll a . const
|
|
{-# INLINE catchAll_ #-}
|
|
|
|
eitherToMaybe :: Either a b -> Maybe b
|
|
eitherToMaybe = either (const Nothing) Just
|
|
{-# INLINE eitherToMaybe #-}
|
|
|
|
safeDecodeUtf8 :: ByteString -> Text
|
|
safeDecodeUtf8 = decodeUtf8With onError
|
|
where
|
|
onError _ _ = Just '?'
|