case-insensitive-1.2.0.9: Case insensitive string comparison

Copyright | (c) 2011-2013 Bas van Dijk
License | BSD-style (see the file LICENSE)
Maintainer | Bas van Dijk <v.dijk.bas@gmail.com>
Safe Haskell | Trustworthy
Language | Haskell98

Data.CaseInsensitive

Description

This module is intended to be imported qualified. May I suggest:

    import           Data.CaseInsensitive  ( CI )
    import qualified Data.CaseInsensitive as CI

Note that the FoldCase instance for ByteStrings is only guaranteed to be correct for ISO-8859-1 encoded strings!

Synopsis

- data CI s
- mk :: FoldCase s => s -> CI s
- original :: CI s -> s
- foldedCase :: CI s -> s
- map :: FoldCase s2 => (s1 -> s2) -> CI s1 -> CI s2
- class FoldCase s where

# Documentation

data CI s #

A `CI s` provides Case Insensitive comparison for the string-like type `s` (for example: `String`, `Text`, `ByteString`, etc.).

Note that `CI s` has an instance for `IsString` which together with the `OverloadedStrings` language extension allows you to write case insensitive string literals as in:

    > ("Content-Type" :: CI Text) == ("CONTENT-TYPE" :: CI Text)
    True

Instances

Eq s => Eq (CI s) # |
Methods (==) :: CI s -> CI s -> Bool # (/=) :: CI s -> CI s -> Bool #
Data s => Data (CI s) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CI s -> c (CI s) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CI s) # toConstr :: CI s -> Constr # dataTypeOf :: CI s -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CI s)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CI s)) # gmapT :: (forall b. Data b => b -> b) -> CI s -> CI s # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CI s -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CI s -> r # gmapQ :: (forall d. Data d => d -> u) -> CI s -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CI s -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CI s -> m (CI s) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CI s -> m (CI s) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CI s -> m (CI s) #
Ord s => Ord (CI s) # |
Methods compare :: CI s -> CI s -> Ordering # (<) :: CI s -> CI s -> Bool # (<=) :: CI s -> CI s -> Bool # (>) :: CI s -> CI s -> Bool # (>=) :: CI s -> CI s -> Bool # max :: CI s -> CI s -> CI s # min :: CI s -> CI s -> CI s #
(Read s, FoldCase s) => Read (CI s) # |
Methods readsPrec :: Int -> ReadS (CI s) # readList :: ReadS [CI s] # readPrec :: ReadPrec (CI s) # readListPrec :: ReadPrec [CI s] #
Show s => Show (CI s) # |
Methods showsPrec :: Int -> CI s -> ShowS # show :: CI s -> String # showList :: [CI s] -> ShowS #
(IsString s, FoldCase s) => IsString (CI s) # |
Methods fromString :: String -> CI s #
Semigroup s => Semigroup (CI s) # |
Methods (<>) :: CI s -> CI s -> CI s # sconcat :: NonEmpty (CI s) -> CI s # stimes :: Integral b => b -> CI s -> CI s #
Monoid s => Monoid (CI s) # |
Methods mempty :: CI s # mappend :: CI s -> CI s -> CI s # mconcat :: [CI s] -> CI s #
NFData s => NFData (CI s) # |
Methods rnf :: CI s -> () #
Hashable s => Hashable (CI s) # |
Methods hashWithSalt :: Int -> CI s -> Int # hash :: CI s -> Int #
FoldCase (CI s) # |
Methods foldCase :: CI s -> CI s # foldCaseList :: [CI s] -> [CI s]

mk :: FoldCase s => s -> CI s #

Make the given string-like value case insensitive.

original :: CI s -> s #

Retrieve the original string-like value.

foldedCase :: CI s -> s #

Retrieve the case folded string-like value. (Also see `foldCase`).

map :: FoldCase s2 => (s1 -> s2) -> CI s1 -> CI s2 #

Transform the original string-like value but keep it case insensitive.

class FoldCase s where #

Class of string-like types that support folding cases.

Note: In some languages, case conversion is a locale- and context-dependent operation. The `foldCase` method is not intended to be locale sensitive. Programs that require locale sensitivity should use appropriate versions of the case mapping functions from the `text-icu` package: http://hackage.haskell.org/package/text-icu

Minimal complete definition

foldCase

Methods

foldCase :: s -> s #

Instances

FoldCase Char # |
Methods foldCase :: Char -> Char # foldCaseList :: [Char] -> [Char]
FoldCase ByteString # | Note that `foldCase` on ``ByteString`s` is only guaranteed to be correct for ISO-8859-1 encoded strings!
Methods foldCase :: ByteString -> ByteString # foldCaseList :: [ByteString] -> [ByteString]
FoldCase ByteString # | Note that `foldCase` on ``ByteString`s` is only guaranteed to be correct for ISO-8859-1 encoded strings!
Methods foldCase :: ByteString -> ByteString # foldCaseList :: [ByteString] -> [ByteString]
FoldCase Text # |
Methods foldCase :: Text -> Text # foldCaseList :: [Text] -> [Text]
FoldCase Text # |
Methods foldCase :: Text -> Text # foldCaseList :: [Text] -> [Text]
FoldCase a => FoldCase [a] # |
Methods foldCase :: [a] -> [a] # foldCaseList :: [[a]] -> [[a]]
FoldCase (CI s) # |
Methods foldCase :: CI s -> CI s # foldCaseList :: [CI s] -> [CI s]