Haste.App

Type-safe client-server communication framework for Haste. This module re-exports most of the Haste module for convenience since some functions are exported by both Haste and Haste.App with different definitions. For simplicity, import one or the other, not both.

Documentation

class Monad m => MonadIO m where

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad.

Instances

MonadIO IO

MonadIO Shell

MonadIO CIO

MonadIO Server

MonadIO Client

(Error e, MonadIO m) => MonadIO (ErrorT e m)

class Remotable a

An exportable function is of the type (Serialize a, ..., Serialize result) => a -> ... -> IO result

Instances

Binary a => Remotable (Server a)

(Binary a, Remotable b) => Remotable (a -> b)

data App a

Application monad; allows for exporting functions, limited liftIO, forkIO and launching the client.

Instances

Monad App

Functor App

Applicative App

data Server a

Server monad for Haste.App. Allows redeeming remote values, lifting IO actions, and not much more.

Instances

Monad Server

Functor Server

Applicative Server

MonadIO Server

MonadBlob Server

Binary a => Remotable (Server a)

data Remote a

data Done

type Sessions = Set SessionID

type SessionID = Word64

liftServerIO :: IO a -> App (Server a)

Lift an IO action into the Server monad, the result of which can only be used server-side.

forkServerIO :: Server () -> App (Server ThreadId)

Fork off a Server computation not bound an API call. This may be useful for any tasks that will keep running for as long as the server is running.

Calling getSessionID inside this computation will return 0, which will never be generated for an actual session. getActiveSessions works as expected.

remote :: Remotable a => a -> App (Remote a)

Make a function available to the client as an API call.

runApp :: AppCfg -> App Done -> IO ()

Run a Haste.App application. runApp never returns before the program terminates.

Note that runApp's arguments *must not* depend on any external IO, or the client and server computations may diverge. Ideally, calling runApp should be the first and only thing that happens in main.

(<.>) :: Binary a => Remote (a -> b) -> a -> Remote b

Apply an exported function to an argument. TODO: look into making this Applicative.

getSessionID :: Server SessionID

Returns the ID of the current session.

getActiveSessions :: Server Sessions

Return all currently active sessions.

onSessionEnd :: (SessionID -> Server ()) -> App ()

Register a handler to be run whenever a session terminates. Several handlers can be registered at the same time; they will be run in the order they were registered.

data AppCfg

Instances

Default AppCfg

cfgURL :: AppCfg -> String

cfgPort :: AppCfg -> Int

mkConfig :: String -> Int -> AppCfg

Create a default configuration from an URL and a port number.

data Client a

A client-side computation. See it as Haste.App's version of the IO monad.

Instances

Monad Client

Functor Client

Applicative Client

MonadIO Client

MonadConc Client

MonadBlob Client

ClientCallback (Client ())

GenericCallback (Client ()) Client

runClient :: Client () -> App Done

Launch a client from a Server computation. runClient never returns before the program terminates.

onServer :: Binary a => Remote (Server a) -> Client a

Perform a server-side computation, blocking the client thread until said computation returns.

liftIO :: MonadIO m => forall a. IO a -> m a

Lift a computation from the IO monad.

data JSString

JSStrings are represented as normal strings server-side; should probably be changed to ByteString or Text.

Instances

Eq JSString

Ord JSString

Show JSString

IsString JSString

Unpack JSString

Pack JSString

Serialize JSString

type JSAny = Ptr Any

type URL = String

alert :: MonadIO m => String -> m ()

Javascript alert() function.

prompt :: MonadIO m => String -> m String

Javascript prompt() function.

eval :: MonadIO m => JSString -> m JSString

Javascript eval() function.

writeLog :: MonadIO m => String -> m ()

Use console.log to write a message.

catJSStr :: JSString -> [JSString] -> JSString

Concatenate a series of JSStrings using the specified separator.

fromJSStr :: JSString -> String

class ClientCallback a

