Language.Javascript.JSaddle.Value

Deals with JavaScript values. These can be

• null
• undefined
• true | false
• a double precision floating point number
• a string
• an object

JavaScript value references

data JSVal

Instances

Show JSVal

Methods

showsPrec :: Int -> JSVal -> ShowS

show :: JSVal -> String

showList :: [JSVal] -> ShowS

FromJSON JSVal

Methods

parseJSON :: Value -> Parser JSVal

parseJSONList :: Value -> Parser [JSVal]

ToJSON JSVal

Methods

toJSON :: JSVal -> Value

toEncoding :: JSVal -> Encoding

toJSONList :: [JSVal] -> Value

toEncodingList :: [JSVal] -> Encoding

class ToJSVal a where

Anything that can be used to make a JavaScript value reference

Minimal complete definition

toJSVal

Methods

toJSVal :: a -> JSM JSVal

Instances

ToJSVal Object

Methods

toJSVal :: Object -> JSM JSVal

ToJSVal JSValue

Makes a JavaScript value from a JSValue ADT.

Methods

toJSVal :: JSValue -> JSM JSVal

ToJSVal JSNull

Makes a null JavaScript value

Methods

toJSVal :: JSNull -> JSM JSVal

ToJSVal Function

Methods

toJSVal :: Function -> JSM JSVal

Haskell types for JavaScript values

data JSNull

Constructors

JSNull

Type that represents a value that can only be null. Haskell of course has no null so we are adding this type.

Instances

ToJSVal JSNull

Makes a null JavaScript value

Methods

toJSVal :: JSNull -> JSM JSVal

MakeArgs JSNull

Makes an argument list with just a single null JavaScript value

Methods

makeArgs :: JSNull -> JSM [JSVal]

type JSUndefined

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 Bool haskell type. type JSNumber = Double -- ^ A number in JavaScript maps nicely to Double. type JSString = Text -- ^ JavaScript strings can be represented with the Haskell Text type.

data JSString

Instances

Show JSString

Methods

showsPrec :: Int -> JSString -> ShowS

show :: JSString -> String

showList :: [JSString] -> ShowS

FromJSON JSString

Methods

parseJSON :: Value -> Parser JSString

parseJSONList :: Value -> Parser [JSString]

ToJSON JSString

Methods

toJSON :: JSString -> Value

toEncoding :: JSString -> Encoding

toJSONList :: [JSString] -> Value

toEncodingList :: [JSString] -> Encoding

data JSValue

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

Instances

ToJSVal JSValue

Makes a JavaScript value from a JSValue ADT.

Methods

toJSVal :: JSValue -> JSM JSVal

MakeArgs JSValue

Makes an argument list with just a single JavaScript value from a JSValue ADT.

Methods

makeArgs :: JSValue -> JSM [JSVal]

showJSValue :: JSValue -> String

Show a JSValue but just say "object" if the value is a JavaScript object.

Converting JavaScript values

valToBool :: ToJSVal value => value -> JSM Bool

Given a JavaScript value get its boolean value. All values in JavaScript convert to bool.

>>> testJSaddle $ valToBool JSNull
false
>>> testJSaddle $ valToBool ()
false
>>> testJSaddle $ valToBool True
true
>>> testJSaddle $ valToBool False
false
>>> 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

Given a JavaScript value get its numeric value. May throw JSException.

>>> testJSaddle $ show <$> valToNumber JSNull
0.0
>>> testJSaddle $ show <$> valToNumber ()
NaN
>>> testJSaddle $ show <$> valToNumber True
1.0
>>> testJSaddle $ show <$> valToNumber False
0.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

Given a JavaScript value get its string value (as a JavaScript string). May throw JSException.

>>> testJSaddle $ strToText <$> valToStr JSNull
null
>>> testJSaddle $ strToText <$> valToStr ()
undefined
>>> testJSaddle $ strToText <$> valToStr True
true
>>> testJSaddle $ strToText <$> valToStr False
false
>>> testJSaddle $ strToText <$> valToStr (1.0 :: Double)
1
>>> testJSaddle $ strToText <$> valToStr (0.0 :: Double)
0
>>> testJSaddle $ strToText <$> valToStr ""

>>> testJSaddle $ strToText <$> valToStr "1"
1

valToObject :: ToJSVal value => value -> JSM Object

Given a JavaScript value get its object value. May throw JSException.

>>> testJSaddle $ (valToObject JSNull >>= valToText) `catch` \ (JSException e) -> valToText e
null
>>> testJSaddle $ (valToObject () >>= valToText) `catch` \ (JSException e) -> valToText e
undefined
>>> testJSaddle $ valToObject True
true
>>> testJSaddle $ valToObject False
false
>>> testJSaddle $ valToObject (1.0 :: Double)
1
>>> testJSaddle $ valToObject (0.0 :: Double)
0
>>> testJSaddle $ valToObject ""

>>> testJSaddle $ valToObject "1"
1

valToText :: ToJSVal value => value -> JSM Text

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

Given a JavaScript value get a JSON string value. May throw JSException.

>>> testJSaddle $ strToText <$> valToJSON JSNull
null
>>> testJSaddle $ strToText <$> valToJSON ()

>>> testJSaddle $ strToText <$> valToJSON True
true
>>> testJSaddle $ strToText <$> valToJSON False
false
>>> 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)
{}

