module Hidden.Tools (
isSymbol
, modifyFst
, modifySnd
, first
, second
, third
, modifyFirst
, modifySecond
, modifyThird
, guardEqual
, (|||)
, (&&&)
, isBit7On
, skipRet
, (>..>)
, ignoreCase
, ifM
, applyIf
, headOrErr
) where
import Data.Char ( ord, toUpper, toLower )
import Data.Bits ( (.&.), shiftL )
import Control.Monad ( MonadPlus, guard )
isSymbol :: Char -> Bool
isSymbol :: Char -> Bool
isSymbol = (Char -> [Char] -> Bool) -> [Char] -> Char -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem [Char]
"!\"#$%&'()*+,-./:;<=>?@[\\]^_'{|}~"
modifyFst :: (a -> c) -> (a, b) -> (c, b)
modifyFst :: forall a c b. (a -> c) -> (a, b) -> (c, b)
modifyFst a -> c
f (a
x, b
y) = (a -> c
f a
x, b
y)
modifySnd :: (b -> c) -> (a, b) -> (a, c)
modifySnd :: forall b c a. (b -> c) -> (a, b) -> (a, c)
modifySnd b -> c
f (a
x, b
y) = (a
x, b -> c
f b
y)
guardEqual :: (MonadPlus m, Eq a) => m a -> m a -> m ()
guardEqual :: forall (m :: * -> *) a. (MonadPlus m, Eq a) => m a -> m a -> m ()
guardEqual m a
m1 m a
m2 = do { a
x <- m a
m1; a
y <- m a
m2; Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
y) }
first :: (a, b, c) -> a
first :: forall a b c. (a, b, c) -> a
first (a
x, b
_, c
_) = a
x
second :: (a, b, c) -> b
second :: forall a b c. (a, b, c) -> b
second (a
_, b
y, c
_) = b
y
third :: (a, b, c) -> c
third :: forall a b c. (a, b, c) -> c
third (a
_, b
_, c
z) = c
z
modifyFirst :: (a -> d) -> (a, b, c) -> (d, b, c)
modifyFirst :: forall a d b c. (a -> d) -> (a, b, c) -> (d, b, c)
modifyFirst a -> d
f (a
x, b
y, c
z) = (a -> d
f a
x, b
y, c
z)
modifySecond :: (b -> d) -> (a, b, c) -> (a, d, c)
modifySecond :: forall b d a c. (b -> d) -> (a, b, c) -> (a, d, c)
modifySecond b -> d
f (a
x, b
y, c
z) = (a
x, b -> d
f b
y, c
z)
modifyThird :: (c -> d) -> (a, b, c) -> (a, b, d)
modifyThird :: forall c d a b. (c -> d) -> (a, b, c) -> (a, b, d)
modifyThird c -> d
f (a
x, b
y, c
z) = (a
x, b
y, c -> d
f c
z)
(|||),(&&&) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
(a -> Bool
p1 ||| :: forall a. (a -> Bool) -> (a -> Bool) -> a -> Bool
||| a -> Bool
p2) a
x = a -> Bool
p1 a
x Bool -> Bool -> Bool
|| a -> Bool
p2 a
x
(a -> Bool
p1 &&& :: forall a. (a -> Bool) -> (a -> Bool) -> a -> Bool
&&& a -> Bool
p2) a
x = a -> Bool
p1 a
x Bool -> Bool -> Bool
&& a -> Bool
p2 a
x
isBit7On :: Char -> Bool
isBit7On :: Char -> Bool
isBit7On Char
c = Char -> Int
ord Char
c Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&. Int -> Int -> Int
forall a. Bits a => a -> Int -> a
shiftL Int
1 Int
7 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0
skipRet :: Monad m => m b -> a -> m a
skipRet :: forall (m :: * -> *) b a. Monad m => m b -> a -> m a
skipRet m b
p a
x = m b
p m b -> m a -> m a
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
(>..>) :: Monad m => m a -> m b -> m (a, b)
m a
m1 >..> :: forall (m :: * -> *) a b. Monad m => m a -> m b -> m (a, b)
>..> m b
m2 = do { a
x <- m a
m1; b
y <- m b
m2; (a, b) -> m (a, b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
x, b
y) }
ignoreCase :: (Char -> Bool) -> Char -> Bool
ignoreCase :: (Char -> Bool) -> Char -> Bool
ignoreCase Char -> Bool
p Char
c = Char -> Bool
p (Char -> Char
toLower Char
c) Bool -> Bool -> Bool
|| Char -> Bool
p (Char -> Char
toUpper Char
c)
ifM :: Monad m => m Bool -> m a -> m a -> m a
ifM :: forall (m :: * -> *) a. Monad m => m Bool -> m a -> m a -> m a
ifM m Bool
p m a
mt m a
me = do Bool
b <- m Bool
p
if Bool
b then m a
mt
else m a
me
applyIf :: Bool -> (a -> a) -> a -> a
applyIf :: forall a. Bool -> (a -> a) -> a -> a
applyIf Bool
True a -> a
f = a -> a
f
applyIf Bool
False a -> a
_ = a -> a
forall a. a -> a
id
headOrErr :: String -> [a] -> a
headOrErr :: forall a. [Char] -> [a] -> a
headOrErr [Char]
err [] = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
err
headOrErr [Char]
_ (a
x:[a]
_) = a
x