See Object

Anything that can be used to make a JavaScript object reference

Lookup a property based on its name.

>>> testJSaddle $ eval "'Hello World'.length"
11
>>> testJSaddle $ val "Hello World" ! "length"
11

Lookup a property based on its index.

>>> testJSaddle $ eval "'Hello World'[6]"
W
>>> testJSaddle $ val "Hello World" !! 6
W

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

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" 12
undefined

Java script function applications have this type

Handy way to call a function

jsf name = to (\o -> o # name $ args)

>>> testJSaddle $ val "Hello World" ^. jsf "indexOf" ["World"]
6

Handy way to call a function that expects no arguments

js0 name = jsf name ()

>>> testJSaddle $ val "Hello World" ^. js0 "toLowerCase"
hello world

Handy way to call a function that expects one argument

js1 name a0 = jsf name [a0]

>>> testJSaddle $ val "Hello World" ^. js1 "indexOf" "World"
6

Handy way to call a function that expects two arguments

Handy way to call a function that expects three arguments

Handy way to call a function that expects four arguments

Handy way to call a function that expects five arguments

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

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

Handy way to call a function that expects no arguments

jsg0 name = jsgf name ()

>>> testJSaddle $ jsg0 "globalFunc" >>= valToText
A JavaScript exception was thrown! (may not reach Haskell code)
TypeError:...undefine...

Handy way to call a function that expects one argument

jsg1 name a0 = jsgf name [a0]

>>> testJSaddle $ jsg1 "globalFunc" "World"
5

Handy way to call a function that expects two arguments

Handy way to call a function that expects three arguments

Handy way to call a function that expects four arguments

Handy way to call a function that expects five arguments

Set a JavaScript property

>>> testJSaddle $ eval "var j = {}; j.x = 1; j.x"
1
>>> testJSaddle $ do {j <- obj; (j <# "x") 1; j!"x"}
1

Set a JavaScript property

>>> testJSaddle $ eval "var j = {}; j[6] = 1; j[6]"
1
>>> testJSaddle $ do {j <- obj; (j <## 6) 1; j!!6}
1

Call a JavaScript function

>>> testJSaddle $ eval "'Hello World'.indexOf('World')"
6
>>> testJSaddle $ val "Hello World" # "indexOf" $ ["World"]
6

Call a JavaScript function

>>> testJSaddle $ eval "something = {}; something[6]=function (x) {return x.length;}; something[6]('World')"
5
>>> testJSaddle $ jsg "something" ## 6 $ ["World"]
5

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 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

create an empty object

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

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).

Make a JavaScript function object that wraps a Haskell function. Calls made to the function will be Asynchronous.

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

Type used for Haskell functions called from JavaScript.

Make an JavaScript array from a list of values

>>> testJSaddle $ eval "['Hello', 'World'][1]"
World
>>> testJSaddle $ array ["Hello", "World"] !! 1
World
>>> testJSaddle $ eval "['Hello', null, undefined, true, 1]"
Hello,,,true,1
>>> testJSaddle $ array ("Hello", JSNull, (), True, 1.0::Double)
Hello,,,true,1

JavaScript's global object

Get a list containing the property names present on a given object >>> testJSaddle $ show . map strToText $ propertyNames obj [] >>> testJSaddle $ show . map strToText $ propertyNames (eval "({x:1, y:2})") ["x","y"]

Get a list containing references to all the properties present on a given object

Call a JavaScript object as function. Consider using #.

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.