[a] -> [a] -> Bool

isInfixOf :: Eq a => [a] -> [a] -> Bool
base Data.List
The isInfixOf function takes two lists and returns True iff the first list is contained, wholly and intact, anywhere within the second. Example: > isInfixOf "Haskell" "I really like Haskell." == True > isInfixOf "Ial" "I really like Haskell." == False
isPrefixOf :: Eq a => [a] -> [a] -> Bool
base Data.List
The isPrefixOf function takes two lists and returns True iff the first list is a prefix of the second.
isSuffixOf :: Eq a => [a] -> [a] -> Bool
base Data.List
The isSuffixOf function takes two lists and returns True iff the first list is a suffix of the second. Both lists must be finite.
equalFilePath :: FilePath -> FilePath -> Bool
filepath System.FilePath.Windows, filepath System.FilePath.Posix
Equality of two FilePaths. If you call System.Directory.canonicalizePath first this has a much better chance of working. Note that this doesn't follow symlinks or DOSNAM~1s. > x == y ==> equalFilePath x y > normalise x == normalise y ==> equalFilePath x y > Posix: equalFilePath "foo" "foo/" > Posix: not (equalFilePath "foo" "/foo") > Posix: not (equalFilePath "foo" "FOO") > Windows: equalFilePath "foo" "FOO"
MkQueue :: [a] -> [a] -> Queue a
fgl Data.Graph.Inductive.Internal.Queue
(++) :: [a] -> [a] -> [a]
base Prelude, base Data.List
Append two lists, i.e., > [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] > [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...] If the first list is not finite, the result is the first list.
elem :: Eq a => a -> [a] -> Bool
base Prelude, base Data.List
elem is the list membership predicate, usually written in infix form, e.g., x `elem` xs. For the result to be False, the list must be finite; True, however, results from an element equal to x found at a finite index of a finite or infinite list.
notElem :: Eq a => a -> [a] -> Bool
base Prelude, base Data.List
notElem is the negation of elem.
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The deleteFirstsBy function takes a predicate and two lists and returns the first list with the first occurrence of each element of the second list removed.
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The intersectBy function is the non-overloaded version of intersect.
unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The unionBy function is the non-overloaded version of union.
intercalate :: [a] -> [[a]] -> [a]
base Data.List
intercalate xs xss is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.
(<|>) :: Alternative f => f a -> f a -> f a
base Control.Applicative
mplus :: MonadPlus m => m a -> m a -> m a
base Control.Monad
elem :: (Foldable t, Eq a) => a -> t a -> Bool
base Data.Foldable
Does the element occur in the structure?
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
base Data.Foldable
notElem is the negation of elem.
intersperse :: a -> [a] -> [a]
base Data.List
The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example, > intersperse ',' "abcde" == "a,b,c,d,e"
asTypeOf :: a -> a -> a
base Prelude
asTypeOf is a type-restricted version of const. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.
(<) :: Ord a => a -> a -> Bool
base Prelude, base Data.Ord
(<=) :: Ord a => a -> a -> Bool
base Prelude, base Data.Ord

Show more results