-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Case insensitive string comparison
--   
--   The module <tt>Data.CaseInsensitive</tt> provides the <a>CI</a> type
--   constructor which can be parameterised by a string-like type like:
--   <a>String</a>, <a>ByteString</a>, <a>Text</a>, etc.. Comparisons of
--   values of the resulting type will be insensitive to cases.
@package case-insensitive
@version 0.4


-- | This module is intended to be imported qualified. May I suggest:
--   
--   <pre>
--   import           Data.CaseInsensitive  ( CI )
--   import qualified Data.CaseInsensitive as CI
--   </pre>
module Data.CaseInsensitive

-- | A <tt>CI s</tt> provides <i>C</i>ase <i>I</i>nsensitive comparison for
--   the string-like type <tt>s</tt> (for example: <a>String</a>,
--   <a>Text</a>, <a>ByteString</a>, <a>ShowS</a>, etc.).
--   
--   Note that <tt>CI s</tt> has an instance for <a>IsString</a> which
--   together with the <tt>OverloadedStrings</tt> language extension allows
--   you to write case insensitive string literals as in:
--   
--   <pre>
--   &gt; ("Content-Type" :: <a>CI</a> <a>Text</a>) == ("CONTENT-TYPE" :: <a>CI</a> <a>Text</a>)
--   True
--   </pre>
data CI s

-- | Make the given string-like value case insensitive.
mk :: FoldCase s => s -> CI s

-- | Retrieve the original string-like value.
original :: CI s -> s

-- | Retrieve the case folded string-like value. (Also see
--   <a>foldCase</a>).
foldedCase :: CI s -> s

-- | Transform the original string-like value but keep it case insensitive.
map :: FoldCase s2 => (s1 -> s2) -> (CI s1 -> CI s2)

-- | Class of string-like types that support folding cases.
--   
--   <i>Note</i>: In some languages, case conversion is a locale- and
--   context-dependent operation. The <tt>foldCase</tt> method is
--   <i>not</i> intended to be locale sensitive. Programs that require
--   locale sensitivity should use appropriate versions of the case mapping
--   functions from the <tt>text-icu</tt> package:
--   <a>http://hackage.haskell.org/package/text-icu</a>
class FoldCase s
foldCase :: FoldCase s => s -> s
instance Typeable1 CI
instance FoldCase (CI s)
instance FoldCase ShowS
instance FoldCase Text
instance FoldCase Text
instance FoldCase String
instance FoldCase ByteString
instance FoldCase ByteString
instance Hashable s => Hashable (CI s)
instance Show s => Show (CI s)
instance (Read s, FoldCase s) => Read (CI s)
instance Ord s => Ord (CI s)
instance Eq s => Eq (CI s)
instance Monoid s => Monoid (CI s)
instance (IsString s, FoldCase s) => IsString (CI s)