Coinbase.Exchange.Types

Documentation

data ApiType

Constructors

Sandbox

Live

Instances

Show ApiType

Methods

showsPrec :: Int -> ApiType -> ShowS

show :: ApiType -> String

showList :: [ApiType] -> ShowS

type Endpoint = String

type Path = String

website :: Endpoint

sandboxRest :: Endpoint

sandboxSocket :: Endpoint

liveRest :: Endpoint

liveSocket :: Endpoint

liveRealCoinbaseRest :: Endpoint

sandboxRealCoinbaseRest :: Endpoint

type Key = ByteString

type Secret = ByteString

type Passphrase = ByteString

data Token

key :: Token -> ByteString

secret :: Token -> ByteString

passphrase :: Token -> ByteString

mkToken :: Key -> Secret -> Passphrase -> Either String Token

data ExchangeConf

Constructors

ExchangeConf

Fields

• manager :: Manager
• authToken :: Maybe Token
• apiType :: ApiType

Instances

Monad m => MonadReader ExchangeConf (ExchangeT m)

Methods

ask :: ExchangeT m ExchangeConf

local :: (ExchangeConf -> ExchangeConf) -> ExchangeT m a -> ExchangeT m a

reader :: (ExchangeConf -> a) -> ExchangeT m a

data ExchangeFailure

Constructors

ParseFailure Text

ApiFailure Text

AuthenticationRequiredFailure Text

AuthenticationRequiresByteStrings

Instances

Data ExchangeFailure

Methods

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

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

toConstr :: ExchangeFailure -> Constr

dataTypeOf :: ExchangeFailure -> DataType

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

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

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

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

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

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

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

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

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

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

Show ExchangeFailure

Methods

showsPrec :: Int -> ExchangeFailure -> ShowS

show :: ExchangeFailure -> String

showList :: [ExchangeFailure] -> ShowS

Generic ExchangeFailure

Associated Types

type Rep ExchangeFailure :: * -> *

Methods

from :: ExchangeFailure -> Rep ExchangeFailure x

to :: Rep ExchangeFailure x -> ExchangeFailure

Exception ExchangeFailure

Methods

toException :: ExchangeFailure -> SomeException

fromException :: SomeException -> Maybe ExchangeFailure

displayException :: ExchangeFailure -> String

Monad m => MonadError ExchangeFailure (ExchangeT m)

Methods

throwError :: ExchangeFailure -> ExchangeT m a

catchError :: ExchangeT m a -> (ExchangeFailure -> ExchangeT m a) -> ExchangeT m a

type Rep ExchangeFailure

type Rep ExchangeFailure = D1 (MetaData "ExchangeFailure" "Coinbase.Exchange.Types" "coinbase-exchange-0.4.0.0-KDeprrDmLO86gY1hPoWgDg" False) ((:+:) ((:+:) (C1 (MetaCons "ParseFailure" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))) (C1 (MetaCons "ApiFailure" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))) ((:+:) (C1 (MetaCons "AuthenticationRequiredFailure" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))) (C1 (MetaCons "AuthenticationRequiresByteStrings" PrefixI False) U1)))

type Exchange a = ExchangeT IO a

data ExchangeT m a

Instances

MonadBase IO m => MonadBase IO (ExchangeT m)

Methods

liftBase :: IO α -> ExchangeT m α

Monad m => MonadError ExchangeFailure (ExchangeT m)

Methods

throwError :: ExchangeFailure -> ExchangeT m a

catchError :: ExchangeT m a -> (ExchangeFailure -> ExchangeT m a) -> ExchangeT m a

Monad m => MonadReader ExchangeConf (ExchangeT m)

Methods

ask :: ExchangeT m ExchangeConf

local :: (ExchangeConf -> ExchangeConf) -> ExchangeT m a -> ExchangeT m a

reader :: (ExchangeConf -> a) -> ExchangeT m a

Monad m => Monad (ExchangeT m)

Methods

(>>=) :: ExchangeT m a -> (a -> ExchangeT m b) -> ExchangeT m b

(>>) :: ExchangeT m a -> ExchangeT m b -> ExchangeT m b

