| Safe Haskell | Safe | 
|---|---|
| Language | Haskell2010 | 
Data.Text.Conversions
Description
This module provides a set of typeclasses for safely converting between
  textual data. The built-in String type, as well as strict Text and lazy
  Text, are safely convertible between one another. The ByteString type
  is frequently treated in much the same manner, but this is unsafe for two
  reasons:
- Since ByteStringencodes binary data, it does not specify a particular encoding, so assuming a particular encoding like UTF-8 would be incorrect.
- Furthermore, decoding binary data into text given a particular encoding can
    fail. Most systems simply use decodeUtf8and similar functions, which will dangerously throw exceptions when given invalid data.
This module addresses both problems by providing a DecodeText typeclass for
  decoding binary data in a way that can fail and by providing a UTF8 wrapper
  type for selecting the desired encoding.
Most of the time, you will not need to create your own instances or use the
  underlying functions that make the conversion machinery tick. Instead, just
  use the convertText method to convert between two textual datatypes or the
  decodeConvertText method to perform a conversion that can fail.
Examples:
>>>convertText ("hello" :: String) :: Text"hello">>>decodeConvertText (UTF8 ("hello" :: ByteString)) :: Maybe TextJust "hello">>>decodeConvertText (UTF8 ("\xc3\x28" :: ByteString)) :: Maybe TextNothing
Synopsis
- class FromText a where
- class ToText a where
- class Functor f => DecodeText f a where- decodeText :: a -> f Text
 
- convertText :: (ToText a, FromText b) => a -> b
- decodeConvertText :: (DecodeText f a, FromText b) => a -> f b
- newtype UTF8 a = UTF8 {- unUTF8 :: a
 
- newtype Base16 a = Base16 {- unBase16 :: a
 
- newtype Base64 a = Base64 {- unBase64 :: a
 
Conversion typeclasses and functions
class FromText a where Source #
A simple typeclass that handles converting Text to arbitrary datatypes. If
  you have a type that can be produced from text, implement this typeclass.
  However, you probably do not want to call fromText directly; call
  convertText, instead.
Instances
| FromText String Source # | |
| FromText Text Source # | |
| FromText Text Source # | |
| FromText (Maybe (Base64 ByteString)) Source # | |
| Defined in Data.Text.Conversions | |
| FromText (Maybe (Base64 ByteString)) Source # | |
| Defined in Data.Text.Conversions | |
| FromText (Maybe (Base16 ByteString)) Source # | |
| Defined in Data.Text.Conversions | |
| FromText (Maybe (Base16 ByteString)) Source # | |
| Defined in Data.Text.Conversions | |
| FromText (UTF8 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
| FromText (UTF8 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
A simple typeclass that handles converting arbitrary datatypes to Text
  when the operation cannot fail. If you have a type that satisfies that
  requirement, implement this typeclass, but if the operation can fail, use
  DecodeText instead.
Instances
| ToText String Source # | |
| ToText Text Source # | |
| ToText Text Source # | |
| ToText (Base64 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
| ToText (Base64 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
| ToText (Base16 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
| ToText (Base16 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
class Functor f => DecodeText f a where Source #
A simple typeclass that handles converting arbitrary datatypes to
  Text when the operation can fail. If you have a type that satisfies that
  requirement, implement this typeclass, but if the operation cannot fail, use
  ToText instead.
Methods
decodeText :: a -> f Text Source #
Instances
| DecodeText Maybe (UTF8 ByteString) Source # | |
| Defined in Data.Text.Conversions Methods decodeText :: UTF8 ByteString -> Maybe Text Source # | |
| DecodeText Maybe (UTF8 ByteString) Source # | |
| Defined in Data.Text.Conversions Methods decodeText :: UTF8 ByteString -> Maybe Text Source # | |
convertText :: (ToText a, FromText b) => a -> b Source #
A function that provides a way to safely convert between arbitrary textual datatypes where the conversion to text cannot fail.
>>>convertText ("hello" :: String) :: Text"hello"
decodeConvertText :: (DecodeText f a, FromText b) => a -> f b Source #
A function that provides a way to safely convert between arbitrary textual
  datatypes where the conversion to text can fail, such as decoding binary data
  to text. Since binary data can represent text in many different potential
  encodings, it is necessary to use a newtype that picks the particular
  encoding, like UTF8:
>>>decodeConvertText (UTF8 ("hello" :: ByteString)) :: Maybe TextJust "hello"
Encoding newtypes
Simple wrapper type that is used to select a desired encoding when encoding or
  decoding text from binary data, such as ByteStrings. The conversion is not
  partial; it will result in Nothing when a ByteString is provided with
  data that is not valid in UTF-8.
>>>convertText ("hello" :: Text) :: UTF8 ByteStringUTF8 "hello">>>decodeConvertText (UTF8 ("hello" :: ByteString)) :: Maybe TextJust "hello">>>decodeConvertText (UTF8 ("invalid \xc3\x28" :: ByteString)) :: Maybe TextNothing
Instances
| Functor UTF8 Source # | |
| DecodeText Maybe (UTF8 ByteString) Source # | |
| Defined in Data.Text.Conversions Methods decodeText :: UTF8 ByteString -> Maybe Text Source # | |
| DecodeText Maybe (UTF8 ByteString) Source # | |
| Defined in Data.Text.Conversions Methods decodeText :: UTF8 ByteString -> Maybe Text Source # | |
| Eq a => Eq (UTF8 a) Source # | |
| Show a => Show (UTF8 a) Source # | |
| FromText (UTF8 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
| FromText (UTF8 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
Wrapper type used to select a base 16 encoding when encoding or decoding binary data. Safe because base 16 encoding will always produce ASCII output.
Instances
| Functor Base16 Source # | |
| Eq a => Eq (Base16 a) Source # | |
| Show a => Show (Base16 a) Source # | |
| FromText (Maybe (Base16 ByteString)) Source # | |
| Defined in Data.Text.Conversions | |
| FromText (Maybe (Base16 ByteString)) Source # | |
| Defined in Data.Text.Conversions | |
| ToText (Base16 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
| ToText (Base16 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
Wrapper type used to select a base 64 encoding when encoding or decoding binary data. Safe because base 64 encoding will always produce ASCII output.
Instances
| Functor Base64 Source # | |
| Eq a => Eq (Base64 a) Source # | |
| Show a => Show (Base64 a) Source # | |
| FromText (Maybe (Base64 ByteString)) Source # | |
| Defined in Data.Text.Conversions | |
| FromText (Maybe (Base64 ByteString)) Source # | |
| Defined in Data.Text.Conversions | |
| ToText (Base64 ByteString) Source # | |
| Defined in Data.Text.Conversions | |
| ToText (Base64 ByteString) Source # | |
| Defined in Data.Text.Conversions | |