Bake a value of type a -> ... -> Client b into a -> ... -> IO b

Instances

ClientCallback (Client ())

ClientCallback b => ClientCallback (a -> b)

data Event m a where

These constructors correspond to their namesake DOM events. Mouse related callbacks receive the coordinates of the mouse pointer at the time the event was fired, relative to the top left corner of the element that fired the event. The click events also receive the mouse button that was pressed.

The key updownpress events receive the character code of the key that was pressed.

Constructors

OnLoad :: Event m (m ())

OnUnload :: Event m (m ())

OnChange :: Event m (m ())

OnFocus :: Event m (m ())

OnBlur :: Event m (m ())

OnMouseMove :: Event m ((Int, Int) -> m ())

OnMouseOver :: Event m ((Int, Int) -> m ())

OnMouseOut :: Event m (m ())

OnClick :: Event m (Int -> (Int, Int) -> m ())

OnDblClick :: Event m (Int -> (Int, Int) -> m ())

OnMouseDown :: Event m (Int -> (Int, Int) -> m ())

OnMouseUp :: Event m (Int -> (Int, Int) -> m ())

OnKeyPress :: Event m (Int -> m ())

OnKeyUp :: Event m (Int -> m ())

OnKeyDown :: Event m (Int -> m ())

Instances

Eq (Event m a)

Ord (Event m a)

onEvent :: ClientCallback a => Elem -> Event Client a -> a -> Client ()

Set a handler for a given event.

setTimeout :: Int -> Client () -> Client ()

Wrapper for window.setTimeout; execute the given computation after a delay given in milliseconds.

evtName :: IsString s => Event m a -> s

The name of a given event.

module Haste.DOM

class Random a where

Methods

randomR :: (a, a) -> Seed -> (a, Seed)

Generate a pseudo random number between a lower (inclusive) and higher (exclusive) bound.

randomRs :: (a, a) -> Seed -> [a]

Instances

Random Double

Random Int

Random Int32

Random Word

Random Word32

data Seed

next :: Seed -> Seed

Generate the next seed in the sequence.

mkSeed :: Int -> Seed

Create a new seed from an integer.

newSeed :: MonadIO m => m Seed

Generate a new seed using Javascript's PRNG.

class JSType a where

Methods

toJSString :: a -> JSString

fromJSString :: JSString -> Maybe a

Instances

JSType Bool

JSType Double

JSType Float

JSType Int

JSType Int8

JSType Int16

JSType Int32

JSType Integer

JSType Word

JSType Word8

JSType Word16

JSType Word32

JSType String

JSType ()

class JSNum a where

(Almost) all numeric types can be efficiently converted to and from Double, which is the internal representation for most of them.

Methods

toNumber :: a -> Double

fromNumber :: Double -> a

Instances

JSNum Double

JSNum Float

JSNum Int

JSNum Int8

JSNum Int16

JSNum Int32

JSNum Integer

JSNum Word

JSNum Word8

JSNum Word16

JSNum Word32

toString :: JSType a => a -> String

fromString :: JSType a => String -> Maybe a

convert :: (JSNum a, JSNum b) => a -> b

onHashChange :: (MonadIO m, GenericCallback (m ()) m, CB (m ()) ~ IO ()) => (String -> String -> m ()) -> m ()

Register a callback to be run whenever the URL hash changes. The two arguments of the callback are the new and old hash respectively.

onHashChange' :: (MonadIO m, GenericCallback (m ()) m, CB (m ()) ~ IO ()) => (JSString -> JSString -> m ()) -> m ()

JSString version of onHashChange.

setHash :: MonadIO m => String -> m ()

Set the hash part of the current URL.

getHash :: MonadIO m => m String

Read the hash part of the currunt URL.

setHash' :: MonadIO m => JSString -> m ()

Set the hash part of the current URL - JSString version.

getHash' :: MonadIO m => m JSString

Read the hash part of the currunt URL - JSString version.

module Haste.Binary

module Data.Default