Safe Haskell	Safe-Inferred
Language	GHC2021

Recalc.Server

Description

This module implements a reactor pattern for Recalc, ensuring asynchronous processing of spreadsheet updates and computations. A single threaded loop listens for JSON-RPC messages and maintains jobs.

Jobs are picked up by multiple "worker" threads such that long-running computations do not block messaging.

Example

type Protocol

type Api = ToApi Protocol

initialState = ...

main :: IO ()
main = runHandler Api initialState $ state ->
  hoist Api (runReaderT state) (namedHandlers server)
 where
  server :: Protocol (AsServerT (Handler EngineState))
  server = Protocol { ... }

Synopsis

type Handler engine = ReaderT (State engine) IO
liftEngine :: State engine a -> Handler engine a
sendIO :: ToJSON a => a -> IO ()
debug :: Show a => String -> a -> Handler engine ()
dumpEngineState :: Show engine => Handler engine ()
scheduleJob :: ReaderT (State engine) IO () -> Handler engine ()
runHandler :: forall api engine. HasHandler api => engine -> (State engine -> HandlerT api IO) -> IO ()
type Id = Word64
data JsonRpcRequest params = JsonRpcRequest {
- request'method :: String
- request'id :: Maybe Id
- request'params :: params
}
pattern JsonRpcNotification :: String -> params -> JsonRpcRequest params
data JsonRpc (sym :: Symbol) (params :: Type) (rsp :: Type)
class HasHandler api
type family HandlerT api (m :: Type -> Type)
handle :: forall api. HasHandler api => JsonRpcRequest Value -> Handler api -> Either String (IO Value)
hoist :: HasHandler api => (forall x. m x -> n x) -> HandlerT api m -> HandlerT api n
class GenericMode mode where
- type mode :- api :: Type
data AsServerT (m :: Type -> Type)
type AsServer = AsServerT IO
data AsApi
type ToApi api' = GToSum (Rep (api' AsApi))
namedHandlers :: (GenericMode m, Generic (api' m), GSum (Rep (api' m))) => api' m -> GToSum (Rep (api' m))
data (path :: Symbol) :> (a :: Type) :: Type
data a :<|> b = a :<|> b
data Nullable t
- = Missing
- | Null
- | Is t
aesonOptions :: Options

Documentation

type Handler engine = ReaderT (State engine) IO Source #

handler threads are in IO and have access to the state

liftEngine :: State engine a -> Handler engine a Source #

sendIO :: ToJSON a => a -> IO () Source #

send JSON-RPC message on stdout (locked to prevent interleaving)

debug :: Show a => String -> a -> Handler engine () Source #

dumpEngineState :: Show engine => Handler engine () Source #

scheduleJob :: ReaderT (State engine) IO () -> Handler engine () Source #

runHandler :: forall api engine. HasHandler api => engine -> (State engine -> HandlerT api IO) -> IO () Source #

reads lines from stdin and maintains a channel of reactor inputs with new requests, handler threads deal with requests by reading from the request channel.

type Id = Word64 Source #

data JsonRpcRequest params Source #

Constructors

JsonRpcRequest
Fields request'method :: String request'id :: Maybe Id request'params :: params

Instances

Instances details

