Swish.Utils.ListHelpers

This module defines some generic list and related helper functions. Although some routines are explicitly marked as deprecated, the intention is to move this functionality into the modules that need it, or replace it by other modules, where possible.

Documentation

select :: (a -> Bool) -> [a] -> [b] -> [b]

Select is like filter, except that it tests one list to select elements from a second list.

deleteIndex :: [a] -> Int -> [a]

Delete the n'th element of a list, returning the result

If the list doesn't have an n'th element, return the list unchanged.

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

Subset test

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

Set equivalence test

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

Add element to set

headOrNothing :: [Maybe a] -> Maybe a

Return head of a list of Maybe's, or Nothing if list is empty

Use with filter isJust to select a non-Nothing value from a list when such a value is present.

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

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

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

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

Break list into a list of sublists, separated by element satisfying supplied condition.

powerSet :: [a] -> [[a]]

Powerset of a list, in ascending order of size. Assumes the supplied list has no duplicate elements.

permutations :: [a] -> [[a]]

listProduct :: [[a]] -> [[a]]

Given a list of lists, construct a new list of lists where each member of the new list is the same length as the original list, and each member corresponds to a different choice of one element from each of the original members in the corresponding position. Thus:

 listProduct [[a1,a2],[b1],[c1,c2]] =
      [ [a1,b1,c1], [a1,b1,c2], [a2,b1,c1], [a2,b1,c2] ]

Note: The length of the resulting list is the prodicty of lengths of the components of the original list. Thus, if any member of the original list is empty then so is the resulting list:

 listProduct [[a1,a2],[],[c1,c2]] = []

NOTE: this is subsumed by sequence

powerSequences_len :: Int -> [a] -> [[a]]

Return all powersequences of a given length

flist :: [a -> b] -> a -> [b]

Apply list of functions to some value, returning list of results. It's kind of like an converse map.

This is similar to the ap function in the Monad library.

allp :: [a -> Bool] -> a -> Bool

Test if a value satisfies all predicates in a list

anyp :: [a -> Bool] -> a -> Bool

Test if a value satisfies any predicate in a list

Deprecated routines

These routines will be removed at the next minor release of of Swish (0.3.3).

mapset :: Eq b => (a -> b) -> [a] -> [b]

Collect set of values from list under supplied mapping function

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

ffold :: (b -> c -> c) -> c -> [a -> b] -> a -> c

Fold result from list of functions applied to some value, returning the result of the fold.

This is similar to the ap function in the Monad library.

hasPartitions :: Eq a => [a] -> ([a], [a]) -> Bool

Set partition test

Is it possible to be more efficient here? Maybe something like sort/merge/compare?

powerSequences :: [a] -> [[a]]

Function to choose all sequences of any length from a supplied set of values, returned in increasing length.

powerSequences_inf :: [a] -> [[a]]

Return all powersequences of indefinite length Observe that any such powersequence will consist of a sequence of a finite length sequence followed by an indefinite number of copies of the head of the base set. To prevent duplicates, the generator constructs only sequences that do not end in the first member of the base set.

allf :: (b -> Bool) -> [a -> b] -> a -> Bool

Test if application of all functions in list to a given value satisfies a given condition

anyf :: (b -> Bool) -> [a -> b] -> a -> Bool

Test if application of any functions in list to a given value satisfies a given condition

combinations :: Int -> [a] -> [[a]]

Combinations of n elements from a list, each being returned in the order that they appear in the list.