The options for connecting to the Myxine server. This is an opaque Monoid: set options by combining pagePort and/or pagePath using their Semigroup instance.

Set the port to a non-default port. This is only necessary when Myxine is running on a non-default port also.

A local port at which the server is expected to be running. Create one using an integer literal or fromInteger.

Set the path to something other than the default of /.

A path at "localhost/..." at which to perform some action. Create one using a string literal or fromString.

A full page update as ready-to-send to the Myxine server.

A list of event types to listen for: either all events, or a specific list of events.

A PageEvent is an event that occurred in the browser: a triple of the EventType, any associated properties of the event (this varies depending on the event type), and the list of Targets of the event, in order from most to least specific.

A Target is a description of a single element node in the browser. When an event fires in the browser, Myxine tracks the path of nodes it touches, from the most specific element all the way up to the root. Each event handler is given access to this [Target], ordered from most to least specific.

For any Target, you can query the value of any of an attribute, or you can ask for the tag of that element.

Get the name of the HTML tag for this Target. Note that unlike in the browser itself, Myxine returns tag names in lower case, rather than upper.

Get the value, if any, of some named attribute of a Target.

The view of a page, as rendered in the browser. Create page content with pageBody and pageTitle, and combine content using the Semigroup instance.

Note: The Semigroup instance for PageContent takes the last specified pageTitle (if any), and concatenates in order each specified pageBody.

Create a rendered PageContent with an empty title and the specified text as its body.

Create a rendered PageContent with an empty body and the specified text as its title.

Get the rendered body of a PageContent.

Get the title of a PageContent.

Send a full-page update to Myxine at a particular port and path. An Update is either a Dynamic page body with an optional title, or a Static file with a particular Content-Type.

Given a page location and list of events, create an IO action that acts as a "stream" of sequential events matching the event list. The state maintained within the stream is used to coordinate with the server to return a sequential event from each poll of the stream. It is strongly recommended to create only one such "get next" action and to poll it repeatedly.

Calls to the "get next" action returned will block until the next event matching the given description is available. Provided that the "get next" action is polled with sufficient frequency, no events will be missed, as the server maintains an internal fixed-size buffer of events to distribute to lagging clients. However, significantly lagging clients may observe dropped events. It is therefore best practice to eagerly collect events in a separate tight-looping thread and buffer them client-side.

A piece of raw JavaScript to evaluate: either an expression or a block of statements. Expressions need not terminate with a return statement but cannot span multiple lines; block need to have an explicit return, but can contain multiple statements and lines.

Evaluate some raw JavaScript in the context of a given page.

Returns either a deserialized Haskell type, or throws a JsException containing a human-readable string describing any error that occurred.

Possible errors include:

Possible errors, which manifest as JsExceptions:

• Any exception in the given JavaScript
• Invalid JSON response for the result type inferred (use Value if you don't know what shape of data you're waiting to receive).

Further caveats:

• JavaScript undefined is translated to null in the results
• Return types are limited to those which can be serialized via JSON.stringify, which does not work for cyclic objects (like window, document, and all DOM nodes), and may fail to serialize some properties for other non-scalar values. If you want to return a non-scalar value like a list or dictionary, construct it explicitly yourself by copying from the fields of the object you're interested in.
• You're evaluating an arbitrary string as JavaScript, which means there are no guarantees about type safety or purity.
• It is possible that you could break the Myxine server code running in the page that makes it update properly, or hang the page by passing a non-terminating piece of code.
• Any modifications you make to the DOM will be immediately overwritten on the next re-draw of the page. Don't do this.
• If there are multiple browser windows pointed at the same page, and the result of your query differs between them, it's nondeterministic which result you get back.

An exception thrown by evaluating JavaScript. This may be a deserialization error, or an error that occurred in the JavaScript runtime itself.

If the response from the server cannot be processed appropriately, this exception is thrown. This should never happen in ordinary circumstances; if it does, your version of the client library may mismatch the version of the Myxine server you are running, or there may be a bug in the Myxine server or this library.

If you encounter this exception in the wild, please file a bug report at https://github.com/kwf/myxine/issues/new. Thanks!

Existential. This is type is useful to hide GADTs' parameters.

>>> data Tag :: * -> * where TagInt :: Tag Int; TagBool :: Tag Bool
>>> instance GShow Tag where gshowsPrec _ TagInt = showString "TagInt"; gshowsPrec _ TagBool = showString "TagBool"
>>> classify s = case s of "TagInt" -> [mkGReadResult TagInt]; "TagBool" -> [mkGReadResult TagBool]; _ -> []
>>> instance GRead Tag where greadsPrec _ s = [ (r, rest) | (con, rest) <-  lex s, r <- classify con ]

You can either use PatternSynonyms (available with GHC >= 8.0)

>>> let x = Some TagInt
>>> x
Some TagInt

>>> case x of { Some TagInt -> "I"; Some TagBool -> "B" } :: String
"I"

or you can use functions

>>> let y = mkSome TagBool
>>> y
Some TagBool

>>> withSome y $ \y' -> case y' of { TagInt -> "I"; TagBool -> "B" } :: String
"B"

The implementation of mapSome is safe.

>>> let f :: Tag a -> Tag a; f TagInt = TagInt; f TagBool = TagBool
>>> mapSome f y
Some TagBool

but you can also use:

>>> withSome y (mkSome . f)
Some TagBool

>>> read "Some TagBool" :: Some Tag
Some TagBool

>>> read "mkSome TagInt" :: Some Tag
Some TagInt