FromJSON params => FromJSON (JsonRpcRequest params) Source #
Instance details Defined in Recalc.Server.Generic Methods parseJSON :: Value -> Parser (JsonRpcRequest params) # parseJSONList :: Value -> Parser [JsonRpcRequest params] # omittedField :: Maybe (JsonRpcRequest params) #
ToJSON params => ToJSON (JsonRpcRequest params) Source #
Instance details Defined in Recalc.Server.Generic Methods toJSON :: JsonRpcRequest params -> Value # toEncoding :: JsonRpcRequest params -> Encoding # toJSONList :: [JsonRpcRequest params] -> Value # toEncodingList :: [JsonRpcRequest params] -> Encoding # omitField :: JsonRpcRequest params -> Bool #
Generic (JsonRpcRequest params) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type Rep (JsonRpcRequest params) :: Type -> Type # Methods from :: JsonRpcRequest params -> Rep (JsonRpcRequest params) x # to :: Rep (JsonRpcRequest params) x -> JsonRpcRequest params #
Show params => Show (JsonRpcRequest params) Source #
Instance details Defined in Recalc.Server.Generic Methods showsPrec :: Int -> JsonRpcRequest params -> ShowS # show :: JsonRpcRequest params -> String # showList :: [JsonRpcRequest params] -> ShowS #
type Rep (JsonRpcRequest params) Source #
Instance details Defined in Recalc.Server.Generic type Rep (JsonRpcRequest params) = D1 ('MetaData "JsonRpcRequest" "Recalc.Server.Generic" "recalc-server-1.3.0.0-inplace" 'False) (C1 ('MetaCons "JsonRpcRequest" 'PrefixI 'True) (S1 ('MetaSel ('Just "request'method") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :: (S1 ('MetaSel ('Just "request'id") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Id)) :: S1 ('MetaSel ('Just "request'params") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 params))))

pattern JsonRpcNotification :: String -> params -> JsonRpcRequest params Source #

data JsonRpc (sym :: Symbol) (params :: Type) (rsp :: Type) Source #

Instances

Instances details

(KnownSymbol sym, FromJSON params, ToJSON rsp, Typeable params) => HasHandler (JsonRpc sym params rsp :: Type) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type HandlerT (JsonRpc sym params rsp) m Source # Methods handle' :: (JsonRpcRequest Value, [Segment]) -> Handler (JsonRpc sym params rsp) -> Either String (IO Value) hoist :: (forall x. m x -> n x) -> HandlerT (JsonRpc sym params rsp) m -> HandlerT (JsonRpc sym params rsp) n Source #
type HandlerT (JsonRpc sym params rsp :: Type) m Source #
Instance details Defined in Recalc.Server.Generic type HandlerT (JsonRpc sym params rsp :: Type) m = (Maybe Id, params) -> m rsp

class HasHandler api Source #

Minimal complete definition

handle', hoist

Instances

Instances details

(HasHandler a, HasHandler b) => HasHandler (a :<\|> b :: Type) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type HandlerT (a :<\|> b) m Source # Methods handle' :: (JsonRpcRequest Value, [Segment]) -> Handler (a :<\|> b) -> Either String (IO Value) hoist :: (forall x. m x -> n x) -> HandlerT (a :<\|> b) m -> HandlerT (a :<\|> b) n Source #
(KnownSymbol path, HasHandler api) => HasHandler (path :> api :: Type) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type HandlerT (path :> api) m Source # Methods handle' :: (JsonRpcRequest Value, [Segment]) -> Handler (path :> api) -> Either String (IO Value) hoist :: (forall x. m x -> n x) -> HandlerT (path :> api) m -> HandlerT (path :> api) n Source #
(KnownSymbol sym, FromJSON params, ToJSON rsp, Typeable params) => HasHandler (JsonRpc sym params rsp :: Type) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type HandlerT (JsonRpc sym params rsp) m Source # Methods handle' :: (JsonRpcRequest Value, [Segment]) -> Handler (JsonRpc sym params rsp) -> Either String (IO Value) hoist :: (forall x. m x -> n x) -> HandlerT (JsonRpc sym params rsp) m -> HandlerT (JsonRpc sym params rsp) n Source #

type family HandlerT api (m :: Type -> Type) Source #

Instances

Instances details

type HandlerT (a :<\|> b :: Type) m Source #
Instance details Defined in Recalc.Server.Generic type HandlerT (a :<\|> b :: Type) m = HandlerT a m :<\|> HandlerT b m
type HandlerT (path :> api :: Type) m Source #
Instance details Defined in Recalc.Server.Generic type HandlerT (path :> api :: Type) m = HandlerT api m
type HandlerT (JsonRpc sym params rsp :: Type) m Source #
Instance details Defined in Recalc.Server.Generic type HandlerT (JsonRpc sym params rsp :: Type) m = (Maybe Id, params) -> m rsp

handle :: forall api. HasHandler api => JsonRpcRequest Value -> Handler api -> Either String (IO Value) Source #

hoist :: HasHandler api => (forall x. m x -> n x) -> HandlerT api m -> HandlerT api n Source #

class GenericMode mode Source #

generic modes for protocol datatypes

Associated Types

type mode :- api :: Type infixl 0 Source #

Instances

Instances details

GenericMode AsApi Source #
Instance details Defined in Recalc.Server.Generic Associated Types type AsApi :- api Source #
GenericMode (AsServerT m :: Type) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type (AsServerT m) :- api Source #

data AsServerT (m :: Type -> Type) Source #

Instances

Instances details

GenericMode (AsServerT m :: Type) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type (AsServerT m) :- api Source #
type (AsServerT m :: Type) :- api Source #
Instance details Defined in Recalc.Server.Generic type (AsServerT m :: Type) :- api = HandlerT api m

type AsServer Source #

Arguments

= AsServerT IO

the default server

data AsApi Source #

Instances

Instances details

GenericMode AsApi Source #
Instance details Defined in Recalc.Server.Generic Associated Types type AsApi :- api Source #
type AsApi :- api Source #
Instance details Defined in Recalc.Server.Generic type AsApi :- api = api

type ToApi api' = GToSum (Rep (api' AsApi)) Source #

namedHandlers :: (GenericMode m, Generic (api' m), GSum (Rep (api' m))) => api' m -> GToSum (Rep (api' m)) Source #

