-- | Useful functions from hbc-library modules ListSet, ListMap, ListUtil, HO
-- and UTF8
module HbcUtils(module HbcUtils,module FudUTF8) where
import Data.List((\\))
import FudUTF8

-- * From ListSet

-- | Union of sets as lists
union :: (Eq a) => [a] -> [a] -> [a]
union :: [a] -> [a] -> [a]
union [a]
xs [a]
ys = [a]
xs [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ ([a]
ys [a] -> [a] -> [a]
forall a. Eq a => [a] -> [a] -> [a]
\\ [a]
xs)


-- * From ListMap
lookupWithDefault :: (Eq a) => [(a, b)] -> b -> a -> b
lookupWithDefault :: [(a, b)] -> b -> a -> b
lookupWithDefault [] b
d a
_ = b
d
lookupWithDefault ((a
x,b
y):[(a, b)]
xys) b
d a
x' = if a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
x' then b
y else [(a, b)] -> b -> a -> b
forall a b. Eq a => [(a, b)] -> b -> a -> b
lookupWithDefault [(a, b)]
xys b
d a
x'


-- * From ListUtil
mapFst :: (t -> a) -> [(t, b)] -> [(a, b)]
mapFst t -> a
f = ((t, b) -> (a, b)) -> [(t, b)] -> [(a, b)]
forall a b. (a -> b) -> [a] -> [b]
map ((t -> a) -> (t, b) -> (a, b)
forall t a b. (t -> a) -> (t, b) -> (a, b)
apFst t -> a
f)
mapSnd :: (t -> b) -> [(a, t)] -> [(a, b)]
mapSnd t -> b
f = ((a, t) -> (a, b)) -> [(a, t)] -> [(a, b)]
forall a b. (a -> b) -> [a] -> [b]
map ((t -> b) -> (a, t) -> (a, b)
forall t b a. (t -> b) -> (a, t) -> (a, b)
apSnd t -> b
f)

breakAt :: a -> [a] -> ([a], [a])
breakAt a
c = ([a] -> [a]) -> ([a], [a]) -> ([a], [a])
forall t b a. (t -> b) -> (a, t) -> (a, b)
apSnd (Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
drop Int
1) (([a], [a]) -> ([a], [a]))
-> ([a] -> ([a], [a])) -> [a] -> ([a], [a])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (a -> a -> Bool
forall a. Eq a => a -> a -> Bool
==a
c)

chopList :: ([a] -> (b, [a])) -> [a] -> [b]
chopList :: ([a] -> (b, [a])) -> [a] -> [b]
chopList [a] -> (b, [a])
f [a]
l = ([a] -> (b, [a])) -> ([a] -> Bool) -> [a] -> [b]
forall a b. (a -> (b, a)) -> (a -> Bool) -> a -> [b]
unfoldr [a] -> (b, [a])
f [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
l
  where
    -- | Repeatedly extract (and transform) values until a predicate hold.  Return the list of values.
    unfoldr :: (a -> (b, a)) -> (a -> Bool) -> a -> [b]
    unfoldr :: (a -> (b, a)) -> (a -> Bool) -> a -> [b]
unfoldr a -> (b, a)
f a -> Bool
p a
x | a -> Bool
p a
x       = []
                  | Bool
otherwise = b
yb -> [b] -> [b]
forall a. a -> [a] -> [a]
:(a -> (b, a)) -> (a -> Bool) -> a -> [b]
forall a b. (a -> (b, a)) -> (a -> Bool) -> a -> [b]
unfoldr a -> (b, a)
f a -> Bool
p a
x'
                                  where (b
y, a
x') = a -> (b, a)
f a
x

assoc :: Eq k => (v -> r) -> r -> [(k, v)] -> k -> r
assoc :: (v -> r) -> r -> [(k, v)] -> k -> r
assoc v -> r
f r
z [(k, v)]
xs k
k = r -> (v -> r) -> Maybe v -> r
forall b a. b -> (a -> b) -> Maybe a -> b
maybe r
z v -> r
f (k -> [(k, v)] -> Maybe v
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup k
k [(k, v)]
xs)

-- * From HO

apFst :: (t -> a) -> (t, b) -> (a, b)
apFst t -> a
f (t
x, b
y) = (t -> a
f t
x, b
y)
apSnd :: (t -> b) -> (a, t) -> (a, b)
apSnd t -> b
f (a
x, t
y) = (a
x, t -> b
f t
y)

curry3 :: ((a, b, c) -> t) -> a -> b -> c -> t
curry3 (a, b, c) -> t
f a
x b
y c
z = (a, b, c) -> t
f (a
x,b
y,c
z)
uncurry3 :: (t -> t -> t -> t) -> (t, t, t) -> t
uncurry3 t -> t -> t -> t
f ~(t
x,t
y,t
z) = t -> t -> t -> t
f t
x t
y t
z