{-# LANGUAGE DeriveDataTypeable, DeriveFunctor, GeneralizedNewtypeDeriving #-}

-- |
-- Module:      Database.MySQL.Simple.Types
-- Copyright:   (c) 2011 MailRank, Inc.
-- License:     BSD3
-- Maintainer:  Paul Rouse <pyr@doynton.org>
-- Stability:   experimental
-- Portability: portable
--
-- Basic types.

module Database.MySQL.Simple.Types
    (
      Null(..)
    , Only(..)
    , In(..)
    , VaArgs(..)
    , Binary(..)
    , Query(..)
    ) where

import Blaze.ByteString.Builder (toByteString)
import Control.Arrow (first)
import Data.ByteString (ByteString)
import Data.Semigroup (Semigroup(..))
import Data.Monoid (Monoid(..))
import Data.String (IsString(..))
import Data.Typeable (Typeable)
import qualified Blaze.ByteString.Builder.Char.Utf8 as Utf8
import qualified Data.ByteString as B

-- | A placeholder for the SQL @NULL@ value.
data Null = Null
          deriving (ReadPrec [Null]
ReadPrec Null
Int -> ReadS Null
ReadS [Null]
(Int -> ReadS Null)
-> ReadS [Null] -> ReadPrec Null -> ReadPrec [Null] -> Read Null
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Null]
$creadListPrec :: ReadPrec [Null]
readPrec :: ReadPrec Null
$creadPrec :: ReadPrec Null
readList :: ReadS [Null]
$creadList :: ReadS [Null]
readsPrec :: Int -> ReadS Null
$creadsPrec :: Int -> ReadS Null
Read, Int -> Null -> ShowS
[Null] -> ShowS
Null -> String
(Int -> Null -> ShowS)
-> (Null -> String) -> ([Null] -> ShowS) -> Show Null
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Null] -> ShowS
$cshowList :: [Null] -> ShowS
show :: Null -> String
$cshow :: Null -> String
showsPrec :: Int -> Null -> ShowS
$cshowsPrec :: Int -> Null -> ShowS
Show, Typeable)

instance Eq Null where
    Null
_ == :: Null -> Null -> Bool
== Null
_ = Bool
False
    Null
_ /= :: Null -> Null -> Bool
/= Null
_ = Bool
False

