Web.SocketIO

Socket.IO for Haskell folks.

How to use this module

Note that most of the string literals below are of type Lazy Text.

{-# LANGUAGE OverloadedStrings #-}

import Web.SocketIO

-- listens to port 4000
main = server 4000 $ do

    -- send something to the client
    emit "some event" ["hey"]

    -- ping-pong
    on "ping" $ do
        emit "pong" []

    -- do some IO
    on "Kim Jong-Un" $ liftIO launchMissile
        
    -- broadcast
    broadcast "UN" "North Korea is best Korea"

Running a standalone server

server :: Port -> HandlerM () -> IO ()

Run a socket.io application, build on top of Warp.

serverConfig :: Port -> Configuration -> HandlerM () -> IO ()

Run a socket.io application with configurations applied.

defaultConfig :: Configuration

Default configuration.

 defaultConfig = Configuration
    {   transports = [XHRPolling]
    ,   logLevel = 2               
    ,   logTo = stderr        
    ,   header = [("Access-Control-Allow-Credentials", "true")]      
    ,   heartbeats = True
    ,   closeTimeout = 60
    ,   heartbeatTimeout = 60
    ,   heartbeatInterval = 25
    ,   pollingDuration = 20
    }

You can override it like so:

 myConfig = defaultConfig { logLevel = 0 }

Unless specified, the header will be modified to enable cross-origin resource sharing (CORS) like this.

 header = 
    [   ("Access-Control-Allow-Origin", <origin-of-the-reqeust>)]      
    ,   ("Access-Control-Allow-Credentials", "true")
    ]      

data Configuration

Defines behaviors of a Socket.IO server

Constructors

Configuration

Fields

transports :: [Transport]

logLevel :: Int

there are 4 levels, from 0 to 3: Error, Warn, Info, Debug

logTo :: Handle

heartbeats :: Bool

header :: ResponseHeaders

closeTimeout :: Int

heartbeatTimeout :: Int

heartbeatInterval :: Int

pollingDuration :: Int

Instances

Show Configuration

type Port = Int

Port number for a standalone Socket.IO server.

data Transport

Now only xhr-polling is supported. socket.io-spec#transport-id

Constructors

XHRPolling

Instances

Eq Transport

Show Transport

Sending and receiving events

class Subscriber m where

Receives events.

Methods

on

Arguments

:: EventName

name of event to listen to

-> CallbackM ()

callback

-> m ()

Instances

Subscriber HandlerM

class Publisher m where

Sends events

Methods

emit

Arguments

:: EventName

name of event to trigger

-> [Value]

payload to carry with

-> m ()

Sends a message to the socket that starts it.

 emit "launch" ["missile", "nuke"] 

broadcast

Arguments

:: EventName

name of event to trigger

-> [Value]

payload to carry with

-> m ()

Sends a message to everybody except for the socket that starts it.

 broadcast "hide" ["nukes coming!"] 

Instances

Publisher CallbackM

Publisher HandlerM

reply :: CallbackM [Value]

Deprecated: use msg instead

This function is deprecated; use msg instead

msg :: CallbackM [Value]

Extracts payload carried by the event

 on "echo" $ do
     payload <- msg
     liftIO $ print payload
     emit echo payload 

msg' :: CallbackM [ByteString]

Lazy ByteString version of msg, convenient for Aeson decoding.

getEventName :: CallbackM EventName

Name of the event

class HasSessionID m where

Class for SessionID getter.

Methods

getSessionID :: m SessionID

Instances

HasSessionID CallbackM

HasSessionID HandlerM

type EventName = Text

Name of an Event

type SessionID = ByteString

Session ID

Special events

On disconnection

 on "disconnect" $ do
     liftIO $ print "client disconnected"

Types

data HandlerM a

Capable of both sending and receiving events.

Use liftIO if you wanna do some IO here.

Instances

Monad HandlerM

Functor HandlerM

Applicative HandlerM

MonadIO HandlerM

Subscriber HandlerM

Publisher HandlerM

HasSessionID HandlerM

MonadBase IO HandlerM

data CallbackM a

Capable of only sending events.

Use liftIO if you wanna do some IO here.

Instances

Monad CallbackM

Functor CallbackM

Applicative CallbackM

MonadIO CallbackM

Publisher CallbackM

HasSessionID CallbackM

MonadBase IO CallbackM