module Sound.SC3.Common.Base where
import Data.Char
import Data.List
type Fn1 a b = a -> b
type Fn2 a b c = a -> b -> c
type Fn3 a b c d = a -> b -> c -> d
type Fn4 a b c d e = a -> b -> c -> d -> e
reads_exact :: Read a => String -> Maybe a
reads_exact s =
case reads s of
[(r,"")] -> Just r
_ -> Nothing
data Case_Rule = CI | CS deriving (Eq)
is_ci :: Case_Rule -> Bool
is_ci = (==) CI
is_cs :: Case_Rule -> Bool
is_cs = (==) CS
string_eq :: Case_Rule -> String -> String -> Bool
string_eq cr x y = if is_ci cr then map toLower x == map toLower y else x == y
rlookup_str :: Case_Rule -> String -> [(a,String)] -> Maybe a
rlookup_str = rlookup_by . string_eq
parse_enum :: (Show t,Enum t,Bounded t) => Case_Rule -> String -> Maybe t
parse_enum cr nm =
let u = [minBound .. maxBound]
t = zip (map show u) u
in lookup_by (string_eq cr) nm t
compose_l :: [t -> t] -> t -> t
compose_l = flip (foldl (\x f -> f x))
compose_r :: [t -> t] -> t -> t
compose_r = flip (foldr (\f x -> f x))
d_dx :: (Num a) => [a] -> [a]
d_dx l = zipWith (-) l (0:l)
d_dx' :: Num n => [n] -> [n]
d_dx' l = zipWith (-) (tail l) l
dx_d :: Num n => [n] -> [n]
dx_d = scanl1 (+)
dx_d' :: Num n => [n] -> [n]
dx_d' = (0 :) . dx_d
lookup_by :: (a -> a -> Bool) -> a -> [(a,b)] -> Maybe b
lookup_by f x = fmap snd . find (f x . fst)
rlookup_by :: (b -> b -> Bool) -> b -> [(a,b)] -> Maybe a
rlookup_by f x = fmap fst . find (f x . snd)
pcn_triples :: [a] -> [(Maybe a,a,Maybe a)]
pcn_triples =
let f e l = case l of
e1 : e2 : l' -> (e,e1,Just e2) : f (Just e1) (e2 : l')
[e'] -> [(e,e',Nothing)]
[] -> undefined
in f Nothing
sep_first :: [t] -> Maybe (t,[t])
sep_first l =
case l of
e:l' -> Just (e,l')
_ -> Nothing
sep_last :: [t] -> Maybe ([t], t)
sep_last =
let f (e,l) = (reverse l,e)
in fmap f . sep_first . reverse
equal_length_p :: [[a]] -> Bool
equal_length_p = (== 1) . length . nub . map length
histogram :: Ord a => [a] -> [(a,Int)]
histogram x =
let g = group (sort x)
in zip (map head g) (map length g)
p4_zip :: (a,b,c,d) -> (e,f,g,h) -> ((a,e),(b,f),(c,g),(d,h))
p4_zip (a,b,c,d) (e,f,g,h) = ((a,e),(b,f),(c,g),(d,h))
type T2 a = (a,a)
type T3 a = (a,a,a)
type T4 a = (a,a,a,a)
dup2 :: t -> T2 t
dup2 t = (t,t)
dup3 :: t -> T3 t
dup3 t = (t,t,t)
dup4 :: t -> T4 t
dup4 t = (t,t,t,t)
mk_duples :: (a -> c) -> (b -> c) -> [(a, b)] -> [c]
mk_duples a b = concatMap (\(x,y) -> [a x, b y])
mk_duples_l :: (Int -> c) -> (a -> c) -> (b -> c) -> [(a,[b])] -> [c]
mk_duples_l i a b = concatMap (\(x,y) -> a x : i (length y) : map b y)
mk_triples :: (a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
mk_triples a b c = concatMap (\(x,y,z) -> [a x, b y, c z])
t2_from_list :: [t] -> T2 t
t2_from_list l = case l of {[p,q] -> (p,q);_ -> error "t2_from_list"}