return :: a -> ExchangeT m a

fail :: String -> ExchangeT m a

Functor m => Functor (ExchangeT m)

Methods

fmap :: (a -> b) -> ExchangeT m a -> ExchangeT m b

(<$) :: a -> ExchangeT m b -> ExchangeT m a

Monad m => Applicative (ExchangeT m)

Methods

pure :: a -> ExchangeT m a

(<*>) :: ExchangeT m (a -> b) -> ExchangeT m a -> ExchangeT m b

(*>) :: ExchangeT m a -> ExchangeT m b -> ExchangeT m b

(<*) :: ExchangeT m a -> ExchangeT m b -> ExchangeT m a

MonadIO m => MonadIO (ExchangeT m)

Methods

liftIO :: IO a -> ExchangeT m a

MonadThrow m => MonadThrow (ExchangeT m)

Methods

throwM :: Exception e => e -> ExchangeT m a

(Monad m, MonadThrow m, MonadIO m, MonadBase IO m) => MonadResource (ExchangeT m)

Methods

liftResourceT :: ResourceT IO a -> ExchangeT m a

data ExceptT e m a :: * -> (* -> *) -> * -> *

A monad transformer that adds exceptions to other monads.

ExceptT constructs a monad parameterized over two things:

• e - The exception type.
• m - The inner monad.

The return function yields a computation that produces the given value, while >>= sequences two subcomputations, exiting on the first exception.

Instances

MonadBaseControl b m => MonadBaseControl b (ExceptT e m)

Associated Types

type StM (ExceptT e m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (ExceptT e m) b -> b a) -> ExceptT e m a

restoreM :: StM (ExceptT e m) a -> ExceptT e m a

MonadBase b m => MonadBase b (ExceptT e m)

Methods

liftBase :: b α -> ExceptT e m α

Monad m => MonadError e (ExceptT e m)

Methods

throwError :: e -> ExceptT e m a

catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a

MonadReader r m => MonadReader r (ExceptT e m)

Methods

ask :: ExceptT e m r

local :: (r -> r) -> ExceptT e m a -> ExceptT e m a

reader :: (r -> a) -> ExceptT e m a

MonadTrans (ExceptT e)

Methods

lift :: Monad m => m a -> ExceptT e m a

MonadTransControl (ExceptT e)

Associated Types

type StT (ExceptT e :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run (ExceptT e) -> m a) -> ExceptT e m a

restoreT :: Monad m => m (StT (ExceptT e) a) -> ExceptT e m a

Monad m => Monad (ExceptT e m)

Methods

