Chorale.Common

Applicative

(.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 8

f . g a $ b = (f .* g) a b

(.**) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e infixr 8

f . g a b $ c = (f .** g) a b c

(.***) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f infixr 8

f . g a b c $ d = (f .** g) a b c d

uncurryM2 :: (Functor m, Monad m) => (a -> b -> x) -> (m a, m b) -> m x

uncurry for two monadic arguments

uncurryMM2 :: (Functor m, Monad m) => (a -> b -> m x) -> (m a, m b) -> m x

uncurry for two monadic arguments with monadic function

curry3 :: ((a, b, c) -> d) -> a -> b -> c -> d

curry for three arguments

uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d

uncurry for three arguments

uncurryM3 :: (Functor m, Monad m) => (a -> b -> c -> x) -> (m a, m b, m c) -> m x

uncurry for three monadic arguments

uncurryMM3 :: (Functor m, Monad m) => (a -> b -> c -> m x) -> (m a, m b, m c) -> m x

uncurry for three monadic arguments with monadic function

curry4 :: ((a, b, c, d) -> e) -> a -> b -> c -> d -> e

curry for four arguments

uncurry4 :: (a -> b -> c -> d -> e) -> (a, b, c, d) -> e

uncurry for four arguments

uncurryM4 :: (Functor m, Monad m) => (a -> b -> c -> d -> x) -> (m a, m b, m c, m d) -> m x

uncurry for four monadic arguments

uncurryMM4 :: (Functor m, Monad m) => (a -> b -> c -> d -> m x) -> (m a, m b, m c, m d) -> m x

uncurry for four monadic arguments with monadic function

curry5 :: ((a, b, c, d, e) -> f) -> a -> b -> c -> d -> e -> f

curry for five arguments

uncurry5 :: (a -> b -> c -> d -> e -> f) -> (a, b, c, d, e) -> f

uncurry for five arguments

uncurryM5 :: (Functor m, Monad m) => (a -> b -> c -> d -> e -> x) -> (m a, m b, m c, m d, m e) -> m x

uncurry for five monadic arguments

uncurryMM5 :: (Functor m, Monad m) => (a -> b -> c -> d -> e -> m x) -> (m a, m b, m c, m d, m e) -> m x

uncurry for five monadic arguments with monadic function

Tuples

Generating Tuples

appendFst :: a -> b -> (a, b)

append a first argument for making a 2-tuple

appendSnd :: b -> a -> (a, b)

append a second argument for making a 2-tuple

appendFst3 :: a -> (b, c) -> (a, b, c)

append a first argument for making a 3-tuple

appendSnd3 :: b -> (a, c) -> (a, b, c)

append a second argument for making a 3-tuple

appendThd3 :: c -> (a, b) -> (a, b, c)

append a third argument for making a 3-tuple

removeFst3 :: (a, b, c) -> (b, c)

remove first argument of a 3-tuple

removeSnd3 :: (a, b, c) -> (a, c)

remove second argument of a 3-tuple

removeThd3 :: (a, b, c) -> (a, b)

remove third argument of a 3-tuple

appendFst4 :: a -> (b, c, d) -> (a, b, c, d)

append a first argument for making a 4-tuple

appendSnd4 :: b -> (a, c, d) -> (a, b, c, d)

append a second argument for making a 4-tuple

appendThd4 :: c -> (a, b, d) -> (a, b, c, d)

append a third argument for making a 4-tuple

appendFth4 :: d -> (a, b, c) -> (a, b, c, d)

append a fourth argument for making a 4-tuple

removeFst4 :: (a, b, c, d) -> (b, c, d)

remove first argument of a 4-tuple

removeSnd4 :: (a, b, c, d) -> (a, c, d)

remove second argument of a 4-tuple

removeThd4 :: (a, b, c, d) -> (a, b, d)

remove third argument of a 4-tuple

removeFth4 :: (a, b, c, d) -> (a, b, c)

remove fourth argument of a 4-tuple

appendFst5 :: a -> (b, c, d, e) -> (a, b, c, d, e)

append a first argument for making a 5-tuple

appendSnd5 :: b -> (a, c, d, e) -> (a, b, c, d, e)

append a second argument for making a 5-tuple

appendThd5 :: c -> (a, b, d, e) -> (a, b, c, d, e)

append a third argument for making a 5-tuple

appendFourth5 :: d -> (a, b, c, e) -> (a, b, c, d, e)

append a fourth argument for making a 5-tuple

appendFifth5 :: e -> (a, b, c, d) -> (a, b, c, d, e)

append a fifth argument for making a 5-tuple

removeFst5 :: (a, b, c, d, e) -> (b, c, d, e)

remove first argument of a 5-tuple

removeSnd5 :: (a, b, c, d, e) -> (a, c, d, e)

remove second argument of a 5-tuple

removeThd5 :: (a, b, c, d, e) -> (a, b, d, e)

remove third argument of a 5-tuple

removeFourth5 :: (a, b, c, d, e) -> (a, b, c, e)

remove fourth argument of a 5-tuple

removeFifth5 :: (a, b, c, d, e) -> (a, b, c, d)

remove fifth argument of a 5-tuple

make2 :: a -> (a, a)

make a 2-tuple containing the given value in each component

make3 :: a -> (a, a, a)

make a 3-tuple containing the given value in each component

make4 :: a -> (a, a, a, a)

make a 4-tuple containing the given value in each component

make5 :: a -> (a, a, a, a, a)

make a 5-tuple containing the given value in each component

Retrieving the Tuples' Components

fst3 :: (a, b, c) -> a

get the first argument of a 3-tuple

snd3 :: (a, b, c) -> b

get the second argument of a 3-tuple

thd3 :: (a, b, c) -> c

get the third argument of a 3-tuple

fst4 :: (a, b, c, d) -> a

get the first argument of a 4-tuple

snd4 :: (a, b, c, d) -> b

get the second argument of a 4-tuple

thd4 :: (a, b, c, d) -> c

get the third argument of a 4-tuple

fth4 :: (a, b, c, d) -> d

get the fourth argument of a 4-tuple

fst5 :: (a, b, c, d, e) -> a

get the first argument of a 5-tuple

snd5 :: (a, b, c, d, e) -> b

get the second argument of a 5-tuple

thd5 :: (a, b, c, d, e) -> c

get the third argument of a 5-tuple

fourth5 :: (a, b, c, d, e) -> d

get the fourth argument of a 5-tuple

fifth5 :: (a, b, c, d, e) -> e

get the fourth argument of a 5-tuple

Modifying Tuples

tupleToList2 :: (a, a) -> [a]

convert a 2-tuple to a list

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

convert a 2-tuple to a list

tupleToList3 :: (a, a, a) -> [a]

convert a 3-tuple to a list

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

convert a 3-tuple to a list

tupleToList4 :: (a, a, a, a) -> [a]

convert a 4-tuple to a list

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

convert a 4-tuple to a list

tupleToList5 :: (a, a, a, a, a) -> [a]

convert a 5-tuple to a list

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

convert a 5-tuple to a list

Applying Functions to Tuples

map12 :: (a -> a') -> (a, a) -> (a', a')

apply one function to a 2-tuple

map21 :: (a -> a', a -> a'') -> a -> (a', a'')

apply a 2-tuple of functions to a value

map22 :: (a -> a', b -> b') -> (a, b) -> (a', b')

apply a 2-tuple of functions to a 2-tuple

map13 :: (a -> a') -> (a, a, a) -> (a', a', a')

apply one function to a 3-tuple

map31 :: (a -> a', a -> a'', a -> a''') -> a -> (a', a'', a''')

apply a 3-tuple of functions to a value

map33 :: (a -> a', b -> b', c -> c') -> (a, b, c) -> (a', b', c')

apply a 3-tuple of functions to a 3-tuple

map14 :: (a -> a') -> (a, a, a, a) -> (a', a', a', a')

apply one function to a 4-tuple

map41 :: (a -> a', a -> a'', a -> a''', a -> a'''') -> a -> (a', a'', a''', a'''')

apply a 4-tuple of functions to a value

map44 :: (a -> a', b -> b', c -> c', d -> d') -> (a, b, c, d) -> (a', b', c', d')

apply a 4-tuple of functions to a 4-tuple

map15 :: (a -> a') -> (a, a, a, a, a) -> (a', a', a', a', a')

apply one function to a 5-tuple

map51 :: (a -> a', a -> a'', a -> a''', a -> a'''', a -> a''''') -> a -> (a', a'', a''', a'''', a''''')

apply a 5-tuple of functions to a value

map55 :: (a -> a', b -> b', c -> c', d -> d', e -> e') -> (a, b, c, d, e) -> (a', b', c', d', e')

apply a 5-tuple of functions to a 5-tuple

mapFst :: (a -> a') -> (a, b) -> (a', b)

apply a function to the first argument of a 2-tuple

mapSnd :: (b -> b') -> (a, b) -> (a, b')

apply a function to the second argument of a 2-tuple

Monads and Tuples

sequence2 :: (Functor m, Monad m) => (m a, m b) -> m (a, b)

like sequence but for a 2-tuple

sequence3 :: (Functor m, Monad m) => (m a, m b, m c) -> m (a, b, c)

like sequence but for a 3-tuple

sequence4 :: (Functor m, Monad m) => (m a, m b, m c, m d) -> m (a, b, c, d)

like sequence but for a 4-tuple

sequence5 :: (Functor m, Monad m) => (m a, m b, m c, m d, m e) -> m (a, b, c, d, e)

like sequence but for a 5-tuple

(<<) :: Monad m => m b -> m a -> m b

like >> but with reversed argument

Functions

const2 :: a -> b -> c -> a

like const but with 2 arguments

const3 :: a -> b -> c -> d -> a

like const but with 3 arguments

const4 :: a -> b -> c -> d -> e -> a

like const but with 4 arguments

const5 :: a -> b -> c -> d -> e -> f -> a

like const but with 5 arguments

applyIf :: Bool -> (a -> a) -> a -> a

apply an endomorphism only if the given boolean value is true

Ordering

compareUsing :: Eq a => [a] -> a -> a -> Ordering

compare function that uses the order in a given list

e.g. compareUsing [1,3,2] will state 1 < 2 and 3 < 2

Comparing and Sorting

vanishes :: (Num a, Eq a) => a -> Bool

tests whether a given number vanishes

equaling :: Eq b => (a -> b) -> a -> a -> Bool

similar to comparing but for equalities

sortAndGroup :: Ord a => [a] -> [[a]]

sort and group

sortAndGroupBy :: Ord b => (a -> b) -> [a] -> [[a]]

sort and than group, non-overloaded version

sortAndGroupLookupBy :: Ord b => (a -> b) -> [a] -> [(b, [a])]

sort and than group to a lookup table

lookupBy :: Eq b => (a -> b) -> b -> [a] -> Maybe a

lookup by using a function

lookupBy f b xs finds the element x which satisfies f x = b

List Operations

notNull :: [a] -> Bool

returns False if a list is empty, otherwise True

takeWhileList :: ([a] -> Bool) -> [a] -> [a]

like takeWhile but the function p takes the whole list as argument

takeUntilList :: ([a] -> Bool) -> [a] -> [a]

similar takeWhileList but returns the the sublist such that p is met the first time

takeToFirst :: (a -> Bool) -> [a] -> [a]

takeToFirst p xs returns the suffix until (and inclusive) the first occurance where p xs

splitOnFirst :: Eq a => a -> [a] -> ([a], Maybe [a])

like splitOn but splits only at the first occurance

nubOrd :: Ord a => [a] -> [a]

like nub but requires a to be an instance of Ord

The original nub is O(n^2) on lists of length n. nubOrd is O(n log(n)).

nubOrdBy :: Ord b => (a -> b) -> [a] -> [a]

like nubBy but requires b to be an instance of Ord

nubOrdBy f = nubBy (equaling f) The original nubBy is O(n^2) on lists of length n. nubOrdBy is O(n log(n)).

zipWithDefault :: a -> (a -> a -> c) -> [a] -> [a] -> [c]

like zipWith but with a default value such that the resulting list is as long as the longest input list

subset :: Eq a => [a] -> [a] -> Bool

test whether the first list is a subset of the second one

subsets :: [a] -> [[a]]

all subsets for a list

sublistByIndex :: (Int, Int) -> [a] -> [a]

sublistByIndex (i, j) xs returns the sublist of xs starting at index i and ending index j

findIndicesTuples :: (a -> Bool) -> [a] -> [([a], Int)]

like findIndices but results a list of tuples (x, i) where x is the list and i the index

minimumIndex :: Ord a => [a] -> Int

like minimum but returns the (first) index

minimumIndexBy :: Ord a => (a -> a -> Ordering) -> [a] -> Int

like minimumBy but returns the (first) index

maximumIndex :: Ord a => [a] -> Int

like maximum but returns the (first) index

maximumIndexBy :: Ord a => (a -> a -> Ordering) -> [a] -> Int

like maximumBy but returns the (first) index

replaceInList :: Int -> [a] -> [a] -> [a]

replace the element at the given position by a given list of elements

for just removing the j-th element of a list, use the following function

replaceInList j []

for replacing the j-th element of a list by an element a, use the following function

replaceInList j [a]

replaceElementInList :: Eq a => a -> [a] -> [a] -> [a]

replace all appearances of an element in a list by a given list of elements

removeFromList :: Int -> [a] -> [a]

remove the j-th element from a list

stripPostfix :: Eq a => [a] -> [a] -> Maybe [a]

like stripPrefix but for postfixes

applyToList :: Int -> (a -> a) -> [a] -> [a]

apply a function to the element at the given position in a given list of elements

mapFoldl :: (Maybe c -> a -> (c, b)) -> [a] -> [b]

map a function f to a list; the function results a result value b as well as a value c which can be used for the computation of the next element (i.e. the next f a)

reverseMap :: [a -> b] -> a -> [b]

map an array of functions to a value

count :: (a -> Bool) -> [a] -> Int

count for how many entries the predicate is met

deleteAll :: Eq a => a -> [a] -> [a]

delete all occurances of an element in a list

deleteAlls :: Eq a => [a] -> [a] -> [a]

delete all occurances of a sublist in a list

cartesian :: [a] -> [b] -> [(a, b)]

cartesian product

Boolean Operations

xor :: Bool -> Bool -> Bool

xor function

xnor :: Bool -> Bool -> Bool

xnor function

Number Operations

average :: [Double] -> Double

compute the average of a list of numbers

String Operations

justifyLeft :: Int -> Char -> String -> String

append a char as often as needed in order to return a string of given length where the given string ist justified left

justifyRight :: Int -> Char -> String -> String

append a char as often as needed in order to return a string of given length where the given string ist justified right

Maybe Operations

mapJust :: (a -> b) -> Maybe a -> Maybe b

maps a Just value

onJustUse :: (a -> b -> b) -> Maybe a -> b -> b

uses an endomorphism parametrised by a Just value

Either Operations

mapLeft :: (a -> c) -> Either a b -> Either c b

maps a Left value

mapRight :: (b -> c) -> Either a b -> Either a c

maps a Right value

fromLeft :: Either a b -> a

returns Left value

fromRight :: Either a b -> b

returns Right value

fromLeftMay :: Either a b -> Maybe a

safe variant of fromLeft

fromRightMay :: Either a b -> Maybe b

safe variant of fromRight

data Either3 a b c

Either-like type for 3 values

Constructors

E1 a

E2 b

E3 c