Sound.SC3.Common.Base

Common core functions.

Function

type Fn1 a b = a -> b

Unary function.

type Fn2 a b c = a -> b -> c

Binary function.

type Fn3 a b c d = a -> b -> c -> d

Ternary function.

type Fn4 a b c d e = a -> b -> c -> d -> e

Quaternary function.

iter :: Int -> (a -> a) -> a -> a

Apply f n times, ie. iterate f x !! n

iter 3 (* 2) 1 == 8
iterate (* 2) 1 !! 3 == 8

Read

reads_exact :: Read a => String -> Maybe a

Variant of reads requiring exact match.

STRING / CASE

data Case_Rule

CI = Case insensitive, CS = case sensitive.

Constructors

CI

CS

Instances

Eq Case_Rule

Defined in Sound.SC3.Common.Base

Methods

(==) :: Case_Rule -> Case_Rule -> Bool

(/=) :: Case_Rule -> Case_Rule -> Bool

is_ci :: Case_Rule -> Bool

Predicates for Case_Rule.

is_cs :: Case_Rule -> Bool

Predicates for Case_Rule.

string_eq :: Case_Rule -> String -> String -> Bool

String equality with Case_Rule.

string_eq CI "lower" "LOWER" == True

rlookup_str :: Case_Rule -> String -> [(a, String)] -> Maybe a

rlookup_by of string_eq.

parse_enum :: (Show t, Enum t, Bounded t) => Case_Rule -> String -> Maybe t

Enum parser with Case_Rule.

parse_enum CI "FALSE" == Just False

LIST

compose_l :: [t -> t] -> t -> t

Left to right composition of a list of functions.

compose_l [(* 2),(+ 1)] 3 == 7

compose_r :: [t -> t] -> t -> t

Right to left composition of a list of functions.

compose_r [(* 2),(+ 1)] 3 == 8

d_dx :: Num a => [a] -> [a]

SequenceableCollection.differentiate

> [3,4,1,1].differentiate == [3,1,-3,0]

d_dx [3,4,1,1] == [3,1,-3,0]
d_dx [0,1,3,6] == [0,1,2,3]

d_dx' :: Num n => [n] -> [n]

Variant that does not prepend zero to input, ie. tail of d_dx.

d_dx' [3,4,1,1] == [1,-3,0]
d_dx' [0,1,3,6] == [1,2,3]

dx_d :: Num n => [n] -> [n]

SequenceableCollection.integrate

> [3,4,1,1].integrate == [3,7,8,9]

dx_d [3,4,1,1] == [3,7,8,9]
dx_d (d_dx [0,1,3,6]) == [0,1,3,6]
dx_d [0.5,0.5] == [0.5,1]

dx_d' :: Num n => [n] -> [n]

Variant pre-prending zero to output.

dx_d' [3,4,1,1] == [0,3,7,8,9]
dx_d' (d_dx' [0,1,3,6]) == [0,1,3,6]
dx_d' [0.5,0.5] == [0,0.5,1]

lookup_by :: (a -> t -> Bool) -> a -> [(t, b)] -> Maybe b

lookup with equality function.

lookup_by_err :: (a -> t -> Bool) -> a -> [(t, b)] -> b

Erroring variant.

rlookup_by :: (b -> b -> Bool) -> b -> [(a, b)] -> Maybe a

Reverse lookup with equality function.

pcn_triples :: [a] -> [(Maybe a, a, Maybe a)]

(prev,cur,next) triples.

pcn_triples [1..3] == [(Nothing,1,Just 2),(Just 1,2,Just 3),(Just 2,3,Nothing)]

sep_first :: [t] -> Maybe (t, [t])

Separate first list element.

sep_first "astring" == Just ('a',"string")

sep_last :: [t] -> Maybe ([t], t)

Separate last list element.

sep_last "stringb" == Just ("string",'b')

equal_length_p :: [[a]] -> Bool

Are lists of equal length?

equal_length_p ["t1","t2"] == True
equal_length_p ["t","t1","t2"] == False

histogram :: Ord a => [a] -> [(a, Int)]

Histogram

TUPLES

p4_zip :: (a, b, c, d) -> (e, f, g, h) -> ((a, e), (b, f), (c, g), (d, h))

Zip two 4-tuples.

type T2 a = (a, a)

Two-tuple.

type T3 a = (a, a, a)

Three-tuple.

type T4 a = (a, a, a, a)

Four-tuple.

dup2 :: t -> T2 t

t -> (t,t)

dup3 :: t -> T3 t

t -> (t,t,t)

dup4 :: t -> T4 t

t -> (t,t,t,t)

mk_duples :: (a -> c) -> (b -> c) -> [(a, b)] -> [c]

concatMap of f at x and g at y.

mk_duples_l :: (Int -> c) -> (a -> c) -> (b -> c) -> [(a, [b])] -> [c]

Length prefixed list variant of mk_duples.

mk_triples :: (a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]

concatMap of f at x and g at y and h at z.

t2_from_list :: [t] -> T2 t

x,y

-> (x,y)

t3_from_list :: [t] -> (t, t, t)

x,y,z

-> (x,y,z)

System

get_env_default :: String -> String -> IO String

Guarded variant of getEnv with default value.

lookup_env_default :: String -> String -> IO String

lookupEnv with default value.

lookup_env_default "PATH" "/usr/bin"