0dcf7e1 · jsaddle · git.iko.soy

git.iko.soy/jsaddle

on master help sign in

Use ghcjs-base types. Add maybeNullOrUndefined.

0dcf7e1Hamish Mackenzie11 years ago

src/Language/Javascript/JSaddle/Arguments.hs+43−43

compare with master

unifiedsplit

@@ -13,64 +13,64 @@

13-----------------------------------------------------------------------------

15module Language.Javascript.JSaddle.Arguments (

16− MakeArgRefs(..)

16+ MakeArgs(..)

17) where

19import Language.Javascript.JSaddle.Classes

20− (MakeValueRef(..), MakeValueRef, MakeArgRefs(..), MakeArgRefs)

20+ (MakeVal(..), MakeArgs(..))

21import Language.Javascript.JSaddle.Monad (JSM)

23−instance MakeArgRefs arg => MakeArgRefs (JSM arg) where

23+instance MakeArgs arg => MakeArgs (JSM arg) where

24− makeArgRefs arg = arg >>= makeArgRefs

24+ makeArgs arg = arg >>= makeArgs

25− {-# INLINE makeArgRefs #-}

25+ {-# INLINE makeArgs #-}

27−instance MakeValueRef arg => MakeArgRefs [arg] where

27+instance MakeVal arg => MakeArgs [arg] where

28− makeArgRefs = mapM makeValueRef

28+ makeArgs = mapM makeVal

29− {-# INLINE makeArgRefs #-}

29+ {-# INLINE makeArgs #-}

31−instance (MakeValueRef arg1, MakeValueRef arg2) => MakeArgRefs (arg1, arg2) where

31+instance (MakeVal arg1, MakeVal arg2) => MakeArgs (arg1, arg2) where

32− makeArgRefs (arg1, arg2) = do

32+ makeArgs (arg1, arg2) = do

33− rarg1 <- makeValueRef arg1

33+ rarg1 <- makeVal arg1

34− rarg2 <- makeValueRef arg2

34+ rarg2 <- makeVal arg2

35 return [rarg1, rarg2]

36− {-# INLINE makeArgRefs #-}

36+ {-# INLINE makeArgs #-}

38−instance (MakeValueRef arg1, MakeValueRef arg2, MakeValueRef arg3) => MakeArgRefs (arg1, arg2, arg3) where

38+instance (MakeVal arg1, MakeVal arg2, MakeVal arg3) => MakeArgs (arg1, arg2, arg3) where

39− makeArgRefs (arg1, arg2, arg3) = do

39+ makeArgs (arg1, arg2, arg3) = do

40− rarg1 <- makeValueRef arg1

40+ rarg1 <- makeVal arg1

41− rarg2 <- makeValueRef arg2

41+ rarg2 <- makeVal arg2

42− rarg3 <- makeValueRef arg3

42+ rarg3 <- makeVal arg3

43 return [rarg1, rarg2, rarg3]

44− {-# INLINE makeArgRefs #-}

44+ {-# INLINE makeArgs #-}

46−instance (MakeValueRef arg1, MakeValueRef arg2, MakeValueRef arg3, MakeValueRef arg4) => MakeArgRefs (arg1, arg2, arg3, arg4) where

46+instance (MakeVal arg1, MakeVal arg2, MakeVal arg3, MakeVal arg4) => MakeArgs (arg1, arg2, arg3, arg4) where

47− makeArgRefs (arg1, arg2, arg3, arg4) = do

47+ makeArgs (arg1, arg2, arg3, arg4) = do

48− rarg1 <- makeValueRef arg1

48+ rarg1 <- makeVal arg1

49− rarg2 <- makeValueRef arg2

49+ rarg2 <- makeVal arg2

50− rarg3 <- makeValueRef arg3

50+ rarg3 <- makeVal arg3

51− rarg4 <- makeValueRef arg4

51+ rarg4 <- makeVal arg4

52 return [rarg1, rarg2, rarg3, rarg4]

53− {-# INLINE makeArgRefs #-}

53+ {-# INLINE makeArgs #-}

55−instance (MakeValueRef arg1, MakeValueRef arg2, MakeValueRef arg3, MakeValueRef arg4, MakeValueRef arg5) => MakeArgRefs (arg1, arg2, arg3, arg4, arg5) where

55+instance (MakeVal arg1, MakeVal arg2, MakeVal arg3, MakeVal arg4, MakeVal arg5) => MakeArgs (arg1, arg2, arg3, arg4, arg5) where

56− makeArgRefs (arg1, arg2, arg3, arg4, arg5) = do

56+ makeArgs (arg1, arg2, arg3, arg4, arg5) = do

57− rarg1 <- makeValueRef arg1

57+ rarg1 <- makeVal arg1

58− rarg2 <- makeValueRef arg2

58+ rarg2 <- makeVal arg2

59− rarg3 <- makeValueRef arg3

59+ rarg3 <- makeVal arg3

60− rarg4 <- makeValueRef arg4

60+ rarg4 <- makeVal arg4

61− rarg5 <- makeValueRef arg5

61+ rarg5 <- makeVal arg5

62 return [rarg1, rarg2, rarg3, rarg4, rarg5]

63− {-# INLINE makeArgRefs #-}

63+ {-# INLINE makeArgs #-}

66−instance (MakeValueRef arg1, MakeValueRef arg2, MakeValueRef arg3, MakeValueRef arg4, MakeValueRef arg5, MakeValueRef arg6) => MakeArgRefs (arg1, arg2, arg3, arg4, arg5, arg6) where

66+instance (MakeVal arg1, MakeVal arg2, MakeVal arg3, MakeVal arg4, MakeVal arg5, MakeVal arg6) => MakeArgs (arg1, arg2, arg3, arg4, arg5, arg6) where

67− makeArgRefs (arg1, arg2, arg3, arg4, arg5, arg6) = do

67+ makeArgs (arg1, arg2, arg3, arg4, arg5, arg6) = do

68− rarg1 <- makeValueRef arg1

68+ rarg1 <- makeVal arg1

69− rarg2 <- makeValueRef arg2

69+ rarg2 <- makeVal arg2

70− rarg3 <- makeValueRef arg3

70+ rarg3 <- makeVal arg3

71− rarg4 <- makeValueRef arg4

71+ rarg4 <- makeVal arg4

72− rarg5 <- makeValueRef arg5

72+ rarg5 <- makeVal arg5

73− rarg6 <- makeValueRef arg6

73+ rarg6 <- makeVal arg6

74 return [rarg1, rarg2, rarg3, rarg4, rarg5, rarg6]

75− {-# INLINE makeArgRefs #-}

75+ {-# INLINE makeArgs #-}

src/Language/Javascript/JSaddle/Classes.hs+13−13

@@ -14,34 +14,34 @@

15module Language.Javascript.JSaddle.Classes (

16 -- * Type classes to convert Haskell data to JavaScript

17− MakeValueRef(..)

17+ MakeVal(..)

18− , MakeStringRef(..)

18+ , MakeString(..)

19− , MakeArgRefs(..)

19+ , MakeArgs(..)

20 , MakeObject(..)

21) where

23import Control.Monad.IO.Class (MonadIO)

24import Language.Javascript.JSaddle.Types

25− (Object(..), JSStringRef, JSValueRef)

25+ (Object(..), JSString, JSVal(..))

26import Language.Javascript.JSaddle.Monad (JSM)

28-- | Anything that can be used to make a JavaScript value reference

29−class MakeValueRef a where

29+class MakeVal a where

30− makeValueRef :: a -> JSM JSValueRef

30+ makeVal :: a -> JSM JSVal

32-- | Anything that can be used to make a JavaScript string reference

33−class MakeStringRef a where

33+class MakeString a where

34− makeStringRef :: a -> JSStringRef

34+ makeString :: a -> JSString

36-- | Anything that can be used to make a list of JavaScript value

37-- references for use as function arguments

38−class MakeArgRefs this where

38+class MakeArgs this where

39− makeArgRefs :: this -> JSM [JSValueRef]

39+ makeArgs :: this -> JSM [JSVal]

41-- | Anything that can be used to make a JavaScript object reference

42class MakeObject this where

43 makeObject :: this -> JSM Object

45−instance MakeValueRef Object where

45+instance MakeVal Object where

46− makeValueRef (Object r) = return r

46+ makeVal (Object r) = return r

47− {-# INLINE makeValueRef #-}

47+ {-# INLINE makeVal #-}

src/Language/Javascript/JSaddle/Evaluate.hs+12−12

@@ -24,8 +24,8 @@ module Language.Javascript.JSaddle.Evaluate (

24import Control.Monad.Trans.Reader (ask)

25import Control.Monad.IO.Class (MonadIO(..))

26import Language.Javascript.JSaddle.Types

27− (JSStringRef, JSValueRef, Object(..),

27+ (JSString, JSVal, Object(..),

28− JSValueRefRef)

28+ MutableJSArray)

29#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

30import GHCJS.Types (nullRef)

31import GHCJS.Marshal.Pure (pFromJSVal)

@@ -38,7 +38,7 @@ import Language.Javascript.JSaddle.Exception (rethrow)

38import Language.Javascript.JSaddle.Value ()

39import Language.Javascript.JSaddle.Object ()

40import Language.Javascript.JSaddle.Classes

41− (MakeObject(..), MakeStringRef(..))

41+ (MakeObject(..), MakeString(..))

42import Language.Javascript.JSaddle.Monad (JSM)

44-- | Evaluates a script (like eval in java script). Unlike 'eval' this function lets you

@@ -46,22 +46,22 @@ import Language.Javascript.JSaddle.Monad (JSM)

46--

47-- >>> testJSaddle $ (evaluateScript "\n\n{" global "FileName" 53 >>= valToText) `catch` \(JSException e) -> array (e,e!"sourceURL", e!"line") >>= valToText

48-- SyntaxError: Expected token '}',FileName,55

49−evaluateScript :: (MakeStringRef script, MakeObject this, MakeStringRef url)

49+evaluateScript :: (MakeString script, MakeObject this, MakeString url)

50 => script -- ^ JavaScript to evaluate

51 -> this

52 -> url

53 -> Int -- ^ The Line number of the first line of the script

54− -> JSM JSValueRef

54+ -> JSM JSVal

55#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

56−evaluateScript script this url line = liftIO $ js_eval (makeStringRef script)

56+evaluateScript script this url line = liftIO $ js_eval (makeString script)

57{-# INLINE evaluateScript #-}

58foreign import javascript unsafe "$r = eval($1);"

59− js_eval :: JSStringRef -> IO JSValueRef

59+ js_eval :: JSString -> IO JSVal

60#elif defined(USE_WEBKIT)

61evaluateScript script this url line = do

62 gctxt <- ask

63 (Object thisr) <- makeObject this

64− rethrow $ liftIO . jsevaluatescript gctxt (makeStringRef script) thisr (makeStringRef url) line

64+ rethrow $ liftIO . jsevaluatescript gctxt (makeString script) thisr (makeString url) line

65{-# INLINE evaluateScript #-}

66#else

67evaluateScript = undefined

@@ -71,13 +71,13 @@ evaluateScript = undefined

71--

72-- >>> testJSaddle $ eval "1+1"

73-- 2

74−eval :: MakeStringRef script

74+eval :: MakeString script

75 => script -- ^ JavaScript to evaluate

76− -> JSM JSValueRef

76+ -> JSM JSVal

77#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

78−eval script = evaluateScript script (Object nullRef) (pFromJSVal nullRef::JSStringRef) 1

78+eval script = evaluateScript script (Object nullRef) (pFromJSVal nullRef::JSString) 1

79{-# INLINE eval #-}

80#else

81−eval script = evaluateScript script (Object nullPtr) (nullPtr::JSStringRef) 1

81+eval script = evaluateScript script (Object nullPtr) (nullPtr::JSString) 1

82{-# INLINE eval #-}

83#endif

src/Language/Javascript/JSaddle/Exception.hs+3−3

@@ -18,19 +18,19 @@ module Language.Javascript.JSaddle.Exception (

19import qualified Control.Exception as E (throwIO, Exception)

20import Language.Javascript.JSaddle.Types

21− (JSValueRefRef, JSValueRef)

21+ (MutableJSArray, JSVal)

22import Data.Typeable (Typeable)

23import Language.Javascript.JSaddle.Monad (catchval, JSM)

24import Control.Monad.IO.Class (MonadIO(..))

25import Data.Text (Text)

27−newtype JSException = JSException JSValueRef deriving (Typeable)

27+newtype JSException = JSException JSVal deriving (Typeable)

29instance Show JSException where show _ = "JSException"

30instance E.Exception JSException

32-- | Catch JavaScript exceptions and rethrow Haskell ones

33−rethrow :: (JSValueRefRef -> JSM a) -> JSM a

33+rethrow :: (MutableJSArray -> JSM a) -> JSM a

34rethrow f = f `catchval` \e ->

35 liftIO . E.throwIO $ JSException e

src/Language/Javascript/JSaddle/Monad.hs+3−3

@@ -28,7 +28,7 @@ module Language.Javascript.JSaddle.Monad (

28import Prelude hiding (catch, read)

29import Control.Monad.Trans.Reader (runReaderT, ask, ReaderT(..))

30import Language.Javascript.JSaddle.Types

31− (JSValueRefRef(..), JSValueRef(..), JSContextRef)

31+ (JSVal(..), MutableJSArray(..), JSContextRef)

32import Control.Monad.IO.Class (MonadIO(..))

33#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

34import GHCJS.Types (isUndefined, isNull)

@@ -67,9 +67,9 @@ t `catch` c = do

67 liftIO (runReaderT t r `E.catch` \e -> runReaderT (c e) r)

68{-# INLINE catch #-}

70−-- | Handle JavaScriptCore functions that take a JSValueRefRef in order

70+-- | Handle JavaScriptCore functions that take a MutableJSArray in order

71-- to throw exceptions.

72−catchval :: (JSValueRefRef -> JSM a) -> (JSValueRef -> JSM a) -> JSM a

72+catchval :: (MutableJSArray -> JSM a) -> (JSVal -> JSM a) -> JSM a

73catchval f catcher = do

74#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

75 pexc <- liftIO Array.create

src/Language/Javascript/JSaddle/Object.hs+83−83

@@ -86,8 +86,8 @@ module Language.Javascript.JSaddle.Object (

87import Prelude hiding ((!!))

88import Language.Javascript.JSaddle.Types

89− (JSPropertyNameArrayRef, JSStringRef, Object(..), JSValueRefRef,

89+ (JSPropertyNameArray, JSString, Object(..), MutableJSArray,

90− JSValueRef, JSContextRef, Index)

90+ JSVal, Index)

91import Foreign.C.Types (CSize(..), CULong(..), CUInt(..), CULLong(..))

92#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

93import GHCJS.Types (nullRef, jsval)

@@ -119,7 +119,7 @@ import Language.Javascript.JSaddle.Exception (rethrow)

119import Language.Javascript.JSaddle.Value

120 (JSUndefined, valMakeUndefined, valToObject)

121import Language.Javascript.JSaddle.Classes

122− (MakeValueRef(..), MakeStringRef(..), MakeArgRefs(..), MakeObject(..))

122+ (MakeVal(..), MakeString(..), MakeArgs(..), MakeObject(..))

123import Language.Javascript.JSaddle.Monad

124 (JSM)

125import Control.Monad.Trans.Reader (runReaderT, ask)

@@ -149,15 +149,15 @@ instance MakeObject v => MakeObject (JSM v) where

149-- >>> testJSaddle $ eval "'Hello World'.length"

150-- >>> testJSaddle $ val "Hello World" ! "length"

151-- 11

152−(!) :: (MakeObject this, MakeStringRef name)

152+(!) :: (MakeObject this, MakeString name)

153 => this -- ^ Object to look on

154 -> name -- ^ Name of the property to find

155− -> JSM JSValueRef -- ^ Property reference

155+ -> JSM JSVal -- ^ Property reference

156this ! name = do

157 rthis <- makeObject this

158 rethrow $ objGetPropertyByName rthis rname

159 where

160− rname = makeStringRef name

160+ rname = makeString name

161{-# INLINE (!) #-}

162

163-- | Lookup a property based on its index.

@@ -168,7 +168,7 @@ this ! name = do

168(!!) :: (MakeObject this)

169 => this -- ^ Object to look on

170 -> Index -- ^ Index of the property to lookup

171− -> JSM JSValueRef -- ^ Property reference

171+ -> JSM JSVal -- ^ Property reference

172this !! index = do

173 rthis <- makeObject this

174 rethrow $ objGetPropertyAtIndex rthis index

@@ -181,9 +181,9 @@ this !! index = do

181-- >>> testJSaddle $ eval "'Hello World'.length"

182-- >>> testJSaddle $ val "Hello World" ^. js "length"

183-- 11

184−js :: (MakeObject s, MakeStringRef name)

184+js :: (MakeObject s, MakeString name)

185 => name -- ^ Name of the property to find

186− -> IndexPreservingGetter s (JSM JSValueRef)

186+ -> IndexPreservingGetter s (JSM JSVal)

187js name = to (!name)

188{-# INLINE js #-}

189

@@ -194,7 +194,7 @@ js name = to (!name)

194-- >>> testJSaddle $ eval "'Hello World'.length"

195-- >>> testJSaddle $ val "Hello World" ^. js "length"

196-- 11

197−jss :: (MakeStringRef name, MakeValueRef val)

197+jss :: (MakeString name, MakeVal val)

198 => name -- ^ Name of the property to find

199 -> val

200 -> forall o . MakeObject o => IndexPreservingGetter o (JSM ())

@@ -207,12 +207,12 @@ jss name val = to (\o -> o <# name $ val)

207--

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

209-- 6

210−jsf :: (MakeStringRef name, MakeArgRefs args) => name -> args -> JSF

210+jsf :: (MakeString name, MakeArgs args) => name -> args -> JSF

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

212{-# INLINE jsf #-}

213

214-- | Java script function applications have this type

215−type JSF = forall o . MakeObject o => IndexPreservingGetter o (JSM JSValueRef)

215+type JSF = forall o . MakeObject o => IndexPreservingGetter o (JSM JSVal)

216

217-- | Handy way to call a function that expects no arguments

218--

@@ -220,7 +220,7 @@ type JSF = forall o . MakeObject o => IndexPreservingGetter o (JSM JSValueRef)

220--

221-- >>> testJSaddle $ val "Hello World" ^. js0 "toLowerCase"

222-- hello world

223−js0 :: (MakeStringRef name) => name -> JSF

223+js0 :: (MakeString name) => name -> JSF

224js0 name = jsf name ()

225{-# INLINE js0 #-}

226

@@ -230,31 +230,31 @@ js0 name = jsf name ()

230--

231-- >>> testJSaddle $ val "Hello World" ^. js1 "indexOf" "World"

232-- 6

233−js1 :: (MakeStringRef name, MakeValueRef a0) => name -> a0 -> JSF

233+js1 :: (MakeString name, MakeVal a0) => name -> a0 -> JSF

234js1 name a0 = jsf name [a0]

235{-# INLINE js1 #-}

236

237-- | Handy way to call a function that expects two arguments

238−js2 :: (MakeStringRef name, MakeValueRef a0, MakeValueRef a1) => name -> a0 -> a1 -> JSF

238+js2 :: (MakeString name, MakeVal a0, MakeVal a1) => name -> a0 -> a1 -> JSF

239js2 name a0 a1 = jsf name (a0, a1)

240{-# INLINE js2 #-}

241

242-- | Handy way to call a function that expects three arguments

243−js3 :: (MakeStringRef name, MakeValueRef a0, MakeValueRef a1, MakeValueRef a2)

243+js3 :: (MakeString name, MakeVal a0, MakeVal a1, MakeVal a2)

244 => name -> a0 -> a1 -> a2 -> JSF

245js3 name a0 a1 a2 = jsf name (a0, a1, a2)

246{-# INLINE js3 #-}

247

248-- | Handy way to call a function that expects four arguments

249−js4 :: (MakeStringRef name, MakeValueRef a0, MakeValueRef a1, MakeValueRef a2,

249+js4 :: (MakeString name, MakeVal a0, MakeVal a1, MakeVal a2,

250− MakeValueRef a3)

250+ MakeVal a3)

251 => name -> a0 -> a1 -> a2 -> a3 -> JSF

252js4 name a0 a1 a2 a3 = jsf name (a0, a1, a2, a3)

253{-# INLINE js4 #-}

254

255-- | Handy way to call a function that expects five arguments

256−js5 :: (MakeStringRef name, MakeValueRef a0, MakeValueRef a1, MakeValueRef a2,

256+js5 :: (MakeString name, MakeVal a0, MakeVal a1, MakeVal a2,

257− MakeValueRef a3, MakeValueRef a4)

257+ MakeVal a3, MakeVal a4)

258 => name -> a0 -> a1 -> a2 -> a3 -> a4 -> JSF

259js5 name a0 a1 a2 a3 a4 = jsf name (a0, a1, a2, a3, a4)

260{-# INLINE js5 #-}

@@ -265,7 +265,7 @@ js5 name a0 a1 a2 a3 a4 = jsf name (a0, a1, a2, a3, a4)

265-- >>> testJSaddle $ eval "w = console; w.log('Hello World')"

266-- >>> testJSaddle $ do w <- jsg "console"; w ^. js "log" # ["Hello World"]

267-- 11

268−jsg :: MakeStringRef a => a -> JSM JSValueRef

268+jsg :: MakeString a => a -> JSM JSVal

269jsg name = global ! name

270{-# INLINE jsg #-}

271

@@ -275,7 +275,7 @@ jsg name = global ! name

275--

276-- >>> testJSaddle $ jsf "globalFunc" ["World"]

277-- 6

278−jsgf :: (MakeStringRef name, MakeArgRefs args) => name -> args -> JSM JSValueRef

278+jsgf :: (MakeString name, MakeArgs args) => name -> args -> JSM JSVal

279jsgf name = global # name

280{-# INLINE jsgf #-}

281

@@ -285,7 +285,7 @@ jsgf name = global # name

285--

286-- >>> testJSaddle $ js0 "globalFunc"

287-- hello world

288−jsg0 :: (MakeStringRef name) => name -> JSM JSValueRef

288+jsg0 :: (MakeString name) => name -> JSM JSVal

289jsg0 name = jsgf name ()

290{-# INLINE jsg0 #-}

291

@@ -295,32 +295,32 @@ jsg0 name = jsgf name ()

295--

296-- >>> testJSaddle $ jsg1 "globalFunc" "World"

297-- 6

298−jsg1 :: (MakeStringRef name, MakeValueRef a0) => name -> a0 -> JSM JSValueRef

298+jsg1 :: (MakeString name, MakeVal a0) => name -> a0 -> JSM JSVal

299jsg1 name a0 = jsgf name [a0]

300{-# INLINE jsg1 #-}

301

302-- | Handy way to call a function that expects two arguments

303−jsg2 :: (MakeStringRef name, MakeValueRef a0, MakeValueRef a1) => name -> a0 -> a1 -> JSM JSValueRef

303+jsg2 :: (MakeString name, MakeVal a0, MakeVal a1) => name -> a0 -> a1 -> JSM JSVal

304jsg2 name a0 a1 = jsgf name (a0, a1)

305{-# INLINE jsg2 #-}

306

307-- | Handy way to call a function that expects three arguments

308−jsg3 :: (MakeStringRef name, MakeValueRef a0, MakeValueRef a1, MakeValueRef a2)

308+jsg3 :: (MakeString name, MakeVal a0, MakeVal a1, MakeVal a2)

309− => name -> a0 -> a1 -> a2 -> JSM JSValueRef

309+ => name -> a0 -> a1 -> a2 -> JSM JSVal

310jsg3 name a0 a1 a2 = jsgf name (a0, a1, a2)

311{-# INLINE jsg3 #-}

312

313-- | Handy way to call a function that expects four arguments

314−jsg4 :: (MakeStringRef name, MakeValueRef a0, MakeValueRef a1, MakeValueRef a2,

314+jsg4 :: (MakeString name, MakeVal a0, MakeVal a1, MakeVal a2,

315− MakeValueRef a3)

315+ MakeVal a3)

316− => name -> a0 -> a1 -> a2 -> a3 -> JSM JSValueRef

316+ => name -> a0 -> a1 -> a2 -> a3 -> JSM JSVal

317jsg4 name a0 a1 a2 a3 = jsgf name (a0, a1, a2, a3)

318{-# INLINE jsg4 #-}

319

320-- | Handy way to call a function that expects five arguments

321−jsg5 :: (MakeStringRef name, MakeValueRef a0, MakeValueRef a1, MakeValueRef a2,

321+jsg5 :: (MakeString name, MakeVal a0, MakeVal a1, MakeVal a2,

322− MakeValueRef a3, MakeValueRef a4)

322+ MakeVal a3, MakeVal a4)

323− => name -> a0 -> a1 -> a2 -> a3 -> a4 -> JSM JSValueRef

323+ => name -> a0 -> a1 -> a2 -> a3 -> a4 -> JSM JSVal

324jsg5 name a0 a1 a2 a3 a4 = jsgf name (a0, a1, a2, a3, a4)

325{-# INLINE jsg5 #-}

326

@@ -330,8 +330,8 @@ jsg5 name a0 a1 a2 a3 a4 = jsgf name (a0, a1, a2, a3, a4)

330-- >>> testJSaddle $ val "Hello World" # "indexOf" $ ["World"]

331-- 6

332infixr 2 #

333−(#) :: (MakeObject this, MakeStringRef name, MakeArgRefs args)

333+(#) :: (MakeObject this, MakeString name, MakeArgs args)

334− => this -> name -> args -> JSM JSValueRef

334+ => this -> name -> args -> JSM JSVal

335(#) this name args = do

336 rthis <- makeObject this

337 f <- rethrow $ objGetPropertyByName rthis name

@@ -344,8 +344,8 @@ infixr 2 #

344-- >>> testJSaddle $ eval "something[6]('World')"

345-- >>> testJSaddle $ val something ## 6 ["World"]

346infixr 2 ##

347−(##) :: (MakeObject this, MakeArgRefs args)

347+(##) :: (MakeObject this, MakeArgs args)

348− => this -> Index -> args -> JSM JSValueRef

348+ => this -> Index -> args -> JSM JSVal

349(##) this index args = do

350 rthis <- makeObject this

351 f <- rethrow $ objGetPropertyAtIndex rthis index

@@ -359,7 +359,7 @@ infixr 2 ##

359-- >>> testJSaddle $ do {j <- eval "({})"; j <# "x" 1; j!"x"}

360-- 1

361infixr 1 <#

362−(<#) :: (MakeObject this, MakeStringRef name, MakeValueRef val)

362+(<#) :: (MakeObject this, MakeString name, MakeVal val)

363 => this -- ^ Object to set the property on

364 -> name -- ^ Name of the property to set

365 -> val -- ^ Value to set it to

@@ -375,7 +375,7 @@ infixr 1 <#

375-- >>> testJSaddle $ do {j <- eval "({})"; j <## 6 1; j!!6}

376-- 1

377infixr 1 <##

378−(<##) :: (MakeObject this, MakeValueRef val)

378+(<##) :: (MakeObject this, MakeVal val)

379 => this -- ^ Object to set the property on

380 -> Index -- ^ Index of the property to set

381 -> val -- ^ Value to set it to

@@ -392,10 +392,10 @@ infixr 1 <##

392--

393-- >>> testJSaddle $ new "Date" (2013, 1, 1)

394-- Fri Feb 01 2013 00:00:00 GMT+1300 (NZDT)

395−new :: (MakeObject constructor, MakeArgRefs args)

395+new :: (MakeObject constructor, MakeArgs args)

396 => constructor

397 -> args

398− -> JSM JSValueRef

398+ -> JSM JSVal

399new constructor args = do

400 f <- makeObject constructor

401 rethrow $ objCallAsConstructor f args

@@ -406,8 +406,8 @@ new constructor args = do

406-- >>> testJSaddle $ eval "(function(){return this;}).apply('Hello', [])"

407-- >>> testJSaddle $ do { test <- eval "(function(){return this;})"; call test (val "Hello") () }

408-- Hello

409−call :: (MakeObject function, MakeObject this, MakeArgRefs args)

409+call :: (MakeObject function, MakeObject this, MakeArgs args)

410− => function -> this -> args -> JSM JSValueRef

410+ => function -> this -> args -> JSM JSVal

411call function this args = do

412 rfunction <- makeObject function

413 rthis <- makeObject this

@@ -430,9 +430,9 @@ obj = do

430{-# INLINE obj #-}

431

432-- | Type used for Haskell functions called from JavaScript.

433−type JSCallAsFunction = JSValueRef -- ^ Function object

433+type JSCallAsFunction = JSVal -- ^ Function object

434− -> JSValueRef -- ^ this

434+ -> JSVal -- ^ this

435− -> [JSValueRef] -- ^ Function arguments

435+ -> [JSVal] -- ^ Function arguments

436 -> JSM JSUndefined -- ^ Only 'JSUndefined' can be returned because

437 -- the function may need to be executed in a

438 -- different thread. If you need to get a

@@ -456,7 +456,7 @@ foreign import ccall "wrapper"

456#endif

457

458-- ^ Make a JavaScript function object that wraps a Haskell function.

459−function :: MakeStringRef name

459+function :: MakeString name

460 => name -- ^ Name of the function

461 -> JSCallAsFunction -- ^ Haskell function to call

462 -> JSM Object -- ^ Returns a JavaScript function object that will

@@ -466,21 +466,21 @@ function name f = liftIO $ do

466 callback <- syncCallback2 ContinueAsync $ \this args -> do

467 rargs <- Array.toListIO (coerce args)

468 runReaderT (f this this rargs) () -- TODO pass function object through

469− makeFunctionWithCallback (makeStringRef name) callback

469+ makeFunctionWithCallback (makeString name) callback

470foreign import javascript unsafe "$r = function () { $2(this, arguments); }"

471− makeFunctionWithCallback :: JSStringRef -> Callback (JSValueRef -> JSValueRef -> IO ()) -> IO Object

471+ makeFunctionWithCallback :: JSString -> Callback (JSVal -> JSVal -> IO ()) -> IO Object

472#elif defined(USE_WEBKIT)

473function name f = do

474 gctxt <- ask

475 callback <- liftIO $ mkJSObjectCallAsFunctionCallback wrap

476− liftIO $ Object <$> jsobjectmakefunctionwithcallback gctxt (makeStringRef name) callback

476+ liftIO $ Object <$> jsobjectmakefunctionwithcallback gctxt (makeString name) callback

477 where

478 wrap ctx fobj this argc argv exception = do

479 args <- peekArray (fromIntegral argc) argv

480 (`runReaderT` ctx) $

481− f fobj this args >>= makeValueRef

481+ f fobj this args >>= makeVal

482 `E.catch` \(e :: SomeException) -> do

483− str <- runReaderT (makeValueRef . T.pack $ show e) ctx

483+ str <- runReaderT (makeVal . T.pack $ show e) ctx

484 poke exception str

485 jsvaluemakeundefined ctx

486#else

@@ -490,33 +490,33 @@ function = undefined

490-- | A callback to Haskell can be used as a JavaScript value. This will create

491-- an anonymous JavaScript function object. Use 'function' to create one with

492-- a name.

493−instance MakeValueRef JSCallAsFunction where

493+instance MakeVal JSCallAsFunction where

494#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

495− makeValueRef f = jsval <$> function (pFromJSVal nullRef :: JSStringRef) f

495+ makeVal f = jsval <$> function (pFromJSVal nullRef :: JSString) f

496#else

497− makeValueRef f = function (nullPtr :: JSStringRef) f >>= makeValueRef

497+ makeVal f = function (nullPtr :: JSString) f >>= makeVal

498#endif

499− {-# INLINE makeValueRef #-}

499+ {-# INLINE makeVal #-}

500

501−instance MakeArgRefs JSCallAsFunction where

501+instance MakeArgs JSCallAsFunction where

502− makeArgRefs f = do

502+ makeArgs f = do

503#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

504− rarg <- jsval <$> function (pFromJSVal nullRef :: JSStringRef) f

504+ rarg <- jsval <$> function (pFromJSVal nullRef :: JSString) f

505#else

506− rarg <- function (nullPtr:: JSStringRef) f >>= makeValueRef

506+ rarg <- function (nullPtr:: JSString) f >>= makeVal

507#endif

508 return [rarg]

509− {-# INLINE makeArgRefs #-}

509+ {-# INLINE makeArgs #-}

510

511−makeArray :: MakeArgRefs args => args -> JSValueRefRef -> JSM Object

511+makeArray :: MakeArgs args => args -> MutableJSArray -> JSM Object

512#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

513makeArray args exceptions = do

514− rargs <- makeArgRefs args

514+ rargs <- makeArgs args

515 liftIO $ Object . jsval <$> Array.fromListIO rargs

516#else

517makeArray args exceptions = do

518 gctxt <- ask

519− rargs <- makeArgRefs args

519+ rargs <- makeArgs args

520 liftIO $ withArrayLen rargs $ \ len ptr ->

521 Object <$> jsobjectmakearray gctxt (fromIntegral len) ptr exceptions

522#endif

@@ -530,7 +530,7 @@ makeArray args exceptions = do

530-- >>> testJSaddle $ eval "['Hello', null, undefined, true, 1]"

531-- >>> testJSaddle $ array ("Hello", JSNull, (), True, 1.0::Double)

532-- Hello,,,true,1

533−array :: MakeArgRefs args => args -> JSM Object

533+array :: MakeArgs args => args -> JSM Object

534array = rethrow . makeArray

535

536-- | JavaScript's global object

@@ -549,7 +549,7 @@ global = undefined

549

550-- | Get an array containing the property names present on a given object

551#if (!defined(ghcjs_HOST_OS) || !defined(USE_JAVASCRIPTFFI)) && defined(USE_WEBKIT)

552−copyPropertyNames :: MakeObject this => this -> JSM JSPropertyNameArrayRef

552+copyPropertyNames :: MakeObject this => this -> JSM JSPropertyNameArray

553copyPropertyNames this = do

554 gctxt <- ask

555 Object rthis <- makeObject this

@@ -557,17 +557,17 @@ copyPropertyNames this = do

557{-# INLINE copyPropertyNames #-}

558

559-- | Get the number of names in a property name array

560−propertyNamesCount :: MonadIO m => JSPropertyNameArrayRef -> m CSize

560+propertyNamesCount :: MonadIO m => JSPropertyNameArray -> m CSize

561propertyNamesCount names = liftIO $ jspropertynamearraygetcount names

562{-# INLINE propertyNamesCount #-}

563

564-- | Get a name out of a property name array

565−propertyNamesAt :: MonadIO m => JSPropertyNameArrayRef -> CSize -> m JSStringRef

565+propertyNamesAt :: MonadIO m => JSPropertyNameArray -> CSize -> m JSString

566propertyNamesAt names index = liftIO $ jspropertynamearraygetnameatindex names index

567{-# INLINE propertyNamesAt #-}

568

569-- | Convert property array to a list

570−propertyNamesList :: MonadIO m => JSPropertyNameArrayRef -> m [JSStringRef]

570+propertyNamesList :: MonadIO m => JSPropertyNameArray -> m [JSString]

571propertyNamesList names = do

572 count <- propertyNamesCount names

573 mapM (propertyNamesAt names) $ enumFromTo 0 (count - 1)

@@ -575,7 +575,7 @@ propertyNamesList names = do

575#endif

576

577-- | Get a list containing the property names present on a given object

578−propertyNames :: MakeObject this => this -> JSM [JSStringRef]

578+propertyNames :: MakeObject this => this -> JSM [JSString]

579#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

580propertyNames this = makeObject this >>= liftIO . js_propertyNames >>= liftIO . (fmap (map pFromJSVal)) . Array.toListIO

581{-# INLINE propertyNames #-}

@@ -589,27 +589,27 @@ propertyNames = undefined

589#endif

590

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

592−properties :: MakeObject this => this -> JSM [JSValueRef]

592+properties :: MakeObject this => this -> JSM [JSVal]

593properties this = propertyNames this >>= mapM (this !)

594

595-- | Call a JavaScript object as function. Consider using '#'.

596−objCallAsFunction :: MakeArgRefs args

596+objCallAsFunction :: MakeArgs args

597 => Object

598 -> Object

599 -> args

600− -> JSValueRefRef

600+ -> MutableJSArray

601− -> JSM JSValueRef

601+ -> JSM JSVal

602#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

603objCallAsFunction function this args exceptions = do

604− rargs <- makeArgRefs args >>= liftIO . Array.fromListIO

604+ rargs <- makeArgs args >>= liftIO . Array.fromListIO

605 liftIO $ js_apply function this rargs exceptions

606{-# INLINE objCallAsFunction #-}

607foreign import javascript unsafe "try { $r = $1.apply($2, $3) } catch(e) { $4[0] = e }"

608− js_apply :: Object -> Object -> JSValueRefRef -> JSValueRefRef -> IO JSValueRef

608+ js_apply :: Object -> Object -> MutableJSArray -> MutableJSArray -> IO JSVal

609#elif defined(USE_WEBKIT)

610objCallAsFunction (Object function) (Object this) args exceptions = do

611 gctxt <- ask

612− rargs <- makeArgRefs args

612+ rargs <- makeArgs args

613 liftIO $ withArrayLen rargs $ \ largs pargs ->

614 jsobjectcallasfunction gctxt function this (fromIntegral largs) pargs exceptions

615{-# INLINE objCallAsFunction #-}

@@ -621,14 +621,14 @@ objCallAsFunction = undefined

621--

622-- If you pass more than 7 arguments to a constructor for a built in

623-- JavaScript type (like Date) then this function will fail.

624−objCallAsConstructor :: MakeArgRefs args

624+objCallAsConstructor :: MakeArgs args

625 => Object

626 -> args

627− -> JSValueRefRef

627+ -> MutableJSArray

628− -> JSM JSValueRef

628+ -> JSM JSVal

629#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

630objCallAsConstructor function args exceptions = do

631− rargs <- makeArgRefs args >>= liftIO . Array.fromListIO

631+ rargs <- makeArgs args >>= liftIO . Array.fromListIO

632 liftIO $ js_new function rargs exceptions

633foreign import javascript unsafe "\

634 try {\

@@ -657,11 +657,11 @@ foreign import javascript unsafe "\

657 catch(e) {\

658 $3[0] = e;\

659 }"

660− js_new :: Object -> JSValueRefRef -> JSValueRefRef -> IO JSValueRef

660+ js_new :: Object -> MutableJSArray -> MutableJSArray -> IO JSVal

661#elif defined(USE_WEBKIT)

662objCallAsConstructor (Object function) args exceptions = do

663 gctxt <- ask

664− rargs <- makeArgRefs args

664+ rargs <- makeArgs args

665 liftIO $ withArrayLen rargs $ \ largs pargs ->

666 jsobjectcallasconstructor gctxt function (fromIntegral largs) pargs exceptions

667#else

src/Language/Javascript/JSaddle/Properties.hs+26−26

@@ -31,12 +31,12 @@ module Language.Javascript.JSaddle.Properties (

32import Control.Applicative ((<$>))

33import Language.Javascript.JSaddle.Classes

34− (MakeObject(..), MakeValueRef(..),

34+ (MakeObject(..), MakeVal(..),

35− MakeArgRefs(..), MakeStringRef(..))

35+ MakeArgs(..), MakeString(..))

36import Language.Javascript.JSaddle.Monad (JSM)

37import Language.Javascript.JSaddle.Types

38− (JSValueRefRef, Object(..), JSPropertyAttributes,

38+ (MutableJSArray, Object(..), JSPropertyAttributes,

39− Index(..), JSStringRef)

39+ Index(..), JSString)

40#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

41#else

42import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSObjectRef

@@ -47,25 +47,25 @@ import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSObjectRef

47import Control.Monad.Trans.Reader (ask)

48import Control.Monad.IO.Class (MonadIO(..))

49import Language.Javascript.JSaddle.Exception (rethrow)

50−import Language.Javascript.JSaddle.Value (JSValueRef)

50+import Language.Javascript.JSaddle.Value (JSVal)

51import Language.Javascript.JSaddle.Arguments ()

52import Language.Javascript.JSaddle.String ()

54-- | Get a property value given the object and the name of the property.

55−objGetPropertyByName :: MakeStringRef name

55+objGetPropertyByName :: MakeString name

56 => Object -- ^ object to find the property on.

57 -> name -- ^ name of the property.

58− -> JSValueRefRef -- ^ exception if one is raised.

58+ -> MutableJSArray -- ^ exception if one is raised.

59− -> JSM JSValueRef -- ^ returns the property value.

59+ -> JSM JSVal -- ^ returns the property value.

60#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

61−objGetPropertyByName this name = liftIO . js_tryGetProp (makeStringRef name) this

61+objGetPropertyByName this name = liftIO . js_tryGetProp (makeString name) this

62{-# INLINE objGetPropertyByName #-}

63foreign import javascript unsafe "try { $r=$2[$1] } catch(e) { $3[0] = e }"

64− js_tryGetProp :: JSStringRef -> Object -> JSValueRefRef -> IO JSValueRef

64+ js_tryGetProp :: JSString -> Object -> MutableJSArray -> IO JSVal

65#elif defined(USE_WEBKIT)

66objGetPropertyByName (Object this) name exceptions = do

67 gctxt <- ask

68− liftIO $ jsobjectgetproperty gctxt this (makeStringRef name) exceptions

68+ liftIO $ jsobjectgetproperty gctxt this (makeString name) exceptions

69{-# INLINE objGetPropertyByName #-}

70#else

71objGetPropertyByName = undefined

@@ -74,13 +74,13 @@ objGetPropertyByName = undefined

74-- | Get a property value given the object and the index of the property.

75objGetPropertyAtIndex :: Object -- ^ object to find the property on.

76 -> Index -- ^ index of the property.

77− -> JSValueRefRef -- ^ exception if one is raised.

77+ -> MutableJSArray -- ^ exception if one is raised.

78− -> JSM JSValueRef -- ^ returns the property value.

78+ -> JSM JSVal -- ^ returns the property value.

79#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

80objGetPropertyAtIndex this index = liftIO . js_tryIndex index this

81{-# INLINE objGetPropertyAtIndex #-}

82foreign import javascript unsafe "try { $r=$2[$1] } catch(e) { $3[0] = e }"

83− js_tryIndex :: Index -> Object -> JSValueRefRef -> IO JSValueRef

83+ js_tryIndex :: Index -> Object -> MutableJSArray -> IO JSVal

84#elif defined(USE_WEBKIT)

85objGetPropertyAtIndex (Object this) index exceptions = do

86 gctxt <- ask

@@ -91,48 +91,48 @@ objGetPropertyAtIndex = undefined

91#endif

93-- | Set a property value given the object and the name of the property.

94−objSetPropertyByName :: (MakeStringRef name, MakeValueRef val)

94+objSetPropertyByName :: (MakeString name, MakeVal val)

95 => Object -- ^ object to set the property on.

96 -> name -- ^ name of the property.

97 -> val -- ^ new value to set the property to.

98 -> JSPropertyAttributes -- ^ property attributes to give the property.

99− -> JSValueRefRef -- ^ exception if one is raised.

99+ -> MutableJSArray -- ^ exception if one is raised.

100 -> JSM ()

101#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

102objSetPropertyByName this name val attributes exceptions = do

103− vref <- makeValueRef val

103+ vref <- makeVal val

104− liftIO $ js_trySetProp (makeStringRef name) this vref exceptions

104+ liftIO $ js_trySetProp (makeString name) this vref exceptions

105{-# INLINE objSetPropertyByName #-}

106foreign import javascript unsafe "try { $2[$1]=$3 } catch(e) { $4[0] = e }"

107− js_trySetProp :: JSStringRef -> Object -> JSValueRef -> JSValueRefRef -> IO ()

107+ js_trySetProp :: JSString -> Object -> JSVal -> MutableJSArray -> IO ()

108#elif defined(USE_WEBKIT)

109objSetPropertyByName (Object this) name val attributes exceptions = do

110 gctxt <- ask

111− vref <- makeValueRef val

111+ vref <- makeVal val

112− liftIO $ jsobjectsetproperty gctxt this (makeStringRef name) vref attributes exceptions

112+ liftIO $ jsobjectsetproperty gctxt this (makeString name) vref attributes exceptions

113{-# INLINE objSetPropertyByName #-}

114#else

115objSetPropertyByName = undefined

116#endif

117

118-- | Set a property value given the object and the index of the property.

119−objSetPropertyAtIndex :: (MakeValueRef val)

119+objSetPropertyAtIndex :: (MakeVal val)

120 => Object -- ^ object to find property on.

121 -> Index -- ^ index of the property.

122 -> val -- ^ new value to set the property to.

123− -> JSValueRefRef -- ^ exception if one is raised.

123+ -> MutableJSArray -- ^ exception if one is raised.

124 -> JSM ()

125#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

126objSetPropertyAtIndex this index val exceptions = do

127− vref <- makeValueRef val

127+ vref <- makeVal val

128 liftIO $ js_trySetAtIndex index this vref exceptions

129{-# INLINE objSetPropertyAtIndex #-}

130foreign import javascript unsafe "try { $2[$1]=$3 } catch(e) { $4[0] = e }"

131− js_trySetAtIndex :: Index -> Object -> JSValueRef -> JSValueRefRef -> IO ()

131+ js_trySetAtIndex :: Index -> Object -> JSVal -> MutableJSArray -> IO ()

132#elif defined(USE_WEBKIT)

133objSetPropertyAtIndex (Object this) index val exceptions = do

134 gctxt <- ask

135− vref <- makeValueRef val

135+ vref <- makeVal val

136 liftIO $ jsobjectsetpropertyatindex gctxt this index vref exceptions

137{-# INLINE objSetPropertyAtIndex #-}

138#else

src/Language/Javascript/JSaddle/String.hs+15−15

@@ -14,8 +14,8 @@

14-----------------------------------------------------------------------------

16module Language.Javascript.JSaddle.String (

17− JSStringRef

17+ JSString

18− , MakeStringRef(..)

18+ , MakeString(..)

20 -- * Data.Text helpers

21 , strToText

@@ -25,7 +25,7 @@ module Language.Javascript.JSaddle.String (

25import Data.Text (Text)

26import qualified Data.Text as T (unpack, pack)

27import Control.Monad.IO.Class (MonadIO(..))

28−import Language.Javascript.JSaddle.Types (JSStringRef)

28+import Language.Javascript.JSaddle.Types (JSString)

29#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

30import Data.JSString.Text (textFromJSString, textToJSString)

31#else

@@ -36,24 +36,24 @@ import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSStringRef

36import qualified Data.Text.Foreign as T (fromPtr)

37import Foreign (castPtr)

38import Data.Text.Foreign (useAsPtr)

39−import Language.Javascript.JSaddle.Classes (MakeStringRef(..))

39+import Language.Javascript.JSaddle.Classes (MakeString(..))

40import System.IO.Unsafe (unsafePerformIO)

42-- | If we already have a JSStringRef we are fine

43−instance MakeStringRef JSStringRef where

43+instance MakeString JSString where

44− makeStringRef = id

44+ makeString = id

45− {-# INLINE makeStringRef #-}

45+ {-# INLINE makeString #-}

47−instance MakeStringRef Text where

47+instance MakeString Text where

48− makeStringRef = textToStr

48+ makeString = textToStr

49− {-# INLINE makeStringRef #-}

49+ {-# INLINE makeString #-}

51−instance MakeStringRef String where

51+instance MakeString String where

52− makeStringRef = textToStr . T.pack

52+ makeString = textToStr . T.pack

53− {-# INLINE makeStringRef #-}

53+ {-# INLINE makeString #-}

55-- | Convert a JavaScript string to a Haskell 'Text'

56−strToText :: MonadIO m => JSStringRef -> m Text

56+strToText :: MonadIO m => JSString -> m Text

57#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

58strToText = return . textFromJSString

59#else

@@ -65,7 +65,7 @@ strToText jsstring = liftIO $ do

65{-# INLINE strToText #-}

67-- | Convert a Haskell 'Text' to a JavaScript string

68−textToStr :: Text -> JSStringRef

68+textToStr :: Text -> JSString

69#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

70textToStr = textToJSString

71#else

src/Language/Javascript/JSaddle/Types.hs+9−8

@@ -13,13 +13,13 @@

13-----------------------------------------------------------------------------

15module Language.Javascript.JSaddle.Types (

16− JSValueRef(..)

16+ JSVal(..)

17− , JSValueRefRef(..)

17+ , MutableJSArray(..)

18 , Object(..)

19− , JSPropertyNameArrayRef(..)

19+ , JSPropertyNameArray(..)

20 , JSPropertyAttributes(..)

21 , JSContextRef(..)

22− , JSStringRef(..)

22+ , JSString(..)

23 , Index(..)

24) where

@@ -37,14 +37,15 @@ import Foreign.C (CUInt(..))

37#endif

39#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

40−type JSValueRef = JSVal

41−type JSValueRefRef = MutableJSArray

42−newtype JSPropertyNameArrayRef = JSPropertyNameArrayRef { unJSPropertyNameArrayRef :: JSVal }

40+newtype JSPropertyNameArray = JSPropertyNameArray { unJSPropertyNameArrayRef :: JSVal }

43type JSPropertyAttributes = Word

41type JSPropertyAttributes = Word

44type JSContextRef = ()

42type JSContextRef = ()

45−type JSStringRef = JSString

46type Index = Int

43type Index = Int

47#else

44#else

45+type JSVal = JSValueRef

46+type MutableJSArray = JSValueRefRef

47+type JSPropertyNameArray = JSPropertyNameArrayRef

48type Index = CUInt

49newtype Object = Object JSObjectRef

50+type JSString = JSStringRef

50#endif

51#endif

src/Language/Javascript/JSaddle/Value.hs+147−108

@@ -2,6 +2,7 @@

2{-# LANGUAGE ScopedTypeVariables #-}

3{-# LANGUAGE FlexibleInstances #-}

4{-# LANGUAGE TypeSynonymInstances #-}

5+{-# LANGUAGE LambdaCase #-}

5#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

6#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

6{-# LANGUAGE ForeignFunctionInterface, JavaScriptFFI #-}

7{-# LANGUAGE ForeignFunctionInterface, JavaScriptFFI #-}

7#endif

8#endif

@@ -31,14 +32,12 @@

32module Language.Javascript.JSaddle.Value (

33module Language.Javascript.JSaddle.Value (

33 -- * JavaScript value references

34 -- * JavaScript value references

34− JSValueRef

35+ JSVal

35− , MakeValueRef(..)

36+ , MakeVal(..)

37 -- * Haskell types for JavaScript values

38 -- * Haskell types for JavaScript values

38 , JSNull(..)

39 , JSNull(..)

39 , JSUndefined(..)

40 , JSUndefined(..)

40− , JSBool(..)

41− , JSNumber(..)

42 , JSString(..)

41 , JSString(..)

43 , JSValue(..)

42 , JSValue(..)

@@ -53,7 +52,10 @@ module Language.Javascript.JSaddle.Value (

53 -- * Make JavaScript values from Haskell ones

52 -- * Make JavaScript values from Haskell ones

54 , val

53 , val

55 , valMakeNull

54 , valMakeNull

55+ , valIsNull

56 , valMakeUndefined

57+ , valIsUndefined

58+ , maybeNullOrUndefined

57 , valMakeBool

59 , valMakeBool

58 , valMakeNumber

60 , valMakeNumber

59 , valMakeString

61 , valMakeString

@@ -65,9 +67,9 @@ module Language.Javascript.JSaddle.Value (

66import Prelude hiding (catch)

68import Prelude hiding (catch)

67import Language.Javascript.JSaddle.Types

69import Language.Javascript.JSaddle.Types

68− (JSValueRefRef, Object(..), JSStringRef, JSValueRef(..))

70+ (MutableJSArray, Object(..), JSString, JSVal(..))

69#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

71#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

70−import GHCJS.Types (JSVal(..))

72+import GHCJS.Types (JSVal(..), isNull, isUndefined)

71import GHCJS.Foreign (toJSBool, isTruthy, jsNull, jsUndefined)

73import GHCJS.Foreign (toJSBool, isTruthy, jsNull, jsUndefined)

72import GHCJS.Marshal (toJSVal)

74import GHCJS.Marshal (toJSVal)

73import GHCJS.Marshal.Pure (pToJSVal)

75import GHCJS.Marshal.Pure (pToJSVal)

@@ -77,9 +79,11 @@ import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSValueRef

77 (jsvaluecreatejsonstring, JSType(..), jsvaluegettype,

79 (jsvaluecreatejsonstring, JSType(..), jsvaluegettype,

78 jsvaluemakestring, jsvaluemakenumber, jsvaluemakeboolean,

80 jsvaluemakestring, jsvaluemakenumber, jsvaluemakeboolean,

79 jsvaluemakeundefined, jsvaluemakenull, jsvaluetoobject,

81 jsvaluemakeundefined, jsvaluemakenull, jsvaluetoobject,

80− jsvaluetostringcopy, jsvaluetonumber, jsvaluetoboolean)

82+ jsvaluetostringcopy, jsvaluetonumber, jsvaluetoboolean,

83+ jsvalueisnull, jsvalueisundefined)

81−import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSStringRef

84+import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSString

82 (jsstringgetcharactersptr, jsstringgetlength)

85 (jsstringgetcharactersptr, jsstringgetlength)

86+import System.IO.Unsafe (unsafePerformIO)

83#endif

87#endif

84import Language.Javascript.JSaddle.Monad (JSM, catchval)

88import Language.Javascript.JSaddle.Monad (JSM, catchval)

85import Language.Javascript.JSaddle.Exception (rethrow)

89import Language.Javascript.JSaddle.Exception (rethrow)

@@ -92,8 +96,8 @@ import Control.Applicative ((<$>))

92import Data.Text (Text)

96import Data.Text (Text)

93import qualified Data.Text as T (pack)

97import qualified Data.Text as T (pack)

94import Language.Javascript.JSaddle.Classes

98import Language.Javascript.JSaddle.Classes

95− (MakeObject(..), MakeStringRef(..), MakeValueRef(..),

99+ (MakeObject(..), MakeString(..), MakeVal(..),

96− MakeArgRefs(..))

100+ MakeArgs(..))

97import Language.Javascript.JSaddle.String (strToText, textToStr)

101import Language.Javascript.JSaddle.String (strToText, textToStr)

98import Language.Javascript.JSaddle.Arguments ()

102import Language.Javascript.JSaddle.Arguments ()

99import Data.Word (Word)

103import Data.Word (Word)

@@ -103,17 +107,17 @@ data JSNull = JSNull -- ^ Type that represents a value that can only be nul

103type JSUndefined = () -- ^ A type that can only be undefined in JavaScript. Using ()

107type JSUndefined = () -- ^ A type that can only be undefined in JavaScript. Using ()

104 -- because functions in JavaScript that have no return, impicitly

108 -- because functions in JavaScript that have no return, impicitly

105 -- return undefined.

109 -- return undefined.

106−type JSBool = Bool -- ^ JavaScript boolean values map the 'Bool' haskell type.

110+-- type JSBool = Bool -- ^ JavaScript boolean values map the 'Bool' haskell type.

107−type JSNumber = Double -- ^ A number in JavaScript maps nicely to 'Double'.

111+-- type JSNumber = Double -- ^ A number in JavaScript maps nicely to 'Double'.

108−type JSString = Text -- ^ JavaScript strings can be represented with the Haskell 'Text' type.

112+-- type JSString = Text -- ^ JavaScript strings can be represented with the Haskell 'Text' type.

109

113

110-- | An algebraic data type that can represent a JavaScript value. Any JavaScriptCore

114-- | An algebraic data type that can represent a JavaScript value. Any JavaScriptCore

111−-- 'JSValueRef' can be converted into this type.

115+-- 'JSVal' can be converted into this type.

112data JSValue = ValNull -- ^ null

116data JSValue = ValNull -- ^ null

113 | ValUndefined -- ^ undefined

117 | ValUndefined -- ^ undefined

114− | ValBool JSBool -- ^ true or false

118+ | ValBool Bool -- ^ true or false

115− | ValNumber JSNumber -- ^ a number

119+ | ValNumber Double -- ^ a number

116− | ValString JSString -- ^ a string

120+ | ValString Text -- ^ a string

117 | ValObject Object -- ^ an object

121 | ValObject Object -- ^ an object

118-- deriving(Show, Eq)

122-- deriving(Show, Eq)

119

123

@@ -136,13 +140,13 @@ data JSValue = ValNull -- ^ null

136-- false

140-- false

137-- >>> testJSaddle $ valToBool "1"

141-- >>> testJSaddle $ valToBool "1"

138-- true

142-- true

139−valToBool :: MakeValueRef val => val -> JSM JSBool

143+valToBool :: MakeVal val => val -> JSM Bool

140#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

144#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

141−valToBool val = isTruthy <$> makeValueRef val

145+valToBool val = isTruthy <$> makeVal val

142#else

146#else

143valToBool val = do

147valToBool val = do

144 gctxt <- ask

148 gctxt <- ask

145− rval <- makeValueRef val

149+ rval <- makeVal val

146 liftIO $ jsvaluetoboolean gctxt rval

150 liftIO $ jsvaluetoboolean gctxt rval

147#endif

151#endif

148{-# INLINE valToBool #-}

152{-# INLINE valToBool #-}

@@ -166,15 +170,15 @@ valToBool val = do

166-- 0.0

170-- 0.0

167-- >>> testJSaddle $ show <$> valToNumber "1"

171-- >>> testJSaddle $ show <$> valToNumber "1"

168-- 1.0

172-- 1.0

169−valToNumber :: MakeValueRef val => val -> JSM JSNumber

173+valToNumber :: MakeVal val => val -> JSM Double

170#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

174#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

171−valToNumber val = jsrefToNumber <$> makeValueRef val

175+valToNumber val = jsrefToNumber <$> makeVal val

172{-# INLINE valToNumber #-}

176{-# INLINE valToNumber #-}

173foreign import javascript unsafe "$r = Number($1);" jsrefToNumber :: JSVal -> Double

177foreign import javascript unsafe "$r = Number($1);" jsrefToNumber :: JSVal -> Double

174#elif defined(USE_WEBKIT)

178#elif defined(USE_WEBKIT)

175valToNumber val = do

179valToNumber val = do

176 gctxt <- ask

180 gctxt <- ask

177− rval <- makeValueRef val

181+ rval <- makeVal val

178 rethrow $ liftIO . jsvaluetonumber gctxt rval

182 rethrow $ liftIO . jsvaluetonumber gctxt rval

179{-# INLINE valToNumber #-}

183{-# INLINE valToNumber #-}

180#else

184#else

@@ -200,15 +204,15 @@ valToNumber = undefined

200--

204--

201-- >>> testJSaddle $ valToStr "1" >>= strToText

205-- >>> testJSaddle $ valToStr "1" >>= strToText

202-- 1

206-- 1

203−valToStr :: MakeValueRef val => val -> JSM JSStringRef

207+valToStr :: MakeVal val => val -> JSM JSString

204#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

208#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

205−valToStr val = jsrefToString <$> makeValueRef val

209+valToStr val = jsrefToString <$> makeVal val

206{-# INLINE valToStr #-}

210{-# INLINE valToStr #-}

207−foreign import javascript unsafe "$r = $1.toString();" jsrefToString :: JSVal -> JSStringRef

211+foreign import javascript unsafe "$r = $1.toString();" jsrefToString :: JSVal -> JSString

208#elif defined(USE_WEBKIT)

212#elif defined(USE_WEBKIT)

209valToStr val = do

213valToStr val = do

210 gctxt <- ask

214 gctxt <- ask

211− rval <- makeValueRef val

215+ rval <- makeVal val

212 rethrow $ liftIO . jsvaluetostringcopy gctxt rval

216 rethrow $ liftIO . jsvaluetostringcopy gctxt rval

213{-# INLINE valToStr #-}

217{-# INLINE valToStr #-}

214#else

218#else

@@ -234,7 +238,7 @@ valToStr = undefined

234-- ""

238-- ""

235-- >>> testJSaddle $ show <$> valToText "1"

239-- >>> testJSaddle $ show <$> valToText "1"

236-- "1"

240-- "1"

237−valToText :: MakeValueRef val => val -> JSM Text

241+valToText :: MakeVal val => val -> JSM Text

238valToText jsvar = valToStr jsvar >>= strToText

242valToText jsvar = valToStr jsvar >>= strToText

239{-# INLINE valToText #-}

243{-# INLINE valToText #-}

240

244

@@ -259,15 +263,15 @@ valToText jsvar = valToStr jsvar >>= strToText

259-- "1"

263-- "1"

260-- >>> testJSaddle $ obj >>= valToJSON 0 >>= strToText

264-- >>> testJSaddle $ obj >>= valToJSON 0 >>= strToText

261-- {}

265-- {}

262−valToJSON :: MakeValueRef val => Word -> val -> JSM JSStringRef

266+valToJSON :: MakeVal val => Word -> val -> JSM JSString

263#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

267#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

264−valToJSON indent val = jsrefToJSON <$> makeValueRef val

268+valToJSON indent val = jsrefToJSON <$> makeVal val

265{-# INLINE valToJSON #-}

269{-# INLINE valToJSON #-}

266−foreign import javascript unsafe "$r = JSON.stringify($1);" jsrefToJSON :: JSVal -> JSStringRef

270+foreign import javascript unsafe "$r = JSON.stringify($1);" jsrefToJSON :: JSVal -> JSString

267#elif defined(USE_WEBKIT)

271#elif defined(USE_WEBKIT)

268valToJSON indent val = do

272valToJSON indent val = do

269 gctxt <- ask

273 gctxt <- ask

270− rval <- makeValueRef val

274+ rval <- makeVal val

271 rethrow $ liftIO . jsvaluecreatejsonstring gctxt rval (fromIntegral indent)

275 rethrow $ liftIO . jsvaluecreatejsonstring gctxt rval (fromIntegral indent)

272{-# INLINE valToJSON #-}

276{-# INLINE valToJSON #-}

273#else

277#else

@@ -293,47 +297,47 @@ valToJSON = undefined

293--

297--

294-- >>> testJSaddle $ valToObject "1"

298-- >>> testJSaddle $ valToObject "1"

295-- 1

299-- 1

296−valToObject :: MakeValueRef val => val -> JSM Object

300+valToObject :: MakeVal val => val -> JSM Object

297valToObject val = Object <$>

301valToObject val = Object <$>

298#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

302#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

299− makeValueRef val

303+ makeVal val

300#else

304#else

301 do gctxt <- ask

305 do gctxt <- ask

302− rval <- makeValueRef val

306+ rval <- makeVal val

303 rethrow $ liftIO . jsvaluetoobject gctxt rval

307 rethrow $ liftIO . jsvaluetoobject gctxt rval

304#endif

308#endif

305{-# INLINE valToObject #-}

309{-# INLINE valToObject #-}

306

310

307−instance MakeObject JSValueRef where

311+instance MakeObject JSVal where

308 makeObject = valToObject

312 makeObject = valToObject

309 {-# INLINE makeObject #-}

313 {-# INLINE makeObject #-}

310

314

311−-- | Convert to a JavaScript value (just an alias for 'makeValueRef')

315+-- | Convert to a JavaScript value (just an alias for 'makeVal')

312−val :: MakeValueRef value

316+val :: MakeVal value

313 => value -- ^ value to convert to a JavaScript value

317 => value -- ^ value to convert to a JavaScript value

314− -> JSM JSValueRef

318+ -> JSM JSVal

315−val = makeValueRef

319+val = makeVal

316{-# INLINE val #-}

320{-# INLINE val #-}

317

321

318−-- | If we already have a JSValueRef we are fine

322+-- | If we already have a JSVal we are fine

319−instance MakeValueRef JSValueRef where

323+instance MakeVal JSVal where

320− makeValueRef = return

324+ makeVal = return

321− {-# INLINE makeValueRef #-}

325+ {-# INLINE makeVal #-}

322

326

323−-- | A single JSValueRef can be used as the argument list

327+-- | A single JSVal can be used as the argument list

324−instance MakeArgRefs JSValueRef where

328+instance MakeArgs JSVal where

325− makeArgRefs arg = return [arg]

329+ makeArgs arg = return [arg]

326− {-# INLINE makeArgRefs #-}

330+ {-# INLINE makeArgs #-}

327

331

328−-- | JSValueRef can be made by evaluating a function in 'JSM' as long

332+-- | JSVal can be made by evaluating a function in 'JSM' as long

329−-- as it returns something we can make into a JSValueRef.

333+-- as it returns something we can make into a JSVal.

330−instance MakeValueRef v => MakeValueRef (JSM v) where

334+instance MakeVal v => MakeVal (JSM v) where

331− makeValueRef v = v >>= makeValueRef

335+ makeVal v = v >>= makeVal

332− {-# INLINE makeValueRef #-}

336+ {-# INLINE makeVal #-}

333

337

334----------- null ---------------

338----------- null ---------------

335-- | Make a @null@ JavaScript value

339-- | Make a @null@ JavaScript value

336−valMakeNull :: JSM JSValueRef

340+valMakeNull :: JSM JSVal

337#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

341#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

338valMakeNull = return jsNull

342valMakeNull = return jsNull

339#else

343#else

@@ -342,18 +346,30 @@ valMakeNull = ask >>= (liftIO . jsvaluemakenull)

342{-# INLINE valMakeNull #-}

346{-# INLINE valMakeNull #-}

343

347

344-- | Makes a @null@ JavaScript value

348-- | Makes a @null@ JavaScript value

345−instance MakeValueRef JSNull where

349+instance MakeVal JSNull where

346− makeValueRef = const valMakeNull

350+ makeVal = const valMakeNull

347− {-# INLINE makeValueRef #-}

351+ {-# INLINE makeVal #-}

348

352

349-- | Makes an argument list with just a single @null@ JavaScript value

353-- | Makes an argument list with just a single @null@ JavaScript value

350−instance MakeArgRefs JSNull where

354+instance MakeArgs JSNull where

351− makeArgRefs _ = valMakeNull >>= (\ref -> return [ref])

355+ makeArgs _ = valMakeNull >>= (\ref -> return [ref])

352− {-# INLINE makeArgRefs #-}

356+ {-# INLINE makeArgs #-}

357+

358+-- | Test a JavaScript value to see if it is @null@

359+valIsNull :: MakeVal val => val -> JSM Bool

360+#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

361+valIsNull val = isNull <$> makeVal val

362+#else

363+valIsNull val = do

364+ gctxt <- ask

365+ rval <- makeVal val

366+ liftIO $ jsvalueisnull gctxt rval

367+#endif

368+{-# INLINE valIsNull #-}

353

369

354----------- undefined ---------------

370----------- undefined ---------------

355-- | Make an @undefined@ JavaScript value

371-- | Make an @undefined@ JavaScript value

356−valMakeUndefined :: JSM JSValueRef

372+valMakeUndefined :: JSM JSVal

357#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

373#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

358valMakeUndefined = return jsUndefined

374valMakeUndefined = return jsUndefined

359#else

375#else

@@ -362,23 +378,47 @@ valMakeUndefined = ask >>= (liftIO . jsvaluemakeundefined)

362{-# INLINE valMakeUndefined #-}

378{-# INLINE valMakeUndefined #-}

363

379

364-- | Makes an @undefined@ JavaScript value

380-- | Makes an @undefined@ JavaScript value

365−instance MakeValueRef JSUndefined where

381+instance MakeVal JSUndefined where

366− makeValueRef = const valMakeUndefined

382+ makeVal = const valMakeUndefined

367− {-# INLINE makeValueRef #-}

383+ {-# INLINE makeVal #-}

368

384

369--We can't allow this if JSUndefined is () as () is no args not "(null)".

385--We can't allow this if JSUndefined is () as () is no args not "(null)".

370--Use [()] instead.

386--Use [()] instead.

371−--instance MakeArgRefs JSUndefined where

387+--instance MakeArgs JSUndefined where

372−-- makeArgRefs _ = valMakeUndefined >>= (\ref -> return [ref])

388+-- makeArgs _ = valMakeUndefined >>= (\ref -> return [ref])

373

389

374−-- | This allows us to pass no arguments easily (altenative would be to use @[]::[JSValueRef]@).

390+-- | This allows us to pass no arguments easily (altenative would be to use @[]::[JSVal]@).

375−instance MakeArgRefs () where

391+instance MakeArgs () where

376− makeArgRefs _ = return []

392+ makeArgs _ = return []

377− {-# INLINE makeArgRefs #-}

393+ {-# INLINE makeArgs #-}

394+

395+-- | Test a JavaScript value to see if it is @undefined@

396+valIsUndefined :: MakeVal val => val -> JSM Bool

397+#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

398+valIsUndefined val = isUndefined <$> makeVal val

399+#else

400+valIsUndefined val = do

401+ gctxt <- ask

402+ rval <- makeVal val

403+ liftIO $ jsvalueisundefined gctxt rval

404+#endif

405+{-# INLINE valIsUndefined #-}

406+

407+-- | Convert a JSVal to a Maybe JSVal (converting null and undefined to Nothing)

408+maybeNullOrUndefined :: MakeVal val => val -> JSM (Maybe JSVal)

409+maybeNullOrUndefined val = do

410+ rval <- makeVal val

411+ valIsNull rval >>= \case

412+ True -> return Nothing

413+ _ ->

414+ valIsUndefined rval >>= \case

415+ True -> return Nothing

416+ _ -> return (Just rval)

417+{-# INLINE maybeNullOrUndefined #-}

378

418

379----------- booleans ---------------

419----------- booleans ---------------

380-- | Make a JavaScript boolean value

420-- | Make a JavaScript boolean value

381−valMakeBool :: JSBool -> JSM JSValueRef

421+valMakeBool :: Bool -> JSM JSVal

382#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

422#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

383valMakeBool b = return $ toJSBool b

423valMakeBool b = return $ toJSBool b

384#else

424#else

@@ -389,18 +429,18 @@ valMakeBool b = do

389{-# INLINE valMakeBool #-}

429{-# INLINE valMakeBool #-}

390

430

391-- | Make a JavaScript boolean value

431-- | Make a JavaScript boolean value

392−instance MakeValueRef Bool where

432+instance MakeVal Bool where

393− makeValueRef = valMakeBool

433+ makeVal = valMakeBool

394− {-# INLINE makeValueRef #-}

434+ {-# INLINE makeVal #-}

395

435

396-- | Makes an argument list with just a single JavaScript boolean value

436-- | Makes an argument list with just a single JavaScript boolean value

397−instance MakeArgRefs Bool where

437+instance MakeArgs Bool where

398− makeArgRefs b = valMakeBool b >>= (\ref -> return [ref])

438+ makeArgs b = valMakeBool b >>= (\ref -> return [ref])

399− {-# INLINE makeArgRefs #-}

439+ {-# INLINE makeArgs #-}

400

440

401----------- numbers ---------------

441----------- numbers ---------------

402-- | Make a JavaScript number

442-- | Make a JavaScript number

403−valMakeNumber :: JSNumber -> JSM JSValueRef

443+valMakeNumber :: Double -> JSM JSVal

404#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

444#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

405valMakeNumber n = liftIO $ toJSVal n

445valMakeNumber n = liftIO $ toJSVal n

406#else

446#else

@@ -411,18 +451,18 @@ valMakeNumber n = do

411{-# INLINE valMakeNumber #-}

451{-# INLINE valMakeNumber #-}

412

452

413-- | Makes a JavaScript number

453-- | Makes a JavaScript number

414−instance MakeValueRef Double where

454+instance MakeVal Double where

415− makeValueRef = valMakeNumber

455+ makeVal = valMakeNumber

416− {-# INLINE makeValueRef #-}

456+ {-# INLINE makeVal #-}

417

457

418-- | Makes an argument list with just a single JavaScript number

458-- | Makes an argument list with just a single JavaScript number

419−instance MakeArgRefs Double where

459+instance MakeArgs Double where

420− makeArgRefs n = valMakeNumber n >>= (\ref -> return [ref])

460+ makeArgs n = valMakeNumber n >>= (\ref -> return [ref])

421− {-# INLINE makeArgRefs #-}

461+ {-# INLINE makeArgs #-}

422

462

423----------- numbers ---------------

463----------- numbers ---------------

424-- | Make a JavaScript string

464-- | Make a JavaScript string

425−valMakeString :: Text -> JSM JSValueRef

465+valMakeString :: Text -> JSM JSVal

426#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

466#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)

427valMakeString = return . pToJSVal . textToJSString

467valMakeString = return . pToJSVal . textToJSString

428#else

468#else

@@ -433,19 +473,19 @@ valMakeString text = do

433{-# INLINE valMakeString #-}

473{-# INLINE valMakeString #-}

434

474

435-- | Makes a JavaScript string

475-- | Makes a JavaScript string

436−instance MakeValueRef Text where

476+instance MakeVal Text where

437− makeValueRef = valMakeString

477+ makeVal = valMakeString

438− {-# INLINE makeValueRef #-}

478+ {-# INLINE makeVal #-}

439

479

440-- | Makes an argument list with just a single JavaScript string

480-- | Makes an argument list with just a single JavaScript string

441−instance MakeArgRefs Text where

481+instance MakeArgs Text where

442− makeArgRefs t = valMakeString t >>= (\ref -> return [ref])

482+ makeArgs t = valMakeString t >>= (\ref -> return [ref])

443− {-# INLINE makeArgRefs #-}

483+ {-# INLINE makeArgs #-}

444

484

445-- | Makes a JavaScript string

485-- | Makes a JavaScript string

446−instance MakeValueRef String where

486+instance MakeVal String where

447− makeValueRef = valMakeString . T.pack

487+ makeVal = valMakeString . T.pack

448− {-# INLINE makeValueRef #-}

488+ {-# INLINE makeVal #-}

449

489

450-- | Derefernce a value reference.

490-- | Derefernce a value reference.

451--

491--

@@ -467,35 +507,34 @@ instance MakeValueRef String where

467-- ValString "1"

507-- ValString "1"

468-- >>> testJSaddle $ show <$> valToObject True >>= deRefVal

508-- >>> testJSaddle $ show <$> valToObject True >>= deRefVal

469-- ValObject 0x...

509-- ValObject 0x...

470−deRefVal :: MakeValueRef val => val -> JSM JSValue

510+deRefVal :: MakeVal val => val -> JSM JSValue

471#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

511#if defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)

472deRefVal val = do

512deRefVal val = do

473− gctxt <- ask

474− valref <- makeValueRef val

513+ valref <- makeVal val

475 case (jsrefGetType valref :: Int) of

514 case (jsrefGetType valref :: Int) of

476 0 -> return ValUndefined

515 0 -> return ValUndefined

477 1 -> return ValNull

516 1 -> return ValNull

478 2 -> ValBool <$> valToBool valref

517 2 -> ValBool <$> valToBool valref

479 3 -> ValNumber <$> valToNumber valref

518 3 -> ValNumber <$> valToNumber valref

480− 4 -> ValString <$> (valToStr valref >>= strToText)

519+ 4 -> ValString <$> valToText valref

481 5 -> ValObject <$> valToObject valref

520 5 -> ValObject <$> valToObject valref

482foreign import javascript unsafe "$r = ($1 === undefined)?0:\

521foreign import javascript unsafe "$r = ($1 === undefined)?0:\

483 ($1===null)?1:\

522 ($1===null)?1:\

484 (typeof $1===\"boolean\")?2:\

523 (typeof $1===\"boolean\")?2:\

485 (typeof $1===\"number\")?3:\

524 (typeof $1===\"number\")?3:\

486 (typeof $1===\"string\")?4:\

525 (typeof $1===\"string\")?4:\

487− (typeof $1===\"object\")?5:-1;" jsrefGetType :: JSValueRef -> Int

526+ (typeof $1===\"object\")?5:-1;" jsrefGetType :: JSVal -> Int

488#elif defined(USE_WEBKIT)

527#elif defined(USE_WEBKIT)

489deRefVal val = do

528deRefVal val = do

490 gctxt <- ask

529 gctxt <- ask

491− valref <- makeValueRef val

530+ valref <- makeVal val

492 t <- liftIO $ jsvaluegettype gctxt valref

531 t <- liftIO $ jsvaluegettype gctxt valref

493 case t of

532 case t of

494 Kjstypenull -> return ValNull

533 Kjstypenull -> return ValNull

495 Kjstypeundefined -> return ValUndefined

534 Kjstypeundefined -> return ValUndefined

496 Kjstypeboolean -> ValBool <$> valToBool valref

535 Kjstypeboolean -> ValBool <$> valToBool valref

497 Kjstypenumber -> ValNumber <$> valToNumber valref

536 Kjstypenumber -> ValNumber <$> valToNumber valref

498− Kjstypestring -> ValString <$> (valToStr valref >>= strToText)

537+ Kjstypestring -> ValString <$> valToText valref

499 Kjstypeobject -> ValObject <$> valToObject valref

538 Kjstypeobject -> ValObject <$> valToObject valref

500#else

539#else

501deRefVal = undefined

540deRefVal = undefined

@@ -513,7 +552,7 @@ deRefVal = undefined

513-- "1"

552-- "1"

514-- >>> testJSaddle $ valMakeRef (ValString $ pack "Hello")

553-- >>> testJSaddle $ valMakeRef (ValString $ pack "Hello")

515-- "Hello"

554-- "Hello"

516−valMakeRef :: JSValue -> JSM JSValueRef

555+valMakeRef :: JSValue -> JSM JSVal

517valMakeRef val =

556valMakeRef val =

518 case val of

557 case val of

519 ValNull -> valMakeNull

558 ValNull -> valMakeNull

@@ -524,14 +563,14 @@ valMakeRef val =

524 ValObject (Object o) -> return o

563 ValObject (Object o) -> return o

525

564

526-- | Makes a JavaScript value from a 'JSValue' ADT.

565-- | Makes a JavaScript value from a 'JSValue' ADT.

527−instance MakeValueRef JSValue where

566+instance MakeVal JSValue where

528− makeValueRef = valMakeRef

567+ makeVal = valMakeRef

529− {-# INLINE makeValueRef #-}

568+ {-# INLINE makeVal #-}

530

569

531-- | Makes an argument list with just a single JavaScript value from a 'JSValue' ADT.

570-- | Makes an argument list with just a single JavaScript value from a 'JSValue' ADT.

532−instance MakeArgRefs JSValue where

571+instance MakeArgs JSValue where

533− makeArgRefs v = valMakeRef v >>= (\ref -> return [ref])

572+ makeArgs v = valMakeRef v >>= (\ref -> return [ref])

534− {-# INLINE makeArgRefs #-}

573+ {-# INLINE makeArgs #-}

535

574

536--instance MakeObjectRef JSNull where

575--instance MakeObjectRef JSNull where

537-- makeObjectRef _ = Object <$> valMakeNull

576-- makeObjectRef _ = Object <$> valMakeNull

tests/TestJSaddle.hs+3−3

@@ -49,16 +49,16 @@ state = unsafePerformIO $ newMVar Nothing

49done = unsafePerformIO $ newEmptyMVar

51-- >>> testJSaddle $ ((global ^. js "console" . js "log") # ["Hello"])

52−testJSaddle :: MakeValueRef val => JSM val -> IO ()

52+testJSaddle :: MakeVal val => JSM val -> IO ()

53testJSaddle = testJSaddle' False

55-- >>> showJSaddle $ eval "document.body.innerHTML = 'Test'"

56−showJSaddle :: MakeValueRef val => JSM val -> IO ()

56+showJSaddle :: MakeVal val => JSM val -> IO ()

57showJSaddle = testJSaddle' True

59debugLog = debugM "jsaddle"

61−testJSaddle' :: MakeValueRef val => Bool -> JSM val -> IO ()

61+testJSaddle' :: MakeVal val => Bool -> JSM val -> IO ()

62testJSaddle' showWindow f = do

63 debugLog "taking done"

64 tryTakeMVar done