-- | A query string. This type is intended to make it difficult to
-- construct a SQL query by concatenating string fragments, as that is
-- an extremely common way to accidentally introduce SQL injection
-- vulnerabilities into an application.
--
-- This type is an instance of 'IsString', so the easiest way to
-- construct a query is to enable the @OverloadedStrings@ language
-- extension and then simply write the query in double quotes.
--
-- > {-# LANGUAGE OverloadedStrings #-}
-- >
-- > import Database.MySQL.Simple
-- >
-- > q :: Query
-- > q = "select ?"
--
-- The underlying type is a 'ByteString', and literal Haskell strings
-- that contain Unicode characters will be correctly transformed to
-- UTF-8.
newtype Query = Query {
      Query -> ByteString
fromQuery :: ByteString
    } deriving (Query -> Query -> Bool
(Query -> Query -> Bool) -> (Query -> Query -> Bool) -> Eq Query
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Query -> Query -> Bool
$c/= :: Query -> Query -> Bool
== :: Query -> Query -> Bool
$c== :: Query -> Query -> Bool
Eq, Eq Query
Eq Query
-> (Query -> Query -> Ordering)
-> (Query -> Query -> Bool)
-> (Query -> Query -> Bool)
-> (Query -> Query -> Bool)
-> (Query -> Query -> Bool)
-> (Query -> Query -> Query)
-> (Query -> Query -> Query)
-> Ord Query
Query -> Query -> Bool
Query -> Query -> Ordering
Query -> Query -> Query
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Query -> Query -> Query
$cmin :: Query -> Query -> Query
max :: Query -> Query -> Query
$cmax :: Query -> Query -> Query
>= :: Query -> Query -> Bool
$c>= :: Query -> Query -> Bool
> :: Query -> Query -> Bool
$c> :: Query -> Query -> Bool
<= :: Query -> Query -> Bool
$c<= :: Query -> Query -> Bool
< :: Query -> Query -> Bool
$c< :: Query -> Query -> Bool
compare :: Query -> Query -> Ordering
$ccompare :: Query -> Query -> Ordering
Ord, Typeable)

instance Show Query where
    show :: Query -> String
show = ByteString -> String
forall a. Show a => a -> String
show (ByteString -> String) -> (Query -> ByteString) -> Query -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Query -> ByteString
fromQuery

instance Read Query where
    readsPrec :: Int -> ReadS Query
readsPrec Int
i = ((ByteString, String) -> (Query, String))
-> [(ByteString, String)] -> [(Query, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((ByteString -> Query) -> (ByteString, String) -> (Query, String)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first ByteString -> Query
Query) ([(ByteString, String)] -> [(Query, String)])
-> (String -> [(ByteString, String)]) -> ReadS Query
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String -> [(ByteString, String)]
forall a. Read a => Int -> ReadS a
readsPrec Int
i

instance IsString Query where
    fromString :: String -> Query
fromString = ByteString -> Query
Query (ByteString -> Query) -> (String -> ByteString) -> String -> Query
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> ByteString
toByteString (Builder -> ByteString)
-> (String -> Builder) -> String -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Builder
Utf8.fromString

instance Semigroup Query where
    <> :: Query -> Query -> Query
(<>) (Query ByteString
a) (Query ByteString
b) = ByteString -> Query
Query (ByteString -> ByteString -> ByteString
B.append ByteString
a ByteString
b)
    {-# INLINE (<>) #-}

instance Monoid Query where
    mempty :: Query
mempty = ByteString -> Query
Query ByteString
B.empty
    mappend :: Query -> Query -> Query
mappend = Query -> Query -> Query
forall a. Semigroup a => a -> a -> a
(<>)
    {-# INLINE mappend #-}

-- | A single-value \"collection\".
--
-- This is useful if you need to supply a single parameter to a SQL
-- query, or extract a single column from a SQL result.
--
-- Parameter example:
--
-- @query c \"select x from scores where x > ?\" ('Only' (42::Int))@
--
-- Result example:
--
-- @xs <- query_ c \"select id from users\"
--forM_ xs $ \\('Only' id) -> {- ... -}@
newtype Only a = Only {
      forall a. Only a -> a
fromOnly :: a
    } deriving (Only a -> Only a -> Bool
(Only a -> Only a -> Bool)
-> (Only a -> Only a -> Bool) -> Eq (Only a)
forall a. Eq a => Only a -> Only a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Only a -> Only a -> Bool
$c/= :: forall a. Eq a => Only a -> Only a -> Bool
== :: Only a -> Only a -> Bool
$c== :: forall a. Eq a => Only a -> Only a -> Bool
Eq, Eq (Only a)
Eq (Only a)
-> (Only a -> Only a -> Ordering)
-> (Only a -> Only a -> Bool)
-> (Only a -> Only a -> Bool)
-> (Only a -> Only a -> Bool)
-> (Only a -> Only a -> Bool)
-> (Only a -> Only a -> Only a)
-> (Only a -> Only a -> Only a)
-> Ord (Only a)
Only a -> Only a -> Bool
Only a -> Only a -> Ordering
Only a -> Only a -> Only a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Only a)
forall a. Ord a => Only a -> Only a -> Bool
forall a. Ord a => Only a -> Only a -> Ordering
forall a. Ord a => Only a -> Only a -> Only a
min :: Only a -> Only a -> Only a
$cmin :: forall a. Ord a => Only a -> Only a -> Only a
max :: Only a -> Only a -> Only a
$cmax :: forall a. Ord a => Only a -> Only a -> Only a
>= :: Only a -> Only a -> Bool
$c>= :: forall a. Ord a => Only a -> Only a -> Bool
> :: Only a -> Only a -> Bool
$c> :: forall a. Ord a => Only a -> Only a -> Bool
<= :: Only a -> Only a -> Bool
$c<= :: forall a. Ord a => Only a -> Only a -> Bool
< :: Only a -> Only a -> Bool
$c< :: forall a. Ord a => Only a -> Only a -> Bool
compare :: Only a -> Only a -> Ordering
$ccompare :: forall a. Ord a => Only a -> Only a -> Ordering
Ord, ReadPrec [Only a]
ReadPrec (Only a)
Int -> ReadS (Only a)
ReadS [Only a]
(Int -> ReadS (Only a))
-> ReadS [Only a]
-> ReadPrec (Only a)
-> ReadPrec [Only a]
-> Read (Only a)
forall a. Read a => ReadPrec [Only a]
forall a. Read a => ReadPrec (Only a)
forall a. Read a => Int -> ReadS (Only a)
forall a. Read a => ReadS [Only a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Only a]
$creadListPrec :: forall a. Read a => ReadPrec [Only a]
readPrec :: ReadPrec (Only a)
$creadPrec :: forall a. Read a => ReadPrec (Only a)
readList :: ReadS [Only a]
$creadList :: forall a. Read a => ReadS [Only a]
readsPrec :: Int -> ReadS (Only a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Only a)
Read, Int -> Only a -> ShowS
[Only a] -> ShowS
Only a -> String
(Int -> Only a -> ShowS)
-> (Only a -> String) -> ([Only a] -> ShowS) -> Show (Only a)
forall a. Show a => Int -> Only a -> ShowS
forall a. Show a => [Only a] -> ShowS
forall a. Show a => Only a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Only a] -> ShowS
$cshowList :: forall a. Show a => [Only a] -> ShowS
show :: Only a -> String
$cshow :: forall a. Show a => Only a -> String
showsPrec :: Int -> Only a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Only a -> ShowS
Show, Typeable, (forall a b. (a -> b) -> Only a -> Only b)
-> (forall a b. a -> Only b -> Only a) -> Functor Only
forall a b. a -> Only b -> Only a
forall a b. (a -> b) -> Only a -> Only b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Only b -> Only a
$c<$ :: forall a b. a -> Only b -> Only a
fmap :: forall a b. (a -> b) -> Only a -> Only b
$cfmap :: forall a b. (a -> b) -> Only a -> Only b
Functor)

-- | Wrap a list of values for use in an @IN@ clause.  Replaces a
-- single \"@?@\" character with a parenthesized list of rendered
-- values.
--
-- Example:
--
-- > query c "select * from whatever where id in ?" (Only (In [3,4,5]))
newtype In a = In a
    deriving (In a -> In a -> Bool
(In a -> In a -> Bool) -> (In a -> In a -> Bool) -> Eq (In a)
forall a. Eq a => In a -> In a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: In a -> In a -> Bool
$c/= :: forall a. Eq a => In a -> In a -> Bool
== :: In a -> In a -> Bool
$c== :: forall a. Eq a => In a -> In a -> Bool
Eq, Eq (In a)
Eq (In a)
-> (In a -> In a -> Ordering)
-> (In a -> In a -> Bool)
-> (In a -> In a -> Bool)
-> (In a -> In a -> Bool)
-> (In a -> In a -> Bool)
-> (In a -> In a -> In a)
-> (In a -> In a -> In a)
-> Ord (In a)
In a -> In a -> Bool
In a -> In a -> Ordering
In a -> In a -> In a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (In a)
forall a. Ord a => In a -> In a -> Bool
forall a. Ord a => In a -> In a -> Ordering
forall a. Ord a => In a -> In a -> In a
min :: In a -> In a -> In a
$cmin :: forall a. Ord a => In a -> In a -> In a
max :: In a -> In a -> In a
$cmax :: forall a. Ord a => In a -> In a -> In a
>= :: In a -> In a -> Bool
$c>= :: forall a. Ord a => In a -> In a -> Bool
> :: In a -> In a -> Bool
$c> :: forall a. Ord a => In a -> In a -> Bool
<= :: In a -> In a -> Bool
$c<= :: forall a. Ord a => In a -> In a -> Bool
< :: In a -> In a -> Bool
$c< :: forall a. Ord a => In a -> In a -> Bool
compare :: In a -> In a -> Ordering
$ccompare :: forall a. Ord a => In a -> In a -> Ordering
Ord, ReadPrec [In a]
ReadPrec (In a)
Int -> ReadS (In a)
ReadS [In a]
(Int -> ReadS (In a))
-> ReadS [In a]
-> ReadPrec (In a)
-> ReadPrec [In a]
-> Read (In a)
forall a. Read a => ReadPrec [In a]
forall a. Read a => ReadPrec (In a)
forall a. Read a => Int -> ReadS (In a)
forall a. Read a => ReadS [In a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [In a]
$creadListPrec :: forall a. Read a => ReadPrec [In a]
readPrec :: ReadPrec (In a)
$creadPrec :: forall a. Read a => ReadPrec (In a)
readList :: ReadS [In a]
$creadList :: forall a. Read a => ReadS [In a]
readsPrec :: Int -> ReadS (In a)
$creadsPrec :: forall a. Read a => Int -> ReadS (In a)
Read, Int -> In a -> ShowS
[In a] -> ShowS
In a -> String
(Int -> In a -> ShowS)
-> (In a -> String) -> ([In a] -> ShowS) -> Show (In a)
forall a. Show a => Int -> In a -> ShowS
forall a. Show a => [In a] -> ShowS
forall a. Show a => In a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [In a] -> ShowS
$cshowList :: forall a. Show a => [In a] -> ShowS
show :: In a -> String
$cshow :: forall a. Show a => In a -> String
showsPrec :: Int -> In a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> In a -> ShowS
Show, Typeable, (forall a b. (a -> b) -> In a -> In b)
-> (forall a b. a -> In b -> In a) -> Functor In
forall a b. a -> In b -> In a
forall a b. (a -> b) -> In a -> In b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> In b -> In a
$c<$ :: forall a b. a -> In b -> In a
fmap :: forall a b. (a -> b) -> In a -> In b
$cfmap :: forall a b. (a -> b) -> In a -> In b
Functor)

-- | Wrap a list of values for use in a function with variable arguments.
-- Replaces a single \"@?@\" character with a non-parenthesized list of
-- rendered values.
--
-- Example:
--
-- > query conn
-- >   "SELECT * FROM example_table ORDER BY field(f,?)"
-- >   (Only (VaArgs [3,2,1]))
newtype VaArgs a = VaArgs a
  deriving (VaArgs a -> VaArgs a -> Bool
(VaArgs a -> VaArgs a -> Bool)
-> (VaArgs a -> VaArgs a -> Bool) -> Eq (VaArgs a)
forall a. Eq a => VaArgs a -> VaArgs a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VaArgs a -> VaArgs a -> Bool
$c/= :: forall a. Eq a => VaArgs a -> VaArgs a -> Bool
== :: VaArgs a -> VaArgs a -> Bool
$c== :: forall a. Eq a => VaArgs a -> VaArgs a -> Bool
Eq, Eq (VaArgs a)
Eq (VaArgs a)
-> (VaArgs a -> VaArgs a -> Ordering)
-> (VaArgs a -> VaArgs a -> Bool)
-> (VaArgs a -> VaArgs a -> Bool)
-> (VaArgs a -> VaArgs a -> Bool)
-> (VaArgs a -> VaArgs a -> Bool)
-> (VaArgs a -> VaArgs a -> VaArgs a)
-> (VaArgs a -> VaArgs a -> VaArgs a)
-> Ord (VaArgs a)
VaArgs a -> VaArgs a -> Bool
VaArgs a -> VaArgs a -> Ordering
VaArgs a -> VaArgs a -> VaArgs a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (VaArgs a)
forall a. Ord a => VaArgs a -> VaArgs a -> Bool
forall a. Ord a => VaArgs a -> VaArgs a -> Ordering
forall a. Ord a => VaArgs a -> VaArgs a -> VaArgs a
min :: VaArgs a -> VaArgs a -> VaArgs a
$cmin :: forall a. Ord a => VaArgs a -> VaArgs a -> VaArgs a
max :: VaArgs a -> VaArgs a -> VaArgs a
$cmax :: forall a. Ord a => VaArgs a -> VaArgs a -> VaArgs a
>= :: VaArgs a -> VaArgs a -> Bool
$c>= :: forall a. Ord a => VaArgs a -> VaArgs a -> Bool
> :: VaArgs a -> VaArgs a -> Bool
$c> :: forall a. Ord a => VaArgs a -> VaArgs a -> Bool
<= :: VaArgs a -> VaArgs a -> Bool
$c<= :: forall a. Ord a => VaArgs a -> VaArgs a -> Bool
< :: VaArgs a -> VaArgs a -> Bool
$c< :: forall a. Ord a => VaArgs a -> VaArgs a -> Bool
compare :: VaArgs a -> VaArgs a -> Ordering
$ccompare :: forall a. Ord a => VaArgs a -> VaArgs a -> Ordering
Ord, ReadPrec [VaArgs a]
ReadPrec (VaArgs a)
Int -> ReadS (VaArgs a)
ReadS [VaArgs a]
(Int -> ReadS (VaArgs a))
-> ReadS [VaArgs a]
-> ReadPrec (VaArgs a)
-> ReadPrec [VaArgs a]
-> Read (VaArgs a)
forall a. Read a => ReadPrec [VaArgs a]
forall a. Read a => ReadPrec (VaArgs a)
forall a. Read a => Int -> ReadS (VaArgs a)
forall a. Read a => ReadS [VaArgs a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VaArgs a]
$creadListPrec :: forall a. Read a => ReadPrec [VaArgs a]
readPrec :: ReadPrec (VaArgs a)
$creadPrec :: forall a. Read a => ReadPrec (VaArgs a)
readList :: ReadS [VaArgs a]
$creadList :: forall a. Read a => ReadS [VaArgs a]
readsPrec :: Int -> ReadS (VaArgs a)
$creadsPrec :: forall a. Read a => Int -> ReadS (VaArgs a)
Read, Int -> VaArgs a -> ShowS
[VaArgs a] -> ShowS
VaArgs a -> String
(Int -> VaArgs a -> ShowS)
-> (VaArgs a -> String) -> ([VaArgs a] -> ShowS) -> Show (VaArgs a)
forall a. Show a => Int -> VaArgs a -> ShowS
forall a. Show a => [VaArgs a] -> ShowS
forall a. Show a => VaArgs a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VaArgs a] -> ShowS
$cshowList :: forall a. Show a => [VaArgs a] -> ShowS
show :: VaArgs a -> String
$cshow :: forall a. Show a => VaArgs a -> String
showsPrec :: Int -> VaArgs a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> VaArgs a -> ShowS
Show, Typeable, (forall a b. (a -> b) -> VaArgs a -> VaArgs b)
-> (forall a b. a -> VaArgs b -> VaArgs a) -> Functor VaArgs
forall a b. a -> VaArgs b -> VaArgs a
forall a b. (a -> b) -> VaArgs a -> VaArgs b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> VaArgs b -> VaArgs a
$c<$ :: forall a b. a -> VaArgs b -> VaArgs a
fmap :: forall a b. (a -> b) -> VaArgs a -> VaArgs b
$cfmap :: forall a b. (a -> b) -> VaArgs a -> VaArgs b
Functor)

-- | Wrap a mostly-binary string to be escaped in hexadecimal.
newtype Binary a = Binary a
    deriving (Binary a -> Binary a -> Bool
(Binary a -> Binary a -> Bool)
-> (Binary a -> Binary a -> Bool) -> Eq (Binary a)
forall a. Eq a => Binary a -> Binary a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Binary a -> Binary a -> Bool
$c/= :: forall a. Eq a => Binary a -> Binary a -> Bool
== :: Binary a -> Binary a -> Bool
$c== :: forall a. Eq a => Binary a -> Binary a -> Bool
Eq, Eq (Binary a)
Eq (Binary a)
-> (Binary a -> Binary a -> Ordering)
-> (Binary a -> Binary a -> Bool)
-> (Binary a -> Binary a -> Bool)
-> (Binary a -> Binary a -> Bool)
-> (Binary a -> Binary a -> Bool)
-> (Binary a -> Binary a -> Binary a)
-> (Binary a -> Binary a -> Binary a)
-> Ord (Binary a)
Binary a -> Binary a -> Bool
Binary a -> Binary a -> Ordering
Binary a -> Binary a -> Binary a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Binary a)
forall a. Ord a => Binary a -> Binary a -> Bool
forall a. Ord a => Binary a -> Binary a -> Ordering
forall a. Ord a => Binary a -> Binary a -> Binary a
min :: Binary a -> Binary a -> Binary a
$cmin :: forall a. Ord a => Binary a -> Binary a -> Binary a
max :: Binary a -> Binary a -> Binary a
$cmax :: forall a. Ord a => Binary a -> Binary a -> Binary a
>= :: Binary a -> Binary a -> Bool
$c>= :: forall a. Ord a => Binary a -> Binary a -> Bool
> :: Binary a -> Binary a -> Bool
$c> :: forall a. Ord a => Binary a -> Binary a -> Bool
<= :: Binary a -> Binary a -> Bool
$c<= :: forall a. Ord a => Binary a -> Binary a -> Bool
< :: Binary a -> Binary a -> Bool
$c< :: forall a. Ord a => Binary a -> Binary a -> Bool
compare :: Binary a -> Binary a -> Ordering
$ccompare :: forall a. Ord a => Binary a -> Binary a -> Ordering
Ord, ReadPrec [Binary a]
ReadPrec (Binary a)
Int -> ReadS (Binary a)
ReadS [Binary a]
(Int -> ReadS (Binary a))
-> ReadS [Binary a]
-> ReadPrec (Binary a)
-> ReadPrec [Binary a]
-> Read (Binary a)
forall a. Read a => ReadPrec [Binary a]
forall a. Read a => ReadPrec (Binary a)
forall a. Read a => Int -> ReadS (Binary a)
forall a. Read a => ReadS [Binary a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Binary a]
$creadListPrec :: forall a. Read a => ReadPrec [Binary a]
readPrec :: ReadPrec (Binary a)
$creadPrec :: forall a. Read a => ReadPrec (Binary a)
readList :: ReadS [Binary a]
$creadList :: forall a. Read a => ReadS [Binary a]
readsPrec :: Int -> ReadS (Binary a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Binary a)
Read, Int -> Binary a -> ShowS
[Binary a] -> ShowS
Binary a -> String
(Int -> Binary a -> ShowS)
-> (Binary a -> String) -> ([Binary a] -> ShowS) -> Show (Binary a)
forall a. Show a => Int -> Binary a -> ShowS
forall a. Show a => [Binary a] -> ShowS
forall a. Show a => Binary a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Binary a] -> ShowS
$cshowList :: forall a. Show a => [Binary a] -> ShowS
show :: Binary a -> String
$cshow :: forall a. Show a => Binary a -> String
showsPrec :: Int -> Binary a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Binary a -> ShowS
Show, Typeable, (forall a b. (a -> b) -> Binary a -> Binary b)
-> (forall a b. a -> Binary b -> Binary a) -> Functor Binary
forall a b. a -> Binary b -> Binary a
forall a b. (a -> b) -> Binary a -> Binary b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Binary b -> Binary a
$c<$ :: forall a b. a -> Binary b -> Binary a
fmap :: forall a b. (a -> b) -> Binary a -> Binary b
$cfmap :: forall a b. (a -> b) -> Binary a -> Binary b
Functor)