Safe Haskell	None
Language	Haskell2010

Data.Bimap.Server

Description

A bimap server is basically a server that stores a one-to-one correspondence between two sets of values. You can think of it as a table with two columns, where each column has elements of the same type. You can lookup the table and update it using JSON based HTTP requests.

This is how you run the server:

bimapServer (Proxy :: Proxy Int) -- This proxy specifies the type of the values in the left column
            (Proxy :: Proxy String) -- This proxy specifies the type of the values in the right column
             5000 -- Server will be running in port 5000
             60 -- This is the number of seconds between saves

In this example, the server will save in the file "saved.bimap" the table every 60 seconds. Keep in mind that bimapServer will install a handle for SIGTERM signals, meaning that a kill signal will be catched by the process, triggering a save of the table. After saving the table, the server will stop running. However, the port that the server was using may still not be available until the program using bimapServer is closed.

The interface of the server is as follows:

[GET] /list: Returns the list of rows in the table. The format is [[a1,b1],...,[aN,bN]]. You can use the aeson's encoding of the type [(a,b)] for decoding it.
[GET] /left-lookup: Lookup an element in the table by searching in the left column. It returns the element in the right column (if any) in JSON format as described by the ToJSON instance. The element to lookup is specified using its JSON encoded form as the body of the HTTP request.
[GET] /right-lookup: Just as /left-lookup, except that using the right column for searching, and returning the element in the left column (if any).
[POST] /insert: Insert a pair of values in the table, replacing any occurences. The pair is sent in the body of the HTTP request, in JSON format, using the aeson's encoding of pairs (tuples of size 2).
[DELETE] /left-delete: Delete a row by searching in the left column. The value to look for in the left column is passed JSON-encoded as the body of the HTTP request.
[DELETE] /right-delete: Just as /left-delete, but searching in the right column.

Synopsis

Documentation

bimapServer #

Arguments

:: (Binary a, Binary b, FromJSON a, FromJSON b, ToJSON a, ToJSON b, Ord a, Ord b)
=> Proxy a	Type of left keys
-> Proxy b	Type of right keys
-> Int	Port to run the server
-> Int	Number of seconds between saves
-> IO ()

Function to start a bimap server. The Binary instances are used for saving the table to file. FromJSON and ToJSON instances are used for the HTTP interface. The Ord instances are used to implement fast lookups.

data Proxy k t :: forall k. k -> * #

A concrete, poly-kinded proxy type

Constructors

Proxy

Instances

