| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Language.Javascript.JSaddle
Description
This package provides an EDSL for calling JavaScript that can be used both from GHCJS and GHC. When using GHC the application is run using Warp and WebSockets to drive a small JavaScript helper.
Synopsis
- bracket :: MonadMask m => m a -> (a -> m c) -> (a -> m b) -> m b
- catch :: (MonadCatch m, Exception e) => m a -> (e -> m a) -> m a
- newtype JSString = JSString Text
- newtype JSVal = JSVal (IORef JSValueRef)
- newtype JSException = JSException JSVal
- type JSadddleHasCallStack = (() :: Constraint)
- data Results
- data BatchResults
- data Result
- = DeRefValResult JSValueRef Text
- | ValueToBoolResult Bool
- | ValueToNumberResult Double
- | ValueToStringResult JSStringReceived
- | ValueToJSONResult JSStringReceived
- | ValueToJSONValueResult Value
- | IsNullResult Bool
- | IsUndefinedResult Bool
- | StrictEqualResult Bool
- | InstanceOfResult Bool
- | PropertyNamesResult [JSStringReceived]
- | ThrowJSValue JSValueReceived
- | SyncResult
- data Batch = Batch [Either AsyncCommand Command] Bool Int
- data Command
- = DeRefVal JSValueForSend
- | ValueToBool JSValueForSend
- | ValueToNumber JSValueForSend
- | ValueToString JSValueForSend
- | ValueToJSON JSValueForSend
- | ValueToJSONValue JSValueForSend
- | IsNull JSValueForSend
- | IsUndefined JSValueForSend
- | StrictEqual JSValueForSend JSValueForSend
- | InstanceOf JSValueForSend JSObjectForSend
- | PropertyNames JSObjectForSend
- | Sync
- data AsyncCommand
- = FreeRef Text JSValueForSend
- | FreeRefs Text
- | SetPropertyByName JSObjectForSend JSStringForSend JSValueForSend
- | SetPropertyAtIndex JSObjectForSend Int JSValueForSend
- | StringToValue JSStringForSend JSValueForSend
- | NumberToValue Double JSValueForSend
- | JSONValueToValue Value JSValueForSend
- | GetPropertyByName JSObjectForSend JSStringForSend JSValueForSend
- | GetPropertyAtIndex JSObjectForSend Int JSValueForSend
- | CallAsFunction JSObjectForSend JSObjectForSend [JSValueForSend] JSValueForSend
- | CallAsConstructor JSObjectForSend [JSValueForSend] JSValueForSend
- | NewEmptyObject JSValueForSend
- | NewAsyncCallback JSValueForSend
- | NewSyncCallback JSValueForSend
- | FreeCallback JSValueForSend
- | NewArray [JSValueForSend] JSValueForSend
- | EvaluateScript JSStringForSend JSValueForSend
- | SyncWithAnimationFrame JSValueForSend
- | StartSyncBlock
- | EndSyncBlock
- newtype JSStringForSend = JSStringForSend Text
- newtype JSStringReceived = JSStringReceived Text
- newtype JSObjectForSend = JSObjectForSend JSValueForSend
- newtype JSValueForSend = JSValueForSend JSValueRef
- newtype JSValueReceived = JSValueReceived JSValueRef
- newtype Nullable a = Nullable a
- newtype Object = Object JSVal
- type STJSArray s = SomeJSArray (STMutable s)
- type MutableJSArray = SomeJSArray Mutable
- type JSArray = SomeJSArray Immutable
- newtype SomeJSArray (m :: MutabilityType s) = SomeJSArray JSVal
- type family Mutability (a :: MutabilityType s) :: IsItMutable where ...
- data IsItMutable
- type Immutable = Immutable_ ()
- type Mutable = Mutable_ ()
- data MutabilityType s
- = Mutable_ s
- | Immutable_ s
- | STMutable s
- class IsJSVal a where
- type JSCallAsFunction = JSVal -> JSVal -> [JSVal] -> JSM ()
- class (Applicative m, MonadIO m) => MonadJSM m where
- newtype GHCJSPure a = GHCJSPure (JSM a)
- newtype JSM a = JSM {
- unJSM :: ReaderT JSContextRef IO a
- data JSContextRef = JSContextRef {
- contextId :: Int64
- startTime :: UTCTime
- doSendCommand :: Command -> IO Result
- doSendAsyncCommand :: AsyncCommand -> IO ()
- addCallback :: Object -> JSCallAsFunction -> IO ()
- nextRef :: TVar JSValueRef
- doEnableLogging :: Bool -> IO ()
- finalizerThreads :: MVar (Set Text)
- animationFrameHandlers :: MVar [Double -> JSM ()]
- liveRefs :: MVar (Set Int64)
- syncPoint :: JSM ()
- syncAfter :: JSM a -> JSM a
- sendCommand :: Command -> JSM Result
- ghcjsPure :: GHCJSPure a -> JSM a
- ghcjsPureMap :: (a -> b) -> GHCJSPure a -> GHCJSPure b
- ghcjsPureId :: a -> GHCJSPure a
- liftJSM :: MonadJSM m => JSM a -> m a
- jsval :: IsJSVal a => a -> GHCJSPure JSVal
- textFromJSString :: JSString -> Text
- textToJSString :: Text -> JSString
- strToText :: JSString -> Text
- textToStr :: Text -> JSString
- waitForAnimationFrame :: JSM Double
- nextAnimationFrame :: (Double -> JSM a) -> JSM a
- askJSM :: MonadJSM m => m JSContextRef
- runJSM :: MonadIO m => JSM a -> JSContextRef -> m a
- runJSaddle :: MonadIO m => JSContextRef -> JSM a -> m a
- class MakeArgs this where
- class MakeObject this where
- makeObject :: this -> JSM Object
- create :: JSM Object
- listProps :: Object -> JSM [JSString]
- getProp :: JSString -> Object -> JSM JSVal
- unsafeGetProp :: JSString -> Object -> JSM JSVal
- setProp :: JSString -> JSVal -> Object -> JSM ()
- unsafeSetProp :: JSString -> JSVal -> Object -> JSM ()
- isNull :: JSVal -> GHCJSPure Bool
- isUndefined :: JSVal -> GHCJSPure Bool
- fromListIO :: [JSVal] -> JSM (SomeJSArray m)
- jsTrue :: JSVal
- jsFalse :: JSVal
- jsNull :: JSVal
- toJSBool :: Bool -> JSVal
- jsUndefined :: JSVal
- isTruthy :: JSVal -> GHCJSPure Bool
- class FromJSVal a where
- fromJSVal :: JSVal -> JSM (Maybe a)
- fromJSValUnchecked :: JSVal -> JSM a
- fromJSValListOf :: JSVal -> JSM (Maybe [a])
- fromJSValUncheckedListOf :: JSVal -> JSM [a]
- class ToJSVal a where
- class PFromJSVal a where
- pFromJSVal :: JSVal -> a
- class PToJSVal a where
- toJSVal_pure :: PToJSVal a => a -> JSM JSVal
- class FromJSVal a => FromJSString a where
- fromJSString :: JSString -> a
- class ToJSVal a => ToJSString a where
- toJSString :: a -> JSString
- eval :: ToJSString script => script -> JSM JSVal
- objGetPropertyByName :: ToJSString name => Object -> name -> JSM JSVal
- objGetPropertyAtIndex :: Object -> Int -> JSM JSVal
- objSetPropertyByName :: (ToJSString name, ToJSVal val) => Object -> name -> val -> JSM ()
- objSetPropertyAtIndex :: ToJSVal val => Object -> Int -> val -> JSM ()
- data JSValue
- type JSUndefined = ()
- data JSNull = JSNull
- showJSValue :: JSValue -> String
- valToBool :: ToJSVal value => value -> JSM Bool
- valToNumber :: ToJSVal value => value -> JSM Double
- valToStr :: ToJSVal value => value -> JSM JSString
- valToText :: ToJSVal value => value -> JSM Text
- valToJSON :: ToJSVal value => value -> JSM JSString
- valToObject :: ToJSVal value => value -> JSM Object
- val :: ToJSVal value => value -> JSM JSVal
- valNull :: JSVal
- valIsNull :: ToJSVal value => value -> JSM Bool
- valUndefined :: JSVal
- valIsUndefined :: ToJSVal value => value -> JSM Bool
- maybeNullOrUndefined :: ToJSVal value => value -> JSM (Maybe JSVal)
- maybeNullOrUndefined' :: ToJSVal value => (JSVal -> JSM a) -> value -> JSM (Maybe a)
- valBool :: Bool -> JSVal
- valMakeNumber :: Double -> JSM JSVal
- valMakeText :: Text -> JSM JSVal
- valMakeString :: JSString -> JSM JSVal
- valMakeJSON :: Value -> JSM JSVal
- deRefVal :: ToJSVal value => value -> JSM JSValue
- valMakeRef :: JSValue -> JSM JSVal
- strictEqual :: (ToJSVal a, ToJSVal b) => a -> b -> JSM Bool
- instanceOf :: (ToJSVal value, MakeObject constructor) => value -> constructor -> JSM Bool
- newtype Function = Function {}
- type JSF = forall o. MakeObject o => IndexPreservingGetter o (JSM JSVal)
- (!) :: (MakeObject this, ToJSString name) => this -> name -> JSM JSVal
- (!!) :: MakeObject this => this -> Int -> JSM JSVal
- js :: (MakeObject s, ToJSString name) => name -> IndexPreservingGetter s (JSM JSVal)
- jss :: (ToJSString name, ToJSVal val) => name -> val -> forall o. MakeObject o => IndexPreservingGetter o (JSM ())
- jsf :: (ToJSString name, MakeArgs args) => name -> args -> JSF
- js0 :: ToJSString name => name -> JSF
- js1 :: (ToJSString name, ToJSVal a0) => name -> a0 -> JSF
- js2 :: (ToJSString name, ToJSVal a0, ToJSVal a1) => name -> a0 -> a1 -> JSF
- js3 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2) => name -> a0 -> a1 -> a2 -> JSF
- js4 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2, ToJSVal a3) => name -> a0 -> a1 -> a2 -> a3 -> JSF
- js5 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2, ToJSVal a3, ToJSVal a4) => name -> a0 -> a1 -> a2 -> a3 -> a4 -> JSF
- jsg :: ToJSString a => a -> JSM JSVal
- jsgf :: (ToJSString name, MakeArgs args) => name -> args -> JSM JSVal
- jsg0 :: ToJSString name => name -> JSM JSVal
- jsg1 :: (ToJSString name, ToJSVal a0) => name -> a0 -> JSM JSVal
- jsg2 :: (ToJSString name, ToJSVal a0, ToJSVal a1) => name -> a0 -> a1 -> JSM JSVal
- jsg3 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2) => name -> a0 -> a1 -> a2 -> JSM JSVal
- jsg4 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2, ToJSVal a3) => name -> a0 -> a1 -> a2 -> a3 -> JSM JSVal
- jsg5 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2, ToJSVal a3, ToJSVal a4) => name -> a0 -> a1 -> a2 -> a3 -> a4 -> JSM JSVal
- (#) :: (MakeObject this, ToJSString name, MakeArgs args) => this -> name -> args -> JSM JSVal
- (##) :: (MakeObject this, MakeArgs args) => this -> Int -> args -> JSM JSVal
- (<#) :: (MakeObject this, ToJSString name, ToJSVal val) => this -> name -> val -> JSM ()
- (<##) :: (MakeObject this, ToJSVal val) => this -> Int -> val -> JSM ()
- new :: (MakeObject constructor, MakeArgs args) => constructor -> args -> JSM JSVal
- call :: (MakeObject f, MakeObject this, MakeArgs args) => f -> this -> args -> JSM JSVal
- obj :: JSM Object
- fun :: JSCallAsFunction -> JSCallAsFunction
- function :: JSCallAsFunction -> JSM Function
- asyncFunction :: JSCallAsFunction -> JSM Function
- freeFunction :: Function -> JSM ()
- array :: MakeArgs args => args -> JSM Object
- global :: Object
- propertyNames :: MakeObject this => this -> JSM [JSString]
- properties :: MakeObject this => this -> JSM [JSVal]
- objCallAsFunction :: MakeArgs args => Object -> Object -> args -> JSM JSVal
- objCallAsConstructor :: MakeArgs args => Object -> args -> JSM JSVal
- nullObject :: Object
- toJSVal_aeson :: ToJSON a => a -> JSM JSVal
JSaddle EDSL
The JSM monad gives us the context for evaluation. In keeping
with JavaScript the EDSL has
- Weakish typing - type classes are used to convert to JSValueRef and Object types
- Strict evaluation - function in the
JSMmonad can be passed in place of a value and will evaluated and converted to JSValueRef or Object and then passed on to JavaScript
JSaddle should be used to write wrappers for JavaScript libraries that provide more type safety.
Code Examples
The code examples in this documentation are executed with a runjs
function that executes the example code in the JSM monad and converts
the result to Text with valToText. It also catches unhandled
exceptions with catch. The source code can be found in tests/TestJSaddle.hs
Where it makes sense code examples are given in two forms. One
that uses eval to run a purely JavaScript version and one that
uses more of the JSaddle EDSL feature being demonstrated.
Calling Haskell from JavaScript
You can call back into Haskell from JavaScript using fun to
convert a Haskell function in the JSM monad into a javascript
value.
GHCJS Support
When built with ghcjs the code works using JavaScript FFI by default.
GHC Support
When built with ghc the code runs a small Warp server that provides index.html and jsaddle.js files. When a browser is connected the code in jsaddle.js will open a WebSockets connection to the server and the server will run the Haskell code. The JSaddle parts will be executed by sending commands back to the browser.
Modules
bracket :: MonadMask m => m a -> (a -> m c) -> (a -> m b) -> m b #
Generalized abstracted pattern of safe resource acquisition and release
in the face of errors. The first action "acquires" some value, which
is "released" by the second action at the end. The third action "uses"
the value and its result is the result of the bracket.
If an error is thrown during the use, the release still happens before the error is rethrown.
Note that this is essentially a type-specialized version of
generalBracket. This function has a more common signature (matching the
signature from Control.Exception), and is often more convenient to use. By
contrast, generalBracket is more expressive, allowing us to implement
other functions like bracketOnError.
catch :: (MonadCatch m, Exception e) => m a -> (e -> m a) -> m a #
Provide a handler for exceptions thrown during execution of the first
action. Note that type of the type of the argument to the handler will
constrain which exceptions are caught. See Control.Exception's
catch.
A wrapper around a JavaScript string
Instances
Constructors
| JSVal (IORef JSValueRef) |
Instances
| NFData JSVal Source # | |
Defined in GHCJS.Prim.Internal | |
| MakeArgs JSVal Source # | A single JSVal can be used as the argument list |
| MakeArgs JSCallAsFunction Source # | |
Defined in Language.Javascript.JSaddle.Object | |
| MakeObject JSVal Source # | |
Defined in Language.Javascript.JSaddle.Value | |
| FromJSVal JSVal Source # | |
| ToJSVal JSVal Source # | If we already have a JSVal we are fine |
| ToJSVal JSCallAsFunction Source # | A callback to Haskell can be used as a JavaScript value. This will create
an anonymous JavaScript function object. Use |
Defined in Language.Javascript.JSaddle.Object Methods toJSVal :: JSCallAsFunction -> JSM JSVal Source # toJSValListOf :: [JSCallAsFunction] -> JSM JSVal Source # | |
| PFromJSVal JSVal Source # | |
Defined in GHCJS.Marshal.Pure Methods pFromJSVal :: JSVal -> JSVal Source # | |
| PToJSVal JSVal Source # | |
newtype JSException Source #
Constructors
| JSException JSVal |
Instances
| Show JSException Source # | JavaScript exception >>> |
Defined in Language.Javascript.JSaddle.Exception Methods showsPrec :: Int -> JSException -> ShowS # show :: JSException -> String # showList :: [JSException] -> ShowS # | |
| Exception JSException Source # | |
Defined in Language.Javascript.JSaddle.Exception Methods toException :: JSException -> SomeException # fromException :: SomeException -> Maybe JSException # displayException :: JSException -> String # | |
type JSadddleHasCallStack = (() :: Constraint) Source #
Like HasCallStack, but only when jsaddle cabal flag check-unchecked is set
Constructors
| BatchResults Int BatchResults | |
| Duplicate Int Int | |
| Callback Int BatchResults JSValueReceived JSValueReceived JSValueReceived [JSValueReceived] | |
| ProtocolError Text |
Instances
data BatchResults Source #
Constructors
| Success [JSValueReceived] [Result] | |
| Failure [JSValueReceived] [Result] JSValueReceived |
Instances
Result of a Command returned from the JavaScript context
Constructors
Instances
Batch of commands that can be sent together to the JavaScript context
Instances
| Show Batch Source # | |
| Generic Batch Source # | |
| ToJSON Batch Source # | |
Defined in Language.Javascript.JSaddle.Types | |
| FromJSON Batch Source # | |
| NFData Batch Source # | |
Defined in Language.Javascript.JSaddle.Types | |
| type Rep Batch Source # | |
Defined in Language.Javascript.JSaddle.Types type Rep Batch = D1 (MetaData "Batch" "Language.Javascript.JSaddle.Types" "jsaddle-0.9.6.0-Djvo0zlHJ2C3FFRFCHUbcO" False) (C1 (MetaCons "Batch" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Either AsyncCommand Command]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))) | |
Command sent to a JavaScript context for execution synchronously
Constructors
Instances
data AsyncCommand Source #
Command sent to a JavaScript context for execution asynchronously
Constructors
Instances
newtype JSStringForSend Source #
Wrapper used when sending a JString to the JavaScript context
Constructors
| JSStringForSend Text |
Instances
newtype JSStringReceived Source #
Wrapper used when receiving a JSString from the JavaScript context
Constructors
| JSStringReceived Text |
Instances
| Show JSStringReceived Source # | |
Defined in Language.Javascript.JSaddle.Types Methods showsPrec :: Int -> JSStringReceived -> ShowS # show :: JSStringReceived -> String # showList :: [JSStringReceived] -> ShowS # | |
| ToJSON JSStringReceived Source # | |
Defined in Language.Javascript.JSaddle.Types Methods toJSON :: JSStringReceived -> Value # toEncoding :: JSStringReceived -> Encoding # toJSONList :: [JSStringReceived] -> Value # toEncodingList :: [JSStringReceived] -> Encoding # | |
| FromJSON JSStringReceived Source # | |
Defined in Language.Javascript.JSaddle.Types Methods parseJSON :: Value -> Parser JSStringReceived # parseJSONList :: Value -> Parser [JSStringReceived] # | |
newtype JSObjectForSend Source #
Wrapper used when sending a Object to the JavaScript context
Constructors
| JSObjectForSend JSValueForSend |
Instances
newtype JSValueForSend Source #
Wrapper used when sending a JSVal to the JavaScript context
Constructors
| JSValueForSend JSValueRef |
Instances
newtype JSValueReceived Source #
Wrapper used when receiving a JSVal from the JavaScript context
Constructors
| JSValueReceived JSValueRef |
Instances
| Show JSValueReceived Source # | |
Defined in Language.Javascript.JSaddle.Types Methods showsPrec :: Int -> JSValueReceived -> ShowS # show :: JSValueReceived -> String # showList :: [JSValueReceived] -> ShowS # | |
| ToJSON JSValueReceived Source # | |
Defined in Language.Javascript.JSaddle.Types Methods toJSON :: JSValueReceived -> Value # toEncoding :: JSValueReceived -> Encoding # toJSONList :: [JSValueReceived] -> Value # toEncodingList :: [JSValueReceived] -> Encoding # | |
| FromJSON JSValueReceived Source # | |
Defined in Language.Javascript.JSaddle.Types Methods parseJSON :: Value -> Parser JSValueReceived # parseJSONList :: Value -> Parser [JSValueReceived] # | |
See Object
Instances
| MakeObject Object Source # | If we already have a Object we are fine |
Defined in Language.Javascript.JSaddle.Classes.Internal | |
| ToJSVal Object Source # | |
type MutableJSArray = SomeJSArray Mutable Source #
See MutableJSArray
newtype SomeJSArray (m :: MutabilityType s) Source #
Constructors
| SomeJSArray JSVal |
Instances
| IsJSVal (SomeJSArray m) Source # | |
Defined in Language.Javascript.JSaddle.Types | |
type family Mutability (a :: MutabilityType s) :: IsItMutable where ... Source #
Equations
| Mutability Immutable = IsImmutable | |
| Mutability Mutable = IsMutable | |
| Mutability (STMutable s) = IsMutable |
data IsItMutable Source #
Constructors
| IsImmutable | |
| IsMutable |
type Immutable = Immutable_ () Source #
data MutabilityType s Source #
Constructors
| Mutable_ s | |
| Immutable_ s | |
| STMutable s |
class IsJSVal a where Source #
Minimal complete definition
Nothing
Methods
jsval_ :: a -> GHCJSPure JSVal Source #
jsval_ :: Coercible a JSVal => a -> GHCJSPure JSVal Source #
Instances
| IsJSVal JSString Source # | |
| IsJSVal (SomeJSArray m) Source # | |
Defined in Language.Javascript.JSaddle.Types | |
| IsJSVal (SomeArrayBuffer m) Source # | |
Defined in JavaScript.TypedArray.ArrayBuffer.Internal | |
| IsJSVal (SomeTypedArray e m) Source # | |
Defined in JavaScript.TypedArray.Internal.Types | |
type JSCallAsFunction Source #
Arguments
| = JSVal | Function object |
| -> JSVal | this |
| -> [JSVal] | Function arguments |
| -> JSM () | Only () (aka |
Type used for Haskell functions called from JavaScript.
class (Applicative m, MonadIO m) => MonadJSM m where Source #
Minimal complete definition
Nothing
Methods
liftJSM' :: JSM a -> m a Source #
liftJSM' :: (MonadJSM m', MonadTrans t, m ~ t m') => JSM a -> m a Source #
Instances
| MonadJSM JSM Source # | |
| MonadJSM m => MonadJSM (MaybeT m) Source # | |
| MonadJSM m => MonadJSM (ListT m) Source # | |
| MonadJSM m => MonadJSM (IdentityT m) Source # | |
| MonadJSM m => MonadJSM (ExceptT e m) Source # | |
| (Error e, MonadJSM m) => MonadJSM (ErrorT e m) Source # | |
| MonadJSM m => MonadJSM (StateT s m) Source # | |
| MonadJSM m => MonadJSM (StateT s m) Source # | |
| (Monoid w, MonadJSM m) => MonadJSM (WriterT w m) Source # | |
| (Monoid w, MonadJSM m) => MonadJSM (WriterT w m) Source # | |
| MonadJSM m => MonadJSM (ContT r m) Source # | |
| MonadJSM m => MonadJSM (ReaderT r m) Source # | |
| (Monoid w, MonadJSM m) => MonadJSM (RWST r w s m) Source # | |
| (Monoid w, MonadJSM m) => MonadJSM (RWST r w s m) Source # | |
Type we can give to functions that are pure when using ghcjs, but live in JSM when using jsaddle.
Some functions that can be pure in GHCJS cannot be implemented in
a pure way in JSaddle (because we need to know the JSContextRef).
Instead we implement versions of these functions in that return
`GHCJSPure a` instead of a. To call them in a way that will
work when compiling with GHCJS use ghcjsPure.
The JSM monad keeps track of the JavaScript execution context.
When using GHCJS it is IO.
Given a JSM function and a JSContextRef you can run the
function like this...
runJSM jsmFunction javaScriptContext
Constructors
| JSM | |
Fields
| |
Instances
data JSContextRef Source #
Identifies a JavaScript execution context. When using GHCJS this is just '()' since their is only one context. When using GHC it includes the functions JSaddle needs to communicate with the JavaScript context.
Constructors
| JSContextRef | |
Fields
| |
ghcjsPure :: GHCJSPure a -> JSM a Source #
Used when you want to call a functions that is pure in GHCJS, but lives in the JSM in jsaddle.
ghcjsPureMap :: (a -> b) -> GHCJSPure a -> GHCJSPure b Source #
ghcjsPureId :: a -> GHCJSPure a Source #
textFromJSString :: JSString -> Text Source #
textToJSString :: Text -> JSString Source #
waitForAnimationFrame :: JSM Double Source #
On GHCJS this is waitForAnimationFrame.
On GHC it will delay the execution of the current batch of asynchronous
command when they are sent to JavaScript. It will not delay the Haskell
code execution. The time returned will be based on the Haskell clock
(not the JavaScript clock).
nextAnimationFrame :: (Double -> JSM a) -> JSM a Source #
Tries to executes the given code in the next animation frame callback. Avoid synchronous opperations where possible.
askJSM :: MonadJSM m => m JSContextRef Source #
Gets the JavaScript context from the monad
runJSM :: MonadIO m => JSM a -> JSContextRef -> m a Source #
Runs a JSM JavaScript function in a given JavaScript context.
runJSaddle :: MonadIO m => JSContextRef -> JSM a -> m a Source #
Alternative version of runJSM
class MakeArgs this where Source #
Anything that can be used to make a list of JavaScript value references for use as function arguments
Instances
| MakeArgs Bool Source # | Makes an argument list with just a single JavaScript boolean value |
| MakeArgs Double Source # | Makes an argument list with just a single JavaScript number |
| MakeArgs () Source # | This allows us to pass no arguments easily (altenative would be to use |
| MakeArgs Text Source # | Makes an argument list with just a single JavaScript string |
| MakeArgs Value Source # | Makes an argument list with just a single JSON value |
| MakeArgs JSVal Source # | A single JSVal can be used as the argument list |
| MakeArgs JSCallAsFunction Source # | |
Defined in Language.Javascript.JSaddle.Object | |
| MakeArgs JSValue Source # | Makes an argument list with just a single JavaScript value from a |
| MakeArgs JSNull Source # | Makes an argument list with just a single |
| ToJSVal arg => MakeArgs [arg] Source # | |
| MakeArgs arg => MakeArgs (JSM arg) Source # | |
| (ToJSVal arg1, ToJSVal arg2) => MakeArgs (arg1, arg2) Source # | |
| (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3) => MakeArgs (arg1, arg2, arg3) Source # | |
| (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4) => MakeArgs (arg1, arg2, arg3, arg4) Source # | |
| (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4, ToJSVal arg5) => MakeArgs (arg1, arg2, arg3, arg4, arg5) Source # | |
| (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4, ToJSVal arg5, ToJSVal arg6) => MakeArgs (arg1, arg2, arg3, arg4, arg5, arg6) Source # | |
class MakeObject this where Source #
Anything that can be used to make a JavaScript object reference
Methods
makeObject :: this -> JSM Object Source #
Instances
| MakeObject JSVal Source # | |
Defined in Language.Javascript.JSaddle.Value | |
| MakeObject Object Source # | If we already have a Object we are fine |
Defined in Language.Javascript.JSaddle.Classes.Internal | |
| MakeObject v => MakeObject (JSM v) Source # | Object can be made by evaluating a fnction in |
Defined in Language.Javascript.JSaddle.Object | |
getProp :: JSString -> Object -> JSM JSVal Source #
get a property from an object. If accessing the property results in an exception, the exception is converted to a JSException. Since exception handling code prevents some optimizations in some JS engines, you may want to use unsafeGetProp instead
fromListIO :: [JSVal] -> JSM (SomeJSArray m) Source #
jsUndefined :: JSVal Source #
class FromJSVal a where Source #
Minimal complete definition
Nothing
Methods
fromJSVal :: JSVal -> JSM (Maybe a) Source #
fromJSValUnchecked :: JSVal -> JSM a Source #
fromJSValListOf :: JSVal -> JSM (Maybe [a]) Source #
fromJSValUncheckedListOf :: JSVal -> JSM [a] Source #
fromJSVal :: (Generic a, GFromJSVal (Rep a ())) => JSVal -> JSM (Maybe a) Source #
Instances
class ToJSVal a where Source #
Minimal complete definition
Nothing
Methods
toJSVal :: a -> JSM JSVal Source #
toJSValListOf :: [a] -> JSM JSVal Source #
toJSVal :: (Generic a, GToJSVal (Rep a ())) => a -> JSM JSVal Source #
Instances
class PFromJSVal a where Source #
Methods
pFromJSVal :: JSVal -> a Source #
Instances
| PFromJSVal () Source # | |
Defined in GHCJS.Marshal.Pure Methods pFromJSVal :: JSVal -> () Source # | |
| PFromJSVal JSVal Source # | |
Defined in GHCJS.Marshal.Pure Methods pFromJSVal :: JSVal -> JSVal Source # | |
| PFromJSVal MutableArrayBuffer Source # | |
Defined in JavaScript.TypedArray.ArrayBuffer.Internal Methods pFromJSVal :: JSVal -> MutableArrayBuffer Source # | |
class FromJSVal a => FromJSString a where Source #
Anything that can be constructed from a JavaScript string
Methods
fromJSString :: JSString -> a Source #
Instances
| FromJSString Text Source # | |
Defined in Language.Javascript.JSaddle.Value Methods fromJSString :: JSString -> Text Source # | |
| FromJSString String Source # | |
Defined in Language.Javascript.JSaddle.Value Methods fromJSString :: JSString -> String Source # | |
| FromJSString JSString Source # | |
Defined in Language.Javascript.JSaddle.Value Methods fromJSString :: JSString -> JSString Source # | |
class ToJSVal a => ToJSString a where Source #
Anything that can be used to make a JavaScript string
Methods
toJSString :: a -> JSString Source #
Instances
| ToJSString Text Source # | |
Defined in Language.Javascript.JSaddle.Value Methods toJSString :: Text -> JSString Source # | |
| ToJSString String Source # | |
Defined in Language.Javascript.JSaddle.Value Methods toJSString :: String -> JSString Source # | |
| ToJSString JSString Source # | If we already have a JSString we are fine |
Defined in Language.Javascript.JSaddle.Value Methods toJSString :: JSString -> JSString Source # | |
Arguments
| :: ToJSString script | |
| => script | JavaScript to evaluate |
| -> JSM JSVal |
Evaluates a script (like eval in java script)
>>>testJSaddle $ eval "1+1"2
Arguments
| :: ToJSString name | |
| => Object | object to find the property on. |
| -> name | name of the property. |
| -> JSM JSVal | returns the property value. |
Get a property value given the object and the name of the property.
objGetPropertyAtIndex Source #
Arguments
| :: Object | object to find the property on. |
| -> Int | index of the property. |
| -> JSM JSVal | returns the property value. |
Get a property value given the object and the index of the property.
Arguments
| :: (ToJSString name, ToJSVal val) | |
| => Object | object to set the property on. |
| -> name | name of the property. |
| -> val | new value to set the property to. |
| -> JSM () |
Set a property value given the object and the name of the property.
objSetPropertyAtIndex Source #
Arguments
| :: ToJSVal val | |
| => Object | object to find property on. |
| -> Int | index of the property. |
| -> val | new value to set the property to. |
| -> JSM () |
Set a property value given the object and the index of the property.
An algebraic data type that can represent a JavaScript value. Any JavaScriptCore
JSVal can be converted into this type.
Constructors
| ValNull | null |
| ValUndefined | undefined |
| ValBool Bool | true or false |
| ValNumber Double | a number |
| ValString Text | a string |
| ValObject Object | an object |
type JSUndefined Source #
Arguments
| = () | A type that can only be undefined in JavaScript. Using ()
because functions in JavaScript that have no return, impicitly
return undefined.
type JSBool = Bool -- ^ JavaScript boolean values map the |
Constructors
| JSNull | Type that represents a value that can only be null. Haskell of course has no null so we are adding this type. |
showJSValue :: JSValue -> String Source #
Show a JSValue but just say "object" if the value is a JavaScript object.
valToBool :: ToJSVal value => value -> JSM Bool Source #
Given a JavaScript value get its boolean value. All values in JavaScript convert to bool.
>>>testJSaddle $ valToBool JSNullfalse>>>testJSaddle $ valToBool ()false>>>testJSaddle $ valToBool Truetrue>>>testJSaddle $ valToBool Falsefalse>>>testJSaddle $ valToBool (1.0 :: Double)true>>>testJSaddle $ valToBool (0.0 :: Double)false>>>testJSaddle $ valToBool ""false>>>testJSaddle $ valToBool "1"true
valToNumber :: ToJSVal value => value -> JSM Double Source #
Given a JavaScript value get its numeric value. May throw JSException.
>>>testJSaddle $ show <$> valToNumber JSNull0.0>>>testJSaddle $ show <$> valToNumber ()NaN>>>testJSaddle $ show <$> valToNumber True1.0>>>testJSaddle $ show <$> valToNumber False0.0>>>testJSaddle $ show <$> valToNumber (1.0 :: Double)1.0>>>testJSaddle $ show <$> valToNumber (0.0 :: Double)0.0>>>testJSaddle $ show <$> valToNumber ""0.0>>>testJSaddle $ show <$> valToNumber "1"1.0
valToStr :: ToJSVal value => value -> JSM JSString Source #
Given a JavaScript value get its string value (as a JavaScript string). May throw JSException.
>>>testJSaddle $ strToText <$> valToStr JSNullnull>>>testJSaddle $ strToText <$> valToStr ()undefined>>>testJSaddle $ strToText <$> valToStr Truetrue>>>testJSaddle $ strToText <$> valToStr Falsefalse>>>testJSaddle $ strToText <$> valToStr (1.0 :: Double)1>>>testJSaddle $ strToText <$> valToStr (0.0 :: Double)0>>>testJSaddle $ strToText <$> valToStr "">>>testJSaddle $ strToText <$> valToStr "1"1
valToText :: ToJSVal value => value -> JSM Text Source #
Given a JavaScript value get its string value (as a Haskell Text).
May throw JSException.
>>>testJSaddle $ show <$> valToText JSNull"null">>>testJSaddle $ show <$> valToText ()"undefined">>>testJSaddle $ show <$> valToText True"true">>>testJSaddle $ show <$> valToText False"false">>>testJSaddle $ show <$> valToText (1.0 :: Double)"1">>>testJSaddle $ show <$> valToText (0.0 :: Double)"0">>>testJSaddle $ show <$> valToText """">>>testJSaddle $ show <$> valToText "1""1"
valToJSON :: ToJSVal value => value -> JSM JSString Source #
Given a JavaScript value get a JSON string value. May throw JSException.
>>>testJSaddle $ strToText <$> valToJSON JSNullnull>>>testJSaddle $ strToText <$> valToJSON ()>>>testJSaddle $ strToText <$> valToJSON Truetrue>>>testJSaddle $ strToText <$> valToJSON Falsefalse>>>testJSaddle $ strToText <$> valToJSON (1.0 :: Double)1>>>testJSaddle $ strToText <$> valToJSON (0.0 :: Double)0>>>testJSaddle $ strToText <$> valToJSON """">>>testJSaddle $ strToText <$> valToJSON "1""1">>>testJSaddle $ strToText <$> (obj >>= valToJSON){}
valToObject :: ToJSVal value => value -> JSM Object Source #
Given a JavaScript value get its object value. May throw JSException.
>>>testJSaddle $ (valToObject JSNull >>= valToText) `catch` \ (JSException e) -> valToText enull>>>testJSaddle $ (valToObject () >>= valToText) `catch` \ (JSException e) -> valToText eundefined>>>testJSaddle $ valToObject Truetrue>>>testJSaddle $ valToObject Falsefalse>>>testJSaddle $ valToObject (1.0 :: Double)1>>>testJSaddle $ valToObject (0.0 :: Double)0>>>testJSaddle $ valToObject "">>>testJSaddle $ valToObject "1"1
Convert to a JavaScript value (just an alias for toJSVal)
valIsNull :: ToJSVal value => value -> JSM Bool Source #
Test a JavaScript value to see if it is null
valUndefined :: JSVal Source #
An undefined JavaScript value
valIsUndefined :: ToJSVal value => value -> JSM Bool Source #
Test a JavaScript value to see if it is undefined
maybeNullOrUndefined :: ToJSVal value => value -> JSM (Maybe JSVal) Source #
Convert a JSVal to a Maybe JSVal (converting null and undefined to Nothing)
deRefVal :: ToJSVal value => value -> JSM JSValue Source #
Derefernce a value reference.
>>>testJSaddle $ showJSValue <$> deRefVal JSNullnull>>>testJSaddle $ showJSValue <$> deRefVal ()undefined>>>testJSaddle $ showJSValue <$> deRefVal Truetrue>>>testJSaddle $ showJSValue <$> deRefVal Falsefalse>>>testJSaddle $ showJSValue <$> deRefVal (1.0 :: Double)1.0>>>testJSaddle $ showJSValue <$> deRefVal (0.0 :: Double)0.0>>>testJSaddle $ showJSValue <$> deRefVal """">>>testJSaddle $ showJSValue <$> deRefVal "1""1">>>testJSaddle $ showJSValue <$> (valToObject True >>= deRefVal)true>>>testJSaddle $ showJSValue <$> (obj >>= deRefVal)object
valMakeRef :: JSValue -> JSM JSVal Source #
Make a JavaScript value out of a JSValue ADT.
>>>testJSaddle $ valMakeRef ValNullnull>>>testJSaddle $ valMakeRef ValUndefinedundefined>>>testJSaddle $ valMakeRef (ValBool True)true>>>testJSaddle $ valMakeRef (ValNumber 1)1>>>testJSaddle $ valMakeRef (ValString $ T.pack "Hello")Hello
instanceOf :: (ToJSVal value, MakeObject constructor) => value -> constructor -> JSM Bool Source #
Make a JavaScript function object that wraps a Haskell function.
Calls made to the function will be synchronous where possible
(on GHCJS it uses on syncCallback2 with ContinueAsync).
Constructors
| Function | |
Fields | |
type JSF = forall o. MakeObject o => IndexPreservingGetter o (JSM JSVal) Source #
Java script function applications have this type
Arguments
| :: (MakeObject this, ToJSString name) | |
| => this | Object to look on |
| -> name | Name of the property to find |
| -> JSM JSVal | Property reference |
Lookup a property based on its name.
>>>testJSaddle $ eval "'Hello World'.length"11>>>testJSaddle $ val "Hello World" ! "length"11
Arguments
| :: MakeObject this | |
| => this | Object to look on |
| -> Int | Index of the property to lookup |
| -> JSM JSVal | Property reference |
Lookup a property based on its index.
>>>testJSaddle $ eval "'Hello World'[6]"W>>>testJSaddle $ val "Hello World" !! 6W
Arguments
| :: (MakeObject s, ToJSString name) | |
| => name | Name of the property to find |
| -> IndexPreservingGetter s (JSM JSVal) |
Makes a getter for a particular property name.
js name = to (!name)
>>>testJSaddle $ eval "'Hello World'.length"11>>>testJSaddle $ val "Hello World" ^. js "length"11
Arguments
| :: (ToJSString name, ToJSVal val) | |
| => name | Name of the property to find |
| -> val | |
| -> MakeObject o | |
| => IndexPreservingGetter o (JSM ()) |
Makes a setter for a particular property name.
jss name = to (<#name)
>>>testJSaddle $ eval "'Hello World'.length = 12"12>>>testJSaddle $ val "Hello World" ^. jss "length" 12undefined
jsf :: (ToJSString name, MakeArgs args) => name -> args -> JSF Source #
Handy way to call a function
jsf name = to (\o -> o # name $ args)
>>>testJSaddle $ val "Hello World" ^. jsf "indexOf" ["World"]6
js0 :: ToJSString name => name -> JSF Source #
Handy way to call a function that expects no arguments
js0 name = jsf name ()
>>>testJSaddle $ val "Hello World" ^. js0 "toLowerCase"hello world
js1 :: (ToJSString name, ToJSVal a0) => name -> a0 -> JSF Source #
Handy way to call a function that expects one argument
js1 name a0 = jsf name [a0]
>>>testJSaddle $ val "Hello World" ^. js1 "indexOf" "World"6
js2 :: (ToJSString name, ToJSVal a0, ToJSVal a1) => name -> a0 -> a1 -> JSF Source #
Handy way to call a function that expects two arguments
js3 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2) => name -> a0 -> a1 -> a2 -> JSF Source #
Handy way to call a function that expects three arguments
js4 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2, ToJSVal a3) => name -> a0 -> a1 -> a2 -> a3 -> JSF Source #
Handy way to call a function that expects four arguments
js5 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2, ToJSVal a3, ToJSVal a4) => name -> a0 -> a1 -> a2 -> a3 -> a4 -> JSF Source #
Handy way to call a function that expects five arguments
jsg :: ToJSString a => a -> JSM JSVal Source #
Handy way to get and hold onto a reference top level javascript
>>>testJSaddle $ eval "w = console; w.log('Hello World')"undefined>>>testJSaddle $ do w <- jsg "console"; w ^. js1 "log" "Hello World"undefined
jsgf :: (ToJSString name, MakeArgs args) => name -> args -> JSM JSVal Source #
Handy way to call a function
jsgf name = jsg name . to (# args)
>>>testJSaddle $ eval "globalFunc = function (x) {return x.length;}"function (x) {return x.length;}>>>testJSaddle $ jsgf "globalFunc" ["World"]5
jsg0 :: ToJSString name => name -> JSM JSVal Source #
Handy way to call a function that expects no arguments
jsg0 name = jsgf name ()
>>>testJSaddle $ jsg0 "globalFunc" >>= valToTextA JavaScript exception was thrown! (may not reach Haskell code) TypeError:...undefine...
jsg1 :: (ToJSString name, ToJSVal a0) => name -> a0 -> JSM JSVal Source #
Handy way to call a function that expects one argument
jsg1 name a0 = jsgf name [a0]
>>>testJSaddle $ jsg1 "globalFunc" "World"5
jsg2 :: (ToJSString name, ToJSVal a0, ToJSVal a1) => name -> a0 -> a1 -> JSM JSVal Source #
Handy way to call a function that expects two arguments
jsg3 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2) => name -> a0 -> a1 -> a2 -> JSM JSVal Source #
Handy way to call a function that expects three arguments
jsg4 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2, ToJSVal a3) => name -> a0 -> a1 -> a2 -> a3 -> JSM JSVal Source #
Handy way to call a function that expects four arguments
jsg5 :: (ToJSString name, ToJSVal a0, ToJSVal a1, ToJSVal a2, ToJSVal a3, ToJSVal a4) => name -> a0 -> a1 -> a2 -> a3 -> a4 -> JSM JSVal Source #
Handy way to call a function that expects five arguments
(#) :: (MakeObject this, ToJSString name, MakeArgs args) => this -> name -> args -> JSM JSVal infixr 2 Source #
Call a JavaScript function
>>>testJSaddle $ eval "'Hello World'.indexOf('World')"6>>>testJSaddle $ val "Hello World" # "indexOf" $ ["World"]6
(##) :: (MakeObject this, MakeArgs args) => this -> Int -> args -> JSM JSVal infixr 2 Source #
Call a JavaScript function
>>>testJSaddle $ eval "something = {}; something[6]=function (x) {return x.length;}; something[6]('World')"5>>>testJSaddle $ jsg "something" ## 6 $ ["World"]5
Arguments
| :: (MakeObject this, ToJSString name, ToJSVal val) | |
| => this | Object to set the property on |
| -> name | Name of the property to set |
| -> val | Value to set it to |
| -> JSM () |
Set a JavaScript property
>>>testJSaddle $ eval "var j = {}; j.x = 1; j.x"1>>>testJSaddle $ do {j <- obj; (j <# "x") 1; j!"x"}1
Arguments
| :: (MakeObject this, ToJSVal val) | |
| => this | Object to set the property on |
| -> Int | Index of the property to set |
| -> val | Value to set it to |
| -> JSM () |
Set a JavaScript property
>>>testJSaddle $ eval "var j = {}; j[6] = 1; j[6]"1>>>testJSaddle $ do {j <- obj; (j <## 6) 1; j!!6}1
new :: (MakeObject constructor, MakeArgs args) => constructor -> args -> JSM JSVal Source #
Use this to create a new JavaScript object
If you pass more than 7 arguments to a constructor for a built in JavaScript type (like Date) then this function will fail.
>>>testJSaddle $ new (jsg "Date") (2013, 1, 1)Fri Feb 01 2013 00:00:00 GMT+... (...)
call :: (MakeObject f, MakeObject this, MakeArgs args) => f -> this -> args -> JSM JSVal Source #
Call function with a given this. In most cases you should use #.
>>>testJSaddle $ eval "(function(){return this;}).apply('Hello', [])"Hello>>>testJSaddle $ do { test <- eval "(function(){return this;})"; call test (val "Hello") () }Hello
Make an empty object using the default constuctor
>>>testJSaddle $ eval "var a = {}; a.x = 'Hello'; a.x"Hello>>>testJSaddle $ do { a <- obj; (a <# "x") "Hello"; a ^. js "x" }Hello
fun :: JSCallAsFunction -> JSCallAsFunction Source #
Short hand ::JSCallAsFunction so a haskell function can be passed to
a to a JavaScipt one.
>>>testJSaddle $ eval "(function(f) {f('Hello');})(function (a) {console.log(a)})"undefined>>>:{testJSaddle $ do result <- liftIO newEmptyMVar deRefVal $ call (eval "(function(f) {f('Hello');})") global [fun $ \ _ _ [arg1] -> do valToText arg1 >>= (liftIO . putMVar result) ] liftIO $ takeMVar result :} Hello
Arguments
| :: JSCallAsFunction | Haskell function to call |
| -> JSM Function | Returns a JavaScript function object that will call the Haskell one when it is called |
Make a JavaScript function object that wraps a Haskell function. Calls made to the function will be Asynchronous.
Arguments
| :: JSCallAsFunction | Haskell function to call |
| -> JSM Function | Returns a JavaScript function object that will call the Haskell one when it is called |
freeFunction :: Function -> JSM () Source #
array :: MakeArgs args => args -> JSM Object Source #
Make an JavaScript array from a list of values
>>>testJSaddle $ eval "['Hello', 'World'][1]"World>>>testJSaddle $ array ["Hello", "World"] !! 1World>>>testJSaddle $ eval "['Hello', null, undefined, true, 1]"Hello,,,true,1>>>testJSaddle $ array ("Hello", JSNull, (), True, 1.0::Double)Hello,,,true,1
propertyNames :: MakeObject this => this -> JSM [JSString] Source #
properties :: MakeObject this => this -> JSM [JSVal] Source #
Get a list containing references to all the properties present on a given object
objCallAsFunction :: MakeArgs args => Object -> Object -> args -> JSM JSVal Source #
Call a JavaScript object as function. Consider using #.
objCallAsConstructor :: MakeArgs args => Object -> args -> JSM JSVal Source #
Call a JavaScript object as a constructor. Consider using new.
If you pass more than 7 arguments to a constructor for a built in JavaScript type (like Date) then this function will fail.
nullObject :: Object Source #