Make JavaScript values from Haskell ones

val

Arguments

:: ToJSVal value

=> value

value to convert to a JavaScript value

-> JSM JSVal

Convert to a JavaScript value (just an alias for toJSVal)

valNull :: JSVal

A null JavaScript value

valIsNull :: ToJSVal value => value -> JSM Bool

Test a JavaScript value to see if it is null

valUndefined :: JSVal

An undefined JavaScript value

valIsUndefined :: ToJSVal value => value -> JSM Bool

Test a JavaScript value to see if it is undefined

maybeNullOrUndefined :: ToJSVal value => value -> JSM (Maybe JSVal)

Convert a JSVal to a Maybe JSVal (converting null and undefined to Nothing)

maybeNullOrUndefined' :: ToJSVal value => (JSVal -> JSM a) -> value -> JSM (Maybe a)

valBool :: Bool -> JSVal

A JavaScript boolean value

valMakeNumber :: Double -> JSM JSVal

Make a JavaScript number

valMakeString :: JSString -> JSM JSVal

Make a JavaScript string from JSString

Convert to and from JSValue

deRefVal :: ToJSVal value => value -> JSM JSValue

Derefernce a value reference.

>>> testJSaddle $ showJSValue <$> deRefVal JSNull
null
>>> testJSaddle $ showJSValue <$> deRefVal ()
undefined
>>> testJSaddle $ showJSValue <$> deRefVal True
true
>>> testJSaddle $ showJSValue <$> deRefVal False
false
>>> 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

Make a JavaScript value out of a JSValue ADT.

>>> testJSaddle $ valMakeRef ValNull
null
>>> testJSaddle $ valMakeRef ValUndefined
undefined
>>> testJSaddle $ valMakeRef (ValBool True)
true
>>> testJSaddle $ valMakeRef (ValNumber 1)
1
>>> testJSaddle $ valMakeRef (ValString $ T.pack "Hello")
Hello

strictEqual :: (ToJSVal a, ToJSVal b) => a -> b -> JSM Bool

Determine if two values are equal (JavaScripts ===) >>> testJSaddle $ strictEqual True False false >>> testJSaddle $ strictEqual True True true >>> testJSaddle $ strictEqual Hello () false >>> testJSaddle $ strictEqual Hello Hello true

instanceOf :: (ToJSVal value, MakeObject constructor) => value -> constructor -> JSM Bool

Determine if two values are equal (JavaScripts ===) >>> testJSaddle $ instanceOf obj (Object $ jsg Object) true

Orphan instances

MakeObject JSVal

Methods

makeObject :: JSVal -> JSM Object

ToJSString String

Methods

toJSString :: String -> JSString

ToJSString Text

Methods

toJSString :: Text -> JSString

ToJSString JSString

If we already have a JSString we are fine

Methods

toJSString :: JSString -> JSString

ToJSVal Bool

Make a JavaScript boolean value

Methods

toJSVal :: Bool -> JSM JSVal

ToJSVal Double

Makes a JavaScript number

Methods

toJSVal :: Double -> JSM JSVal

ToJSVal Float

Methods

toJSVal :: Float -> JSM JSVal

ToJSVal Int

Methods

toJSVal :: Int -> JSM JSVal

ToJSVal Int32

Methods

toJSVal :: Int32 -> JSM JSVal

ToJSVal Int64

Methods

toJSVal :: Int64 -> JSM JSVal

ToJSVal Word

Methods

toJSVal :: Word -> JSM JSVal

ToJSVal Word32

Methods

toJSVal :: Word32 -> JSM JSVal

ToJSVal Word64

Methods

toJSVal :: Word64 -> JSM JSVal

ToJSVal String

Makes a JavaScript string

Methods

toJSVal :: String -> JSM JSVal

ToJSVal Text

Makes a JavaScript string

Methods

toJSVal :: Text -> JSM JSVal

ToJSVal JSString

Makes a JavaScript string

Methods

toJSVal :: JSString -> JSM JSVal

ToJSVal JSVal

If we already have a JSVal we are fine

Methods

toJSVal :: JSVal -> JSM JSVal

ToJSVal JSUndefined

Makes an undefined JavaScript value

Methods

toJSVal :: JSUndefined -> JSM JSVal

MakeArgs Bool

Makes an argument list with just a single JavaScript boolean value

Methods

makeArgs :: Bool -> JSM [JSVal]

MakeArgs Double

Makes an argument list with just a single JavaScript number

Methods

makeArgs :: Double -> JSM [JSVal]

MakeArgs ()

This allows us to pass no arguments easily (altenative would be to use []::[JSVal]).

Methods

makeArgs :: () -> JSM [JSVal]

MakeArgs Text

Makes an argument list with just a single JavaScript string

Methods

makeArgs :: Text -> JSM [JSVal]

MakeArgs JSVal

A single JSVal can be used as the argument list

Methods

makeArgs :: JSVal -> JSM [JSVal]

ToJSVal a => ToJSVal (Maybe a)

Makes a JSVal or null JavaScript value

Methods

toJSVal :: Maybe a -> JSM JSVal

ToJSVal v => ToJSVal (JSM v)

JSVal can be made by evaluating a function in JSM as long as it returns something we can make into a JSVal.

Methods

toJSVal :: JSM v -> JSM JSVal