Monad (Proxy *)
Methods (>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b # (>>) :: Proxy * a -> Proxy * b -> Proxy * b # return :: a -> Proxy * a # fail :: String -> Proxy * a #
Functor (Proxy *)
Methods fmap :: (a -> b) -> Proxy * a -> Proxy * b # (<$) :: a -> Proxy * b -> Proxy * a #
Applicative (Proxy *)
Methods pure :: a -> Proxy * a # (<>) :: Proxy (a -> b) -> Proxy * a -> Proxy * b # (>) :: Proxy a -> Proxy * b -> Proxy * b # (<) :: Proxy a -> Proxy * b -> Proxy * a #
Generic1 (Proxy *)
Associated Types type Rep1 (Proxy * :: * -> ) :: -> * # Methods from1 :: Proxy * a -> Rep1 (Proxy ) a # to1 :: Rep1 (Proxy ) a -> Proxy * a #
ToJSON1 (Proxy *)
Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Proxy * a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Proxy * a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Proxy * a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Proxy * a] -> Encoding #
FromJSON1 (Proxy *)
Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Proxy * a) # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Proxy * a] #
Alternative (Proxy *)
Methods empty :: Proxy * a # (<\|>) :: Proxy * a -> Proxy * a -> Proxy * a # some :: Proxy * a -> Proxy * [a] # many :: Proxy * a -> Proxy * [a] #
MonadPlus (Proxy *)
Methods mzero :: Proxy * a # mplus :: Proxy * a -> Proxy * a -> Proxy * a #
Eq1 (Proxy *)	Since: 4.9.0.0
Methods liftEq :: (a -> b -> Bool) -> Proxy * a -> Proxy * b -> Bool #
Ord1 (Proxy *)	Since: 4.9.0.0
Methods liftCompare :: (a -> b -> Ordering) -> Proxy * a -> Proxy * b -> Ordering #
Read1 (Proxy *)	Since: 4.9.0.0
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy * a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy * a] #
Show1 (Proxy *)	Since: 4.9.0.0
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy * a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy * a] -> ShowS #
Hashable1 (Proxy *)
Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Proxy * a -> Int #
Bounded (Proxy k s)
Methods minBound :: Proxy k s # maxBound :: Proxy k s #
Enum (Proxy k s)
Methods succ :: Proxy k s -> Proxy k s # pred :: Proxy k s -> Proxy k s # toEnum :: Int -> Proxy k s # fromEnum :: Proxy k s -> Int # enumFrom :: Proxy k s -> [Proxy k s] # enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s] # enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s] # enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s] #
Eq (Proxy k s)
Methods (==) :: Proxy k s -> Proxy k s -> Bool # (/=) :: Proxy k s -> Proxy k s -> Bool #
Ord (Proxy k s)
Methods compare :: Proxy k s -> Proxy k s -> Ordering # (<) :: Proxy k s -> Proxy k s -> Bool # (<=) :: Proxy k s -> Proxy k s -> Bool # (>) :: Proxy k s -> Proxy k s -> Bool # (>=) :: Proxy k s -> Proxy k s -> Bool # max :: Proxy k s -> Proxy k s -> Proxy k s # min :: Proxy k s -> Proxy k s -> Proxy k s #
Read (Proxy k s)
Methods readsPrec :: Int -> ReadS (Proxy k s) # readList :: ReadS [Proxy k s] # readPrec :: ReadPrec (Proxy k s) # readListPrec :: ReadPrec [Proxy k s] #
Show (Proxy k s)
Methods showsPrec :: Int -> Proxy k s -> ShowS # show :: Proxy k s -> String # showList :: [Proxy k s] -> ShowS #
Ix (Proxy k s)
Methods range :: (Proxy k s, Proxy k s) -> [Proxy k s] # index :: (Proxy k s, Proxy k s) -> Proxy k s -> Int # unsafeIndex :: (Proxy k s, Proxy k s) -> Proxy k s -> Int inRange :: (Proxy k s, Proxy k s) -> Proxy k s -> Bool # rangeSize :: (Proxy k s, Proxy k s) -> Int # unsafeRangeSize :: (Proxy k s, Proxy k s) -> Int
Generic (Proxy k t)
Associated Types type Rep (Proxy k t) :: * -> * # Methods from :: Proxy k t -> Rep (Proxy k t) x # to :: Rep (Proxy k t) x -> Proxy k t #
Semigroup (Proxy k s)
Methods (<>) :: Proxy k s -> Proxy k s -> Proxy k s # sconcat :: NonEmpty (Proxy k s) -> Proxy k s # stimes :: Integral b => b -> Proxy k s -> Proxy k s #
Monoid (Proxy k s)
Methods mempty :: Proxy k s # mappend :: Proxy k s -> Proxy k s -> Proxy k s # mconcat :: [Proxy k s] -> Proxy k s #
Hashable (Proxy * a)
Methods hashWithSalt :: Int -> Proxy * a -> Int # hash :: Proxy * a -> Int #
ToJSON (Proxy k a)
Methods toJSON :: Proxy k a -> Value # toEncoding :: Proxy k a -> Encoding # toJSONList :: [Proxy k a] -> Value # toEncodingList :: [Proxy k a] -> Encoding #
FromJSON (Proxy k a)
Methods parseJSON :: Value -> Parser (Proxy k a) # parseJSONList :: Value -> Parser [Proxy k a] #
type Rep1 (Proxy *)
type Rep1 (Proxy *) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)
type Rep (Proxy k t)
type Rep (Proxy k t) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)