Data.UUID

This library is useful for comparing, parsing and printing Universally Unique Identifiers. See http://en.wikipedia.org/wiki/UUID for the general idea. See http://tools.ietf.org/html/rfc4122 for the specification.

• Use nextRandom to generate secure random UUIDs, and your favorite instance of Random for faster but insecure generation of UUIDs.
• We have an implementation of generating a UUID from the hardware MAC address and current system time in Data.UUID.V1.
• For name-based generation of UUIDs using SHA-1 hashing see Data.UUID.V5.

Documentation

data UUID

Type representing Universally Unique Identifiers (UUID) as specified in RFC 4122.

Instances

Eq UUID

Defined in Data.UUID.Types.Internal

Methods

(==) :: UUID -> UUID -> Bool

(/=) :: UUID -> UUID -> Bool

Data UUID

Defined in Data.UUID.Types.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UUID -> c UUID

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UUID

toConstr :: UUID -> Constr

dataTypeOf :: UUID -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UUID)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UUID)

gmapT :: (forall b. Data b => b -> b) -> UUID -> UUID

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UUID -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UUID -> r

gmapQ :: (forall d. Data d => d -> u) -> UUID -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> UUID -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UUID -> m UUID

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UUID -> m UUID

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UUID -> m UUID

Ord UUID

Defined in Data.UUID.Types.Internal

Methods

compare :: UUID -> UUID -> Ordering

(<) :: UUID -> UUID -> Bool

(<=) :: UUID -> UUID -> Bool

(>) :: UUID -> UUID -> Bool

(>=) :: UUID -> UUID -> Bool

max :: UUID -> UUID -> UUID

min :: UUID -> UUID -> UUID

Read UUID

Defined in Data.UUID.Types.Internal

Methods

readsPrec :: Int -> ReadS UUID

readList :: ReadS [UUID]

readPrec :: ReadPrec UUID

readListPrec :: ReadPrec [UUID]

Show UUID

Pretty prints a UUID (without quotation marks). See also toString.

>>> show nil
"00000000-0000-0000-0000-000000000000"

Defined in Data.UUID.Types.Internal

Methods

showsPrec :: Int -> UUID -> ShowS

show :: UUID -> String

showList :: [UUID] -> ShowS

Storable UUID

This Storable instance uses the memory layout as described in RFC 4122, but in contrast to the Binary instance, the fields are stored in host byte order.

Defined in Data.UUID.Types.Internal

Methods

sizeOf :: UUID -> Int

alignment :: UUID -> Int

peekElemOff :: Ptr UUID -> Int -> IO UUID

pokeElemOff :: Ptr UUID -> Int -> UUID -> IO ()

peekByteOff :: Ptr b -> Int -> IO UUID

pokeByteOff :: Ptr b -> Int -> UUID -> IO ()

peek :: Ptr UUID -> IO UUID

poke :: Ptr UUID -> UUID -> IO ()

Binary UUID

This Binary instance is compatible with RFC 4122, storing the fields in network order as 16 bytes.

Defined in Data.UUID.Types.Internal

Methods

put :: UUID -> Put

get :: Get UUID

putList :: [UUID] -> Put

NFData UUID

Defined in Data.UUID.Types.Internal

Methods

rnf :: UUID -> ()

Hashable UUID

Defined in Data.UUID.Types.Internal

Methods

hashWithSalt :: Int -> UUID -> Int

hash :: UUID -> Int

Random UUID

This Random instance produces insecure version 4 UUIDs as specified in RFC 4122.

Defined in Data.UUID.Types.Internal

Methods

randomR :: RandomGen g => (UUID, UUID) -> g -> (UUID, g)

random :: RandomGen g => g -> (UUID, g)

randomRs :: RandomGen g => (UUID, UUID) -> g -> [UUID]

randoms :: RandomGen g => g -> [UUID]

Uniform UUID

Defined in Data.UUID.Types.Internal

Methods

uniformM :: StatefulGen g m => g -> m UUID

Lift UUID

Defined in Data.UUID.Types.Internal

Methods

lift :: UUID -> Q Exp

liftTyped :: UUID -> Q (TExp UUID)

toString :: UUID -> String

Convert a UUID into a hypenated string using lower-case letters. Example:

>>> toString <$> fromString "550e8400-e29b-41d4-a716-446655440000"
Just "550e8400-e29b-41d4-a716-446655440000"

fromString :: String -> Maybe UUID

If the passed in String can be parsed as a UUID, it will be. The hyphens may not be omitted. Example:

>>> fromString "c2cc10e1-57d6-4b6f-9899-38d972112d8c"
Just c2cc10e1-57d6-4b6f-9899-38d972112d8c

Hex digits may be upper or lower-case.

toText :: UUID -> Text

Convert a UUID into a hyphentated string using lower-case letters.

fromText :: Text -> Maybe UUID

If the passed in Text can be parsed as an ASCII representation of a UUID, it will be. The hyphens may not be omitted.

toASCIIBytes :: UUID -> ByteString

Convert a UUID into a hyphentated string using lower-case letters, packed as ASCII bytes into ByteString.

This should be equivalent to toString with pack.

fromASCIIBytes :: ByteString -> Maybe UUID

If the passed in ByteString can be parsed as an ASCII representation of a UUID, it will be. The hyphens may not be omitted.

This should be equivalent to fromString with unpack.

toLazyASCIIBytes :: UUID -> ByteString

Similar to toASCIIBytes except we produce a lazy ByteString.

fromLazyASCIIBytes :: ByteString -> Maybe UUID

Similar to fromASCIIBytes except parses from a lazy ByteString.

toByteString :: UUID -> ByteString

Encode a UUID into a ByteString in network order.

This uses the same encoding as the Binary instance.

fromByteString :: ByteString -> Maybe UUID

Extract a UUID from a ByteString in network byte order. The argument must be 16 bytes long, otherwise Nothing is returned.

toWords :: UUID -> (Word32, Word32, Word32, Word32)

Convert a UUID into a sequence of Word32 values. Useful for when you need to serialize a UUID and neither Storable nor Binary are appropriate.

>>> toWords <$> fromString "550e8400-e29b-41d4-a716-446655440000"
Just (1427014656,3801825748,2803254374,1430519808)

See also toWords64.

Since: uuid-1.2.2

Since: uuid-types-1.0.0

fromWords :: Word32 -> Word32 -> Word32 -> Word32 -> UUID

Create a UUID from a sequence of Word32. The inverse of toWords. Useful when you need a total function for constructing UUID values.

See also fromWords64.

Since: uuid-1.2.2

Since: uuid-types-1.0.0

toWords64 :: UUID -> (Word64, Word64)

Convert a UUID into a pair of Word64s.

>>> toWords64 <$> fromString "550e8400-e29b-41d4-a716-446655440000"
Just (6128981282234515924,12039885860129472512)

See also toWords.

Since: uuid-types-1.0.4

fromWords64 :: Word64 -> Word64 -> UUID

Create a UUID from a pair of Word64s.

Inverse of toWords64. See also fromWords.

Since: uuid-types-1.0.4

null :: UUID -> Bool

Returns true if the passed-in UUID is the nil UUID.

nil :: UUID

The nil UUID, as defined in RFC 4122. It is a UUID of all zeros. null u iff u == nil.