(>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b

(>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b

return :: a -> ExceptT e m a

fail :: String -> ExceptT e m a

Functor m => Functor (ExceptT e m)

Methods

fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b

(<$) :: a -> ExceptT e m b -> ExceptT e m a

MonadFix m => MonadFix (ExceptT e m)

Methods

mfix :: (a -> ExceptT e m a) -> ExceptT e m a

MonadFail m => MonadFail (ExceptT e m)

Methods

fail :: String -> ExceptT e m a

(Functor m, Monad m) => Applicative (ExceptT e m)

Methods

pure :: a -> ExceptT e m a

(<*>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b

(*>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b

(<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a

Foldable f => Foldable (ExceptT e f)

Methods

fold :: Monoid m => ExceptT e f m -> m

foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m

foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b

foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b

foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b

foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b

foldr1 :: (a -> a -> a) -> ExceptT e f a -> a

foldl1 :: (a -> a -> a) -> ExceptT e f a -> a

toList :: ExceptT e f a -> [a]

null :: ExceptT e f a -> Bool

length :: ExceptT e f a -> Int

elem :: Eq a => a -> ExceptT e f a -> Bool

maximum :: Ord a => ExceptT e f a -> a

minimum :: Ord a => ExceptT e f a -> a

sum :: Num a => ExceptT e f a -> a

product :: Num a => ExceptT e f a -> a

Traversable f => Traversable (ExceptT e f)

Methods

traverse :: Applicative f => (a -> f b) -> ExceptT e f a -> f (ExceptT e f b)

sequenceA :: Applicative f => ExceptT e f (f a) -> f (ExceptT e f a)

mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b)

sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a)

(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)

Methods

empty :: ExceptT e m a

(<|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a

some :: ExceptT e m a -> ExceptT e m [a]

many :: ExceptT e m a -> ExceptT e m [a]

(Monad m, Monoid e) => MonadPlus (ExceptT e m)

Methods

mzero :: ExceptT e m a

mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a

(Eq e, Eq1 m) => Eq1 (ExceptT e m)

Methods

liftEq :: (a -> b -> Bool) -> ExceptT e m a -> ExceptT e m b -> Bool

(Ord e, Ord1 m) => Ord1 (ExceptT e m)

Methods

liftCompare :: (a -> b -> Ordering) -> ExceptT e m a -> ExceptT e m b -> Ordering

(Read e, Read1 m) => Read1 (ExceptT e m)

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ExceptT e m a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ExceptT e m a]

(Show e, Show1 m) => Show1 (ExceptT e m)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ExceptT e m a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ExceptT e m a] -> ShowS

MonadZip m => MonadZip (ExceptT e m)

Methods

mzip :: ExceptT e m a -> ExceptT e m b -> ExceptT e m (a, b)

mzipWith :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c

munzip :: ExceptT e m (a, b) -> (ExceptT e m a, ExceptT e m b)

MonadIO m => MonadIO (ExceptT e m)

Methods

liftIO :: IO a -> ExceptT e m a

MonadThrow m => MonadThrow (ExceptT e m)

Throws exceptions into the base monad.

Methods

throwM :: Exception e => e -> ExceptT e m a

MonadCatch m => MonadCatch (ExceptT e m)

Catches exceptions from the base monad.

Methods

catch :: Exception e => ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a

MonadResource m => MonadResource (ExceptT e m)

Methods

liftResourceT :: ResourceT IO a -> ExceptT e m a

PrimMonad m => PrimMonad (ExceptT e m)

Associated Types

type PrimState (ExceptT e m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (ExceptT e m)) -> (#VoidRep, PtrRepLifted, State# (PrimState (ExceptT e m)), a#)) -> ExceptT e m a

(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)

Methods

(==) :: ExceptT e m a -> ExceptT e m a -> Bool

(/=) :: ExceptT e m a -> ExceptT e m a -> Bool

(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a)

Methods

compare :: ExceptT e m a -> ExceptT e m a -> Ordering

(<) :: ExceptT e m a -> ExceptT e m a -> Bool

(<=) :: ExceptT e m a -> ExceptT e m a -> Bool

(>) :: ExceptT e m a -> ExceptT e m a -> Bool

(>=) :: ExceptT e m a -> ExceptT e m a -> Bool

max :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a

min :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a

(Read e, Read1 m, Read a) => Read (ExceptT e m a)

Methods

readsPrec :: Int -> ReadS (ExceptT e m a)

readList :: ReadS [ExceptT e m a]

readPrec :: ReadPrec (ExceptT e m a)

readListPrec :: ReadPrec [ExceptT e m a]

(Show e, Show1 m, Show a) => Show (ExceptT e m a)

Methods

showsPrec :: Int -> ExceptT e m a -> ShowS

show :: ExceptT e m a -> String

showList :: [ExceptT e m a] -> ShowS

type StT (ExceptT e) a

type StT (ExceptT e) a = Either e a

type PrimState (ExceptT e m)

type PrimState (ExceptT e m) = PrimState m

type StM (ExceptT e m) a

type StM (ExceptT e m) a = ComposeSt (ExceptT e) m a

runExchange :: ExchangeConf -> Exchange a -> IO (Either ExchangeFailure a)

runExchangeT :: MonadBaseControl IO m => ExchangeConf -> ExchangeT m a -> m (Either ExchangeFailure a)

execExchange :: ExchangeConf -> Exchange a -> IO a

execExchangeT :: (MonadThrow m, MonadBaseControl IO m) => ExchangeConf -> ExchangeT m a -> m a

getManager :: MonadReader ExchangeConf m => m Manager