generically converts an Api (AsServerT m) to its sum representation ep0 :| ep1 :| ...

data (path :: Symbol) :> (a :: Type) :: Type infixr 4 Source #

Instances

Instances details

(KnownSymbol path, HasHandler api) => HasHandler (path :> api :: Type) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type HandlerT (path :> api) m Source # Methods handle' :: (JsonRpcRequest Value, [Segment]) -> Handler (path :> api) -> Either String (IO Value) hoist :: (forall x. m x -> n x) -> HandlerT (path :> api) m -> HandlerT (path :> api) n Source #
type HandlerT (path :> api :: Type) m Source #
Instance details Defined in Recalc.Server.Generic type HandlerT (path :> api :: Type) m = HandlerT api m

data a :<|> b infixr 3 Source #

Constructors

a :<|> b infixr 3

Instances

Instances details

(HasHandler a, HasHandler b) => HasHandler (a :<\|> b :: Type) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type HandlerT (a :<\|> b) m Source # Methods handle' :: (JsonRpcRequest Value, [Segment]) -> Handler (a :<\|> b) -> Either String (IO Value) hoist :: (forall x. m x -> n x) -> HandlerT (a :<\|> b) m -> HandlerT (a :<\|> b) n Source #
type HandlerT (a :<\|> b :: Type) m Source #
Instance details Defined in Recalc.Server.Generic type HandlerT (a :<\|> b :: Type) m = HandlerT a m :<\|> HandlerT b m

data Nullable t Source #

Constructors

Missing
Null
Is t

Instances

Instances details

FromJSON t => FromJSON (Nullable t) Source #
Instance details Defined in Recalc.Server.Types Methods parseJSON :: Value -> Parser (Nullable t) # parseJSONList :: Value -> Parser [Nullable t] # omittedField :: Maybe (Nullable t) #
ToJSON t => ToJSON (Nullable t) Source #
Instance details Defined in Recalc.Server.Types Methods toJSON :: Nullable t -> Value # toEncoding :: Nullable t -> Encoding # toJSONList :: [Nullable t] -> Value # toEncodingList :: [Nullable t] -> Encoding # omitField :: Nullable t -> Bool #
Show t => Show (Nullable t) Source #
Instance details Defined in Recalc.Server.Types Methods showsPrec :: Int -> Nullable t -> ShowS # show :: Nullable t -> String # showList :: [Nullable t] -> ShowS #
Eq t => Eq (Nullable t) Source #
Instance details Defined in Recalc.Server.Types Methods (==) :: Nullable t -> Nullable t -> Bool # (/=) :: Nullable t -> Nullable t -> Bool #
Ord t => Ord (Nullable t) Source #
Instance details Defined in Recalc.Server.Types Methods compare :: Nullable t -> Nullable t -> Ordering # (<) :: Nullable t -> Nullable t -> Bool # (<=) :: Nullable t -> Nullable t -> Bool # (>) :: Nullable t -> Nullable t -> Bool # (>=) :: Nullable t -> Nullable t -> Bool # max :: Nullable t -> Nullable t -> Nullable t # min :: Nullable t -> Nullable t -> Nullable t #

aesonOptions :: Options Source #

JSON Instances

(HasHandler a, HasHandler b) => HasHandler (a :<\|> b :: Type) Source #
Instance details Defined in Recalc.Server.Generic Associated Types type HandlerT (a :<\|> b) m Source # Methods handle' :: (JsonRpcRequest Value, [Segment]) -> Handler (a :<\|> b) -> Either String (IO Value) hoist :: (forall x. m x -> n x) -> HandlerT (a :<\|> b) m -> HandlerT (a :<\|> b) n Source #
type HandlerT (a :<\|> b :: Type) m Source #
Instance details Defined in Recalc.Server.Generic type HandlerT (a :<\|> b :: Type) m = HandlerT a m :<\|> HandlerT b m