-----------------------------------------------------------------------------
{-# LANGUAGE ScopedTypeVariables  #-}
{-# LANGUAGE DerivingStrategies   #-}
{-# LANGUAGE DefaultSignatures    #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE FlexibleInstances    #-}
{-# LANGUAGE FlexibleContexts     #-}
{-# LANGUAGE DeriveAnyClass       #-}
{-# LANGUAGE KindSignatures       #-}
{-# LANGUAGE DeriveGeneric        #-}
{-# LANGUAGE TypeOperators        #-}
{-# LANGUAGE LambdaCase           #-}
{-# LANGUAGE CPP                  #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Miso.DSL
-- Copyright   :  (C) 2016-2025 David M. Johnson (@dmjio)
-- License     :  BSD3-style (see the file LICENSE)
-- Maintainer  :  David M. Johnson <code@dmj.io>
-- Stability   :  experimental
-- Portability :  non-portable
--
-- A JavaScript DSL for interacting with the browser or JS runtime environments.
-----------------------------------------------------------------------------
module Miso.DSL
  ( -- * Classes
    ToJSVal (..)
  , FromJSVal (..)
  , ToArgs (..)
  , ToObject (..)
    -- * Types
  , JSVal
  , Object (..)
  , Function (..)
    -- * Utils
  , jsg
  , jsg0
  , jsg1
  , jsg2
  , jsg3
  , jsg4
  , jsg5
  , jsgf
  , global
  , (#)
  , setField
  , (<##)
  , (!)
  , listProps
  , call
  , new
  , create
  , setProp
  , getProp
  , eval
  , requestAnimationFrame
  , cancelAnimationFrame
  , freeFunction
  , (!!)
  , isUndefined
  , isNull
  , jsNull
  , syncCallback
  , syncCallback1
  , syncCallback2
  , syncCallback3
  , syncCallback'
  , syncCallback1'
  , syncCallback2'
  , syncCallback3'
  , asyncCallback
  , asyncCallback1
  , asyncCallback2
  , asyncCallback3
  ) where
-----------------------------------------------------------------------------
import Control.Applicative
#ifndef VANILLA
import Data.Text (Text)
#endif
import Control.Monad
import Control.Monad.Trans.Maybe
import GHC.Generics
import Data.Kind
import Prelude hiding ((!!))
-----------------------------------------------------------------------------
import Miso.DSL.FFI
import Miso.JSON (Value, fromJSVal_Value, toJSVal_Value)
import Miso.String
-----------------------------------------------------------------------------
-- | A class for marshaling Haskell values into JS
class ToJSVal a where
  toJSVal :: a -> IO JSVal
  default toJSVal :: (Generic a, GToJSVal (Rep a)) => a -> IO JSVal
  toJSVal a
x = do
    o <- IO Object
create
    gToJSVal (from x) o
    toJSVal o
-----------------------------------------------------------------------------
class GToJSVal (f :: Type -> Type) where
  gToJSVal :: f a -> Object -> IO ()
-----------------------------------------------------------------------------
instance GToJSVal a => GToJSVal (D1 i a) where
  gToJSVal :: forall a. D1 i a a -> Object -> IO ()
gToJSVal (M1 a a
x) = a a -> Object -> IO ()
forall a. a a -> Object -> IO ()
forall (f :: * -> *) a. GToJSVal f => f a -> Object -> IO ()
gToJSVal a a
x
-----------------------------------------------------------------------------
instance GToJSVal a => GToJSVal (C1 i a) where
  gToJSVal :: forall a. C1 i a a -> Object -> IO ()
gToJSVal (M1 a a
x) = a a -> Object -> IO ()
forall a. a a -> Object -> IO ()
forall (f :: * -> *) a. GToJSVal f => f a -> Object -> IO ()
gToJSVal a a
x
-----------------------------------------------------------------------------
instance (GToJSVal a, GToJSVal b) => GToJSVal (a :*: b) where
  gToJSVal :: forall a. (:*:) a b a -> Object -> IO ()
gToJSVal (a a
x :*: b a
y) Object
o = a a -> Object -> IO ()
forall a. a a -> Object -> IO ()
forall (f :: * -> *) a. GToJSVal f => f a -> Object -> IO ()
gToJSVal a a
x Object
o IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> b a -> Object -> IO ()
forall a. b a -> Object -> IO ()
forall (f :: * -> *) a. GToJSVal f => f a -> Object -> IO ()
gToJSVal b a
y Object
o
-----------------------------------------------------------------------------
instance (GToJSVal a, GToJSVal b) => GToJSVal (a :+: b) where
  gToJSVal :: forall a. (:+:) a b a -> Object -> IO ()
gToJSVal = \case
    L1 a a
x -> a a -> Object -> IO ()
forall a. a a -> Object -> IO ()
forall (f :: * -> *) a. GToJSVal f => f a -> Object -> IO ()
gToJSVal a a
x
    R1 b a
x -> b a -> Object -> IO ()
forall a. b a -> Object -> IO ()
forall (f :: * -> *) a. GToJSVal f => f a -> Object -> IO ()
gToJSVal b a
x
-----------------------------------------------------------------------------
instance (ToJSVal a, Selector s) => GToJSVal (S1 s (K1 i a)) where
  gToJSVal :: forall a. S1 s (K1 i a) a -> Object -> IO ()
gToJSVal (M1 (K1 a
x)) Object
o =
    Object -> MisoString -> JSVal -> IO ()
forall o v.
(ToObject o, ToJSVal v) =>
o -> MisoString -> v -> IO ()
setField Object
o MisoString
fieldName (JSVal -> IO ()) -> IO JSVal -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal a
x
      where
        fieldName :: MisoString
fieldName = [Char] -> MisoString
forall str. ToMisoString str => str -> MisoString
ms ([Char] -> MisoString) -> [Char] -> MisoString
forall a b. (a -> b) -> a -> b
$ M1 S s (K1 i a) () -> [Char]
forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Selector s =>
t s f a -> [Char]
forall k1 (t :: Meta -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
t s f a -> [Char]
selName (M1 S s (K1 i a) ()
forall a. HasCallStack => a
undefined :: S1 s (K1 i a) ())
-----------------------------------------------------------------------------
instance GToJSVal U1 where
  gToJSVal :: forall a. U1 a -> Object -> IO ()
gToJSVal U1 a
U1 Object
_ = () -> IO ()
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
-----------------------------------------------------------------------------
instance GToJSVal V1 where
  gToJSVal :: forall a. V1 a -> Object -> IO ()
gToJSVal V1 a
_ Object
_ = () -> IO ()
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
-----------------------------------------------------------------------------
instance ToJSVal Bool where
  toJSVal :: Bool -> IO JSVal
toJSVal = Bool -> IO JSVal
toJSVal_Bool
-----------------------------------------------------------------------------
instance ToJSVal Double where
  toJSVal :: Double -> IO JSVal
toJSVal = Double -> IO JSVal
toJSVal_Double
-----------------------------------------------------------------------------
instance ToJSVal Float where
  toJSVal :: Float -> IO JSVal
toJSVal = Float -> IO JSVal
toJSVal_Float
-----------------------------------------------------------------------------
instance ToJSVal a => ToJSVal (IO a) where
  toJSVal :: IO a -> IO JSVal
toJSVal IO a
action = a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal (a -> IO JSVal) -> IO a -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO a
action
-----------------------------------------------------------------------------
instance ToJSVal () where
  toJSVal :: () -> IO JSVal
toJSVal () = JSVal -> IO JSVal
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JSVal
jsNull
-----------------------------------------------------------------------------
instance ToJSVal Char where
  toJSVal :: Char -> IO JSVal
toJSVal = Char -> IO JSVal
toJSVal_Char
-----------------------------------------------------------------------------
instance ToJSVal Int where
  toJSVal :: Int -> IO JSVal
toJSVal = Int -> IO JSVal
toJSVal_Int
-----------------------------------------------------------------------------
instance ToJSVal a => ToJSVal (Maybe a) where
  toJSVal :: Maybe a -> IO JSVal
toJSVal = \case
    Maybe a
Nothing -> JSVal -> IO JSVal
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure JSVal
jsNull
    Just a
x -> a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal a
x
-----------------------------------------------------------------------------
instance FromJSVal a => FromJSVal [a] where
  fromJSVal :: JSVal -> IO (Maybe [a])
fromJSVal JSVal
jsval_ = do
    JSVal -> IO (Maybe [JSVal])
fromJSVal_List JSVal
jsval_ IO (Maybe [JSVal])
-> (Maybe [JSVal] -> IO (Maybe [a])) -> IO (Maybe [a])
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Maybe [JSVal]
Nothing -> Maybe [a] -> IO (Maybe [a])
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe [a]
forall a. Maybe a
Nothing
      Just [JSVal]
xs -> [Maybe a] -> Maybe [a]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([Maybe a] -> Maybe [a]) -> IO [Maybe a] -> IO (Maybe [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (JSVal -> IO (Maybe a)) -> [JSVal] -> IO [Maybe a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM JSVal -> IO (Maybe a)
forall a. FromJSVal a => JSVal -> IO (Maybe a)
fromJSVal [JSVal]
xs
-----------------------------------------------------------------------------
instance ToJSVal a => ToJSVal [a] where
  toJSVal :: [a] -> IO JSVal
toJSVal = [JSVal] -> IO JSVal
toJSVal_List ([JSVal] -> IO JSVal) -> ([a] -> IO [JSVal]) -> [a] -> IO JSVal
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (a -> IO JSVal) -> [a] -> IO [JSVal]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal
-----------------------------------------------------------------------------
instance ToJSVal JSVal where
  toJSVal :: JSVal -> IO JSVal
toJSVal = JSVal -> IO JSVal
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
-----------------------------------------------------------------------------
instance FromJSVal Value where
  fromJSVal :: JSVal -> IO (Maybe Value)
fromJSVal = JSVal -> IO (Maybe Value)
fromJSVal_Value
-----------------------------------------------------------------------------
-- | A class for marshaling JS values into Haskell
class FromJSVal a where
  fromJSVal :: JSVal -> IO (Maybe a)
  default fromJSVal :: (Generic a, GFromJSVal (Rep a)) => JSVal -> IO (Maybe a)
  fromJSVal JSVal
x = (Rep a (ZonkAny 1) -> a) -> Maybe (Rep a (ZonkAny 1)) -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep a (ZonkAny 1) -> a
forall a x. Generic a => Rep a x -> a
forall x. Rep a x -> a
to (Maybe (Rep a (ZonkAny 1)) -> Maybe a)
-> IO (Maybe (Rep a (ZonkAny 1))) -> IO (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object -> IO (Maybe (Rep a (ZonkAny 1)))
forall a. Object -> IO (Maybe (Rep a a))
forall (f :: * -> *) a. GFromJSVal f => Object -> IO (Maybe (f a))
gFromJSVal (JSVal -> Object
Object JSVal
x)
  fromJSValUnchecked :: JSVal -> IO a
  fromJSValUnchecked JSVal
x = do
    JSVal -> IO (Maybe a)
forall a. FromJSVal a => JSVal -> IO (Maybe a)
fromJSVal JSVal
x IO (Maybe a) -> (Maybe a -> IO a) -> IO a
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Maybe a
Nothing -> [Char] -> IO a
forall a. HasCallStack => [Char] -> a
error [Char]
"fromJSValUnchecked: failure"
      Just a
y -> a -> IO a
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
y
-----------------------------------------------------------------------------
class GFromJSVal (f :: Type -> Type) where
  gFromJSVal :: Object -> IO (Maybe (f a))
-----------------------------------------------------------------------------
instance GFromJSVal a => GFromJSVal (D1 i a) where
  gFromJSVal :: forall a. Object -> IO (Maybe (D1 i a a))
gFromJSVal Object
o = (a a -> D1 i a a) -> Maybe (a a) -> Maybe (D1 i a a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a a -> D1 i a a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (Maybe (a a) -> Maybe (D1 i a a))
-> IO (Maybe (a a)) -> IO (Maybe (D1 i a a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object -> IO (Maybe (a a))
forall a. Object -> IO (Maybe (a a))
forall (f :: * -> *) a. GFromJSVal f => Object -> IO (Maybe (f a))
gFromJSVal Object
o
-----------------------------------------------------------------------------
instance GFromJSVal a => GFromJSVal (C1 i a) where
  gFromJSVal :: forall a. Object -> IO (Maybe (C1 i a a))
gFromJSVal Object
o = (a a -> C1 i a a) -> Maybe (a a) -> Maybe (C1 i a a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a a -> C1 i a a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (Maybe (a a) -> Maybe (C1 i a a))
-> IO (Maybe (a a)) -> IO (Maybe (C1 i a a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object -> IO (Maybe (a a))
forall a. Object -> IO (Maybe (a a))
forall (f :: * -> *) a. GFromJSVal f => Object -> IO (Maybe (f a))
gFromJSVal Object
o
-----------------------------------------------------------------------------
instance GFromJSVal U1 where
  gFromJSVal :: forall a. Object -> IO (Maybe (U1 a))
gFromJSVal Object
_ = Maybe (U1 a) -> IO (Maybe (U1 a))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (U1 a -> Maybe (U1 a)
forall a. a -> Maybe a
Just U1 a
forall k (p :: k). U1 p
U1)
-----------------------------------------------------------------------------
instance GFromJSVal V1 where
  gFromJSVal :: forall a. Object -> IO (Maybe (V1 a))
gFromJSVal Object
_ = Maybe (V1 a) -> IO (Maybe (V1 a))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (V1 a)
forall a. Maybe a
Nothing
-----------------------------------------------------------------------------
instance (GFromJSVal a, GFromJSVal b) => GFromJSVal (a :*: b) where
  gFromJSVal :: forall a. Object -> IO (Maybe ((:*:) a b a))
gFromJSVal Object
o = MaybeT IO ((:*:) a b a) -> IO (Maybe ((:*:) a b a))
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT IO ((:*:) a b a) -> IO (Maybe ((:*:) a b a)))
-> MaybeT IO ((:*:) a b a) -> IO (Maybe ((:*:) a b a))
forall a b. (a -> b) -> a -> b
$ a a -> b a -> (:*:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (a a -> b a -> (:*:) a b a)
-> MaybeT IO (a a) -> MaybeT IO (b a -> (:*:) a b a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Maybe (a a)) -> MaybeT IO (a a)
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (Object -> IO (Maybe (a a))
forall a. Object -> IO (Maybe (a a))
forall (f :: * -> *) a. GFromJSVal f => Object -> IO (Maybe (f a))
gFromJSVal Object
o) MaybeT IO (b a -> (:*:) a b a)
-> MaybeT IO (b a) -> MaybeT IO ((:*:) a b a)
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IO (Maybe (b a)) -> MaybeT IO (b a)
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (Object -> IO (Maybe (b a))
forall a. Object -> IO (Maybe (b a))
forall (f :: * -> *) a. GFromJSVal f => Object -> IO (Maybe (f a))
gFromJSVal Object
o)
-----------------------------------------------------------------------------
instance (GFromJSVal a, GFromJSVal b) => GFromJSVal (a :+: b) where
  gFromJSVal :: forall a. Object -> IO (Maybe ((:+:) a b a))
gFromJSVal Object
o = do
    x <- (a a -> (:+:) a b a) -> Maybe (a a) -> Maybe ((:+:) a b a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a a -> (:+:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (Maybe (a a) -> Maybe ((:+:) a b a))
-> IO (Maybe (a a)) -> IO (Maybe ((:+:) a b a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object -> IO (Maybe (a a))
forall a. Object -> IO (Maybe (a a))
forall (f :: * -> *) a. GFromJSVal f => Object -> IO (Maybe (f a))
gFromJSVal Object
o
    case x of
      Maybe ((:+:) a b a)
Nothing -> (b a -> (:+:) a b a) -> Maybe (b a) -> Maybe ((:+:) a b a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b a -> (:+:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (Maybe (b a) -> Maybe ((:+:) a b a))
-> IO (Maybe (b a)) -> IO (Maybe ((:+:) a b a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object -> IO (Maybe (b a))
forall a. Object -> IO (Maybe (b a))
forall (f :: * -> *) a. GFromJSVal f => Object -> IO (Maybe (f a))
gFromJSVal Object
o
      Just (:+:) a b a
y -> Maybe ((:+:) a b a) -> IO (Maybe ((:+:) a b a))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((:+:) a b a -> Maybe ((:+:) a b a)
forall a. a -> Maybe a
Just (:+:) a b a
y)
-----------------------------------------------------------------------------
instance (FromJSVal a, Selector s) => GFromJSVal (S1 s (K1 i a)) where
  gFromJSVal :: forall a. Object -> IO (Maybe (S1 s (K1 i a) a))
gFromJSVal Object
o = (a -> S1 s (K1 i a) a) -> Maybe a -> Maybe (S1 s (K1 i a) a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (K1 i a a -> S1 s (K1 i a) a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (K1 i a a -> S1 s (K1 i a) a)
-> (a -> K1 i a a) -> a -> S1 s (K1 i a) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> K1 i a a
forall k i c (p :: k). c -> K1 i c p
K1) (Maybe a -> Maybe (S1 s (K1 i a) a))
-> IO (Maybe a) -> IO (Maybe (S1 s (K1 i a) a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> do JSVal -> IO (Maybe a)
forall a. FromJSVal a => JSVal -> IO (Maybe a)
fromJSVal (JSVal -> IO (Maybe a)) -> IO JSVal -> IO (Maybe a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< MisoString -> Object -> IO JSVal
forall o. ToObject o => MisoString -> o -> IO JSVal
getProp ([Char] -> MisoString
forall str. ToMisoString str => str -> MisoString
ms [Char]
name) Object
o
    where
      name :: [Char]
name = M1 S s (K1 i a) () -> [Char]
forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Selector s =>
t s f a -> [Char]
forall k1 (t :: Meta -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
t s f a -> [Char]
selName (M1 S s (K1 i a) ()
forall a. HasCallStack => a
undefined :: S1 s (K1 i a) ())
-----------------------------------------------------------------------------
instance FromJSVal Int where
  fromJSVal :: JSVal -> IO (Maybe Int)
fromJSVal = JSVal -> IO (Maybe Int)
fromJSVal_Int
  fromJSValUnchecked :: JSVal -> IO Int
fromJSValUnchecked = JSVal -> IO Int
fromJSValUnchecked_Int
-----------------------------------------------------------------------------
instance FromJSVal Char where
  fromJSVal :: JSVal -> IO (Maybe Char)
fromJSVal = JSVal -> IO (Maybe Char)
fromJSVal_Char
  fromJSValUnchecked :: JSVal -> IO Char
fromJSValUnchecked = JSVal -> IO Char
fromJSValUnchecked_Char
-----------------------------------------------------------------------------
instance FromJSVal Float where
  fromJSVal :: JSVal -> IO (Maybe Float)
fromJSVal = JSVal -> IO (Maybe Float)
fromJSVal_Float
  fromJSValUnchecked :: JSVal -> IO Float
fromJSValUnchecked = JSVal -> IO Float
fromJSValUnchecked_Float
-----------------------------------------------------------------------------
instance FromJSVal Double where
  fromJSVal :: JSVal -> IO (Maybe Double)
fromJSVal = JSVal -> IO (Maybe Double)
fromJSVal_Double
  fromJSValUnchecked :: JSVal -> IO Double
fromJSValUnchecked = JSVal -> IO Double
fromJSValUnchecked_Double
-----------------------------------------------------------------------------
instance FromJSVal Text where
  fromJSVal :: JSVal -> IO (Maybe MisoString)
fromJSVal = JSVal -> IO (Maybe MisoString)
fromJSVal_Text
  fromJSValUnchecked :: JSVal -> IO MisoString
fromJSValUnchecked = JSVal -> IO MisoString
fromJSValUnchecked_Text
-----------------------------------------------------------------------------
instance ToObject Object where
  toObject :: Object -> IO Object
toObject = Object -> IO Object
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
-----------------------------------------------------------------------------
instance ToJSVal Value where
  toJSVal :: Value -> IO JSVal
toJSVal = Value -> IO JSVal
toJSVal_Value
-----------------------------------------------------------------------------
instance ToJSVal Text where
  toJSVal :: MisoString -> IO JSVal
toJSVal = MisoString -> IO JSVal
toJSVal_Text
-----------------------------------------------------------------------------
instance FromJSVal () where
  fromJSVal :: JSVal -> IO (Maybe ())
fromJSVal JSVal
x =
    if JSVal -> Bool
isUndefined_ffi JSVal
x Bool -> Bool -> Bool
|| JSVal -> Bool
isNull_ffi JSVal
x
      then Maybe () -> IO (Maybe ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (() -> Maybe ()
forall a. a -> Maybe a
Just ())
      else Maybe () -> IO (Maybe ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ()
forall a. Maybe a
Nothing
-----------------------------------------------------------------------------
instance (ToJSVal a, ToJSVal b) => ToJSVal (a,b) where
  toJSVal :: (a, b) -> IO JSVal
toJSVal (a
y,b
z) = do
    y_ <- a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal a
y
    z_ <- toJSVal z
    toJSVal_List [ y_, z_ ]
-----------------------------------------------------------------------------
instance (ToJSVal a, ToJSVal b, ToJSVal c) => ToJSVal (a,b,c) where
  toJSVal :: (a, b, c) -> IO JSVal
toJSVal (a
x,b
y,c
z) = do
    x_ <- a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal a
x
    y_ <- toJSVal y
    z_ <- toJSVal z
    toJSVal_List [ x_, y_, z_ ]
-----------------------------------------------------------------------------
instance (ToJSVal a, ToJSVal b, ToJSVal c, ToJSVal d) => ToJSVal (a,b,c,d) where
  toJSVal :: (a, b, c, d) -> IO JSVal
toJSVal (a
w,b
x,c
y,d
z) = do
    w_ <- a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal a
w
    x_ <- toJSVal x
    y_ <- toJSVal y
    z_ <- toJSVal z
    toJSVal_List [ w_, x_, y_, z_ ]
-----------------------------------------------------------------------------
instance (ToJSVal a, ToJSVal b, ToJSVal c, ToJSVal d, ToJSVal e) => ToJSVal (a,b,c,d,e) where
  toJSVal :: (a, b, c, d, e) -> IO JSVal
toJSVal (a
v,b
w,c
x,d
y,e
z) = do
    v_ <- a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal a
v
    w_ <- toJSVal w
    x_ <- toJSVal x
    y_ <- toJSVal y
    z_ <- toJSVal z
    toJSVal_List [ v_, w_, x_, y_, z_ ]
-----------------------------------------------------------------------------
instance (ToJSVal a, ToJSVal b, ToJSVal c, ToJSVal d, ToJSVal e, ToJSVal f) => ToJSVal (a,b,c,d,e,f) where
  toJSVal :: (a, b, c, d, e, f) -> IO JSVal
toJSVal (a
u,b
v,c
w,d
x,e
y,f
z) = do
    u_ <- a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal a
u
    v_ <- toJSVal v
    w_ <- toJSVal w
    x_ <- toJSVal x
    y_ <- toJSVal y
    z_ <- toJSVal z
    toJSVal_List [ u_, v_, w_, x_, y_, z_ ]
-----------------------------------------------------------------------------
-- | Retrieves a field from globalThis
jsg :: MisoString -> IO JSVal
jsg :: MisoString -> IO JSVal
jsg MisoString
key = JSVal
global JSVal -> MisoString -> IO JSVal
forall o. ToObject o => o -> MisoString -> IO JSVal
! MisoString
key
-----------------------------------------------------------------------------
-- | Invokes a function with a specified argument list
jsgf :: ToArgs args => MisoString -> args -> IO JSVal
jsgf :: forall args. ToArgs args => MisoString -> args -> IO JSVal
jsgf MisoString
name = JSVal
global JSVal -> MisoString -> args -> IO JSVal
forall object args.
(ToObject object, ToArgs args) =>
object -> MisoString -> args -> IO JSVal
# MisoString
name
-----------------------------------------------------------------------------
-- | Invokes a function with no argument
jsg0 :: MisoString -> IO JSVal
jsg0 :: MisoString -> IO JSVal
jsg0 MisoString
name = MisoString -> [JSVal] -> IO JSVal
forall args. ToArgs args => MisoString -> args -> IO JSVal
jsgf MisoString
name ([] :: [JSVal])
-----------------------------------------------------------------------------
-- | Invokes a function with 1 argument
jsg1 :: ToJSVal arg => MisoString -> arg -> IO JSVal
jsg1 :: forall arg. ToJSVal arg => MisoString -> arg -> IO JSVal
jsg1 MisoString
name arg
arg = MisoString -> [arg] -> IO JSVal
forall args. ToArgs args => MisoString -> args -> IO JSVal
jsgf MisoString
name [arg
arg]
-----------------------------------------------------------------------------
-- | Invokes a function with 2 arguments
jsg2 :: (ToJSVal arg1, ToJSVal arg2) => MisoString -> arg1 -> arg2 -> IO JSVal
jsg2 :: forall arg1 arg2.
(ToJSVal arg1, ToJSVal arg2) =>
MisoString -> arg1 -> arg2 -> IO JSVal
jsg2 MisoString
name arg1
arg1 arg2
arg2 = do
  arg1_ <- arg1 -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal arg1
arg1
  arg2_ <- toJSVal arg2
  jsgf name [arg1_, arg2_]
-----------------------------------------------------------------------------
-- | Invokes a function with 3 arguments
jsg3 :: (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3)
     => MisoString
     -> arg1
     -> arg2
     -> arg3
     -> IO JSVal
jsg3 :: forall arg1 arg2 arg3.
(ToJSVal arg1, ToJSVal arg2, ToJSVal arg3) =>
MisoString -> arg1 -> arg2 -> arg3 -> IO JSVal
jsg3 MisoString
name arg1
arg1 arg2
arg2 arg3
arg3 = do
  arg1_ <- arg1 -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal arg1
arg1
  arg2_ <- toJSVal arg2
  arg3_ <- toJSVal arg3
  jsgf name [arg1_, arg2_, arg3_]
-----------------------------------------------------------------------------
-- | Invokes a function with 4 arguments
jsg4 :: (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4)
     => MisoString
     -> arg1
     -> arg2
     -> arg3
     -> arg4
     -> IO JSVal
jsg4 :: forall arg1 arg2 arg3 arg4.
(ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4) =>
MisoString -> arg1 -> arg2 -> arg3 -> arg4 -> IO JSVal
jsg4 MisoString
name arg1
arg1 arg2
arg2 arg3
arg3 arg4
arg4 = do
  arg1_ <- arg1 -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal arg1
arg1
  arg2_ <- toJSVal arg2
  arg3_ <- toJSVal arg3
  arg4_ <- toJSVal arg4
  jsgf name [arg1_, arg2_, arg3_, arg4_]
-----------------------------------------------------------------------------
-- | Invokes a function with 5 arguments
jsg5 :: (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4, ToJSVal arg5)
     => MisoString
     -> arg1
     -> arg2
     -> arg3
     -> arg4
     -> arg5
     -> IO JSVal
jsg5 :: forall arg1 arg2 arg3 arg4 arg5.
(ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4,
 ToJSVal arg5) =>
MisoString -> arg1 -> arg2 -> arg3 -> arg4 -> arg5 -> IO JSVal
jsg5 MisoString
name arg1
arg1 arg2
arg2 arg3
arg3 arg4
arg4 arg5
arg5 = do
  arg1_ <- arg1 -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal arg1
arg1
  arg2_ <- toJSVal arg2
  arg3_ <- toJSVal arg3
  arg4_ <- toJSVal arg4
  arg5_ <- toJSVal arg5
  jsgf name [arg1_, arg2_, arg3_, arg4_, arg5_]
-----------------------------------------------------------------------------
-- | Sets a field on an Object at a specified field
setField :: (ToObject o, ToJSVal v) => o -> MisoString -> v -> IO ()
setField :: forall o v.
(ToObject o, ToJSVal v) =>
o -> MisoString -> v -> IO ()
setField o
o MisoString
k v
v = do
  o' <- Object -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal (Object -> IO JSVal) -> IO Object -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< o -> IO Object
forall a. ToObject a => a -> IO Object
toObject o
o
  v' <- toJSVal v
  setProp_ffi k v' o'
-----------------------------------------------------------------------------
-- | Sets a field on an Object at a specified index
infixr 1 <##
(<##) :: (ToObject o, ToJSVal v) => o -> Int -> v -> IO ()
<## :: forall o v. (ToObject o, ToJSVal v) => o -> Int -> v -> IO ()
(<##) o
o Int
k v
v = do
  o' <- Object -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal (Object -> IO JSVal) -> IO Object -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< o -> IO Object
forall a. ToObject a => a -> IO Object
toObject o
o
  v' <- toJSVal v
  setPropIndex_ffi k v' o'
-----------------------------------------------------------------------------
-- | Retrieves a property from an Object
(!) :: ToObject o => o -> MisoString -> IO JSVal
! :: forall o. ToObject o => o -> MisoString -> IO JSVal
(!) = (MisoString -> o -> IO JSVal) -> o -> MisoString -> IO JSVal
forall a b c. (a -> b -> c) -> b -> a -> c
flip MisoString -> o -> IO JSVal
forall o. ToObject o => MisoString -> o -> IO JSVal
getProp
-----------------------------------------------------------------------------
-- | Lists the properties on a JS Object.
listProps :: Object -> IO [MisoString]
listProps :: Object -> IO [MisoString]
listProps (Object JSVal
jsval) = do
  keys <- JSVal -> IO [JSVal]
forall a. FromJSVal a => JSVal -> IO a
fromJSValUnchecked (JSVal -> IO [JSVal]) -> IO JSVal -> IO [JSVal]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< JSVal -> IO JSVal
listProps_ffi JSVal
jsval
  forM keys fromJSValUnchecked
-----------------------------------------------------------------------------
-- | Calls a JS function on an t'Object' at a field with specified arguments.
call :: (ToObject obj, ToObject this, ToArgs args) => obj -> this -> args -> IO JSVal
call :: forall obj this args.
(ToObject obj, ToObject this, ToArgs args) =>
obj -> this -> args -> IO JSVal
call obj
o this
this args
args = do
  o' <- Object -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal (Object -> IO JSVal) -> IO Object -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< obj -> IO Object
forall a. ToObject a => a -> IO Object
toObject obj
o
  this' <- toJSVal =<< toObject this
  args' <- toJSVal =<< toArgs args
  invokeFunction o' this' args'
-----------------------------------------------------------------------------
-- | Calls a JS function on an t'Object' at a field with specified arguments.
infixr 2 #
(#) :: (ToObject object, ToArgs args) => object -> MisoString -> args -> IO JSVal
# :: forall object args.
(ToObject object, ToArgs args) =>
object -> MisoString -> args -> IO JSVal
(#) object
o MisoString
k args
args = do
  o' <- Object -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal (Object -> IO JSVal) -> IO Object -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< object -> IO Object
forall a. ToObject a => a -> IO Object
toObject object
o
  func <- getProp_ffi k o'
  args' <- toJSVal =<< toArgs args
  invokeFunction func o' args'
-----------------------------------------------------------------------------
-- | Instantiates a new JS t'Object'.
new :: (ToObject constructor, ToArgs args) => constructor -> args -> IO JSVal
new :: forall constructor args.
(ToObject constructor, ToArgs args) =>
constructor -> args -> IO JSVal
new constructor
constr args
args = do
  obj <- Object -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal (Object -> IO JSVal) -> IO Object -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< constructor -> IO Object
forall a. ToObject a => a -> IO Object
toObject constructor
constr
  argv <- toJSVal =<< toArgs args
  new_ffi obj argv
-----------------------------------------------------------------------------
-- | Creates a new JS t'Object'
create :: IO Object
create :: IO Object
create = JSVal -> Object
Object (JSVal -> Object) -> IO JSVal -> IO Object
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO JSVal
create_ffi
-----------------------------------------------------------------------------
-- | Sets a property on a JS t'Object'
setProp :: ToJSVal val => MisoString -> val -> Object -> IO ()
setProp :: forall val. ToJSVal val => MisoString -> val -> Object -> IO ()
setProp MisoString
k val
v (Object JSVal
o) = (JSVal -> JSVal -> IO ()) -> JSVal -> JSVal -> IO ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (MisoString -> JSVal -> JSVal -> IO ()
setProp_ffi MisoString
k) JSVal
o (JSVal -> IO ()) -> IO JSVal -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< val -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal val
v
-----------------------------------------------------------------------------
-- | Retrieves a property from a JS t'Object'
getProp :: ToObject o => MisoString -> o -> IO JSVal
getProp :: forall o. ToObject o => MisoString -> o -> IO JSVal
getProp MisoString
k o
v = MisoString -> JSVal -> IO JSVal
getProp_ffi MisoString
k (JSVal -> IO JSVal) -> IO JSVal -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO Object -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal (o -> IO Object
forall a. ToObject a => a -> IO Object
toObject o
v)
-----------------------------------------------------------------------------
-- | Dynamically evaluates a JS string. See [eval](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval)
--
-- `eval()` is slower (not subject to JS engine optimizations) and also
-- has security vulnerabilities (can alter other local variables).
--
-- Consider using the more performant and secure (isolated) `inline` function.
--
eval :: MisoString -> IO JSVal
eval :: MisoString -> IO JSVal
eval = MisoString -> IO JSVal
eval_ffi
-----------------------------------------------------------------------------
instance FromJSVal Bool where
  fromJSVal :: JSVal -> IO (Maybe Bool)
fromJSVal = JSVal -> IO (Maybe Bool)
fromJSVal_Bool
  fromJSValUnchecked :: JSVal -> IO Bool
fromJSValUnchecked = JSVal -> IO Bool
fromJSValUnchecked_Bool
-----------------------------------------------------------------------------
instance FromJSVal JSVal where
  fromJSVal :: JSVal -> IO (Maybe JSVal)
fromJSVal = Maybe JSVal -> IO (Maybe JSVal)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe JSVal -> IO (Maybe JSVal))
-> (JSVal -> Maybe JSVal) -> JSVal -> IO (Maybe JSVal)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSVal -> Maybe JSVal
forall a. a -> Maybe a
Just
-----------------------------------------------------------------------------
instance FromJSVal a => FromJSVal (Maybe a) where
  fromJSVal :: JSVal -> IO (Maybe (Maybe a))
fromJSVal JSVal
x = JSVal -> IO (Maybe (Maybe JSVal))
fromJSVal_Maybe JSVal
x IO (Maybe (Maybe JSVal))
-> (Maybe (Maybe JSVal) -> IO (Maybe (Maybe a)))
-> IO (Maybe (Maybe a))
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Maybe (Maybe JSVal)
Nothing -> Maybe (Maybe a) -> IO (Maybe (Maybe a))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Maybe a)
forall a. Maybe a
Nothing
    Just Maybe JSVal
Nothing -> Maybe (Maybe a) -> IO (Maybe (Maybe a))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe a -> Maybe (Maybe a)
forall a. a -> Maybe a
Just Maybe a
forall a. Maybe a
Nothing)
    Just (Just JSVal
y) -> (a -> Maybe a) -> Maybe a -> Maybe (Maybe a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Maybe a
forall a. a -> Maybe a
Just (Maybe a -> Maybe (Maybe a))
-> IO (Maybe a) -> IO (Maybe (Maybe a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> JSVal -> IO (Maybe a)
forall a. FromJSVal a => JSVal -> IO (Maybe a)
fromJSVal JSVal
y
  fromJSValUnchecked :: JSVal -> IO (Maybe a)
fromJSValUnchecked JSVal
x = JSVal -> IO (Maybe JSVal)
fromJSValUnchecked_Maybe JSVal
x IO (Maybe JSVal) -> (Maybe JSVal -> IO (Maybe a)) -> IO (Maybe a)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Maybe JSVal
Nothing -> Maybe a -> IO (Maybe a)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing
    Just JSVal
y -> a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> IO a -> IO (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> JSVal -> IO a
forall a. FromJSVal a => JSVal -> IO a
fromJSValUnchecked JSVal
y
-----------------------------------------------------------------------------
-- | A class for creating arguments to a JS function
class ToArgs args where
  toArgs :: args -> IO [JSVal]
-----------------------------------------------------------------------------
instance ToArgs Double where
  toArgs :: Double -> IO [JSVal]
toArgs Double
x = (JSVal -> [JSVal] -> [JSVal]
forall a. a -> [a] -> [a]
:[]) (JSVal -> [JSVal]) -> IO JSVal -> IO [JSVal]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal Double
x
-----------------------------------------------------------------------------
instance ToArgs JSVal where
  toArgs :: JSVal -> IO [JSVal]
toArgs JSVal
val = [JSVal] -> IO [JSVal]
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [JSVal
val]
-----------------------------------------------------------------------------
instance ToObject JSVal where
  toObject :: JSVal -> IO Object
toObject = Object -> IO Object
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Object -> IO Object) -> (JSVal -> Object) -> JSVal -> IO Object
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSVal -> Object
Object
-----------------------------------------------------------------------------
-- | A class for creating JS objects.
class ToObject a where
  toObject :: a -> IO Object
  default toObject :: (Generic a, GToJSVal (Rep a)) => a -> IO Object
  toObject a
x = do
    o <- IO Object
create
    gToJSVal (from x) o
    pure o
-----------------------------------------------------------------------------
instance ToJSVal a => ToObject (IO a) where
  toObject :: IO a -> IO Object
toObject IO a
action = JSVal -> Object
Object (JSVal -> Object) -> IO JSVal -> IO Object
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal (a -> IO JSVal) -> IO a -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO a
action)
-----------------------------------------------------------------------------
instance ToArgs MisoString where
  toArgs :: MisoString -> IO [JSVal]
toArgs MisoString
arg = (JSVal -> [JSVal] -> [JSVal]
forall a. a -> [a] -> [a]
:[]) (JSVal -> [JSVal]) -> IO JSVal -> IO [JSVal]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MisoString -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal MisoString
arg
----------------------------------------------------------------------------
#ifndef VANILLA
----------------------------------------------------------------------------
instance ToJSVal MisoString where
  toJSVal = toJSVal_JSString
-----------------------------------------------------------------------------
instance FromJSVal MisoString where
  fromJSVal = fromJSVal_JSString
----------------------------------------------------------------------------
#endif
----------------------------------------------------------------------------
instance ToJSVal arg => ToArgs [arg] where
    toArgs :: [arg] -> IO [JSVal]
toArgs = (arg -> IO JSVal) -> [arg] -> IO [JSVal]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM arg -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal
----------------------------------------------------------------------------
instance ToArgs () where
  toArgs :: () -> IO [JSVal]
toArgs ()
_ = [JSVal] -> IO [JSVal]
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
----------------------------------------------------------------------------
instance ToArgs Int where
  toArgs :: Int -> IO [JSVal]
toArgs Int
k = (JSVal -> [JSVal] -> [JSVal]
forall a. a -> [a] -> [a]
:[]) (JSVal -> [JSVal]) -> IO JSVal -> IO [JSVal]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal Int
k
-----------------------------------------------------------------------------
instance ToArgs Function where
  toArgs :: Function -> IO [JSVal]
toArgs Function
k = (JSVal -> [JSVal] -> [JSVal]
forall a. a -> [a] -> [a]
:[]) (JSVal -> [JSVal]) -> IO JSVal -> IO [JSVal]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Function -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal Function
k
-----------------------------------------------------------------------------
instance ToArgs Bool where
  toArgs :: Bool -> IO [JSVal]
toArgs Bool
k = (JSVal -> [JSVal] -> [JSVal]
forall a. a -> [a] -> [a]
:[]) (JSVal -> [JSVal]) -> IO JSVal -> IO [JSVal]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal Bool
k
-----------------------------------------------------------------------------
instance ToArgs Object where
  toArgs :: Object -> IO [JSVal]
toArgs Object
k = (JSVal -> [JSVal] -> [JSVal]
forall a. a -> [a] -> [a]
:[]) (JSVal -> [JSVal]) -> IO JSVal -> IO [JSVal]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal Object
k
-----------------------------------------------------------------------------
instance ToArgs args => ToArgs (Maybe args) where
  toArgs :: Maybe args -> IO [JSVal]
toArgs (Just args
args) = args -> IO [JSVal]
forall args. ToArgs args => args -> IO [JSVal]
toArgs args
args
  toArgs Maybe args
Nothing     = [JSVal] -> IO [JSVal]
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
----------------------------------------------------------------------------
instance (ToJSVal arg1, ToJSVal arg2) => ToArgs (arg1, arg2) where
  toArgs :: (arg1, arg2) -> IO [JSVal]
toArgs (arg1
arg1, arg2
arg2) = do
    rarg1 <- arg1 -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal arg1
arg1
    rarg2 <- toJSVal arg2
    return [rarg1, rarg2]
----------------------------------------------------------------------------
instance (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3) => ToArgs (arg1, arg2, arg3) where
  toArgs :: (arg1, arg2, arg3) -> IO [JSVal]
toArgs (arg1
arg1, arg2
arg2, arg3
arg3) = do
    rarg1 <- arg1 -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal arg1
arg1
    rarg2 <- toJSVal arg2
    rarg3 <- toJSVal arg3
    return [rarg1, rarg2, rarg3]
----------------------------------------------------------------------------
instance (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4) => ToArgs (arg1, arg2, arg3, arg4) where
  toArgs :: (arg1, arg2, arg3, arg4) -> IO [JSVal]
toArgs (arg1
arg1, arg2
arg2, arg3
arg3, arg4
arg4) = do
    rarg1 <- arg1 -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal arg1
arg1
    rarg2 <- toJSVal arg2
    rarg3 <- toJSVal arg3
    rarg4 <- toJSVal arg4
    return [rarg1, rarg2, rarg3, rarg4]
----------------------------------------------------------------------------
instance (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4, ToJSVal arg5) => ToArgs (arg1, arg2, arg3, arg4, arg5) where
  toArgs :: (arg1, arg2, arg3, arg4, arg5) -> IO [JSVal]
toArgs (arg1
arg1, arg2
arg2, arg3
arg3, arg4
arg4, arg5
arg5) = do
    rarg1 <- arg1 -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal arg1
arg1
    rarg2 <- toJSVal arg2
    rarg3 <- toJSVal arg3
    rarg4 <- toJSVal arg4
    rarg5 <- toJSVal arg5
    return [rarg1, rarg2, rarg3, rarg4, rarg5]
----------------------------------------------------------------------------
instance (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4, ToJSVal arg5, ToJSVal arg6) => ToArgs (arg1, arg2, arg3, arg4, arg5, arg6) where
  toArgs :: (arg1, arg2, arg3, arg4, arg5, arg6) -> IO [JSVal]
toArgs (arg1
arg1, arg2
arg2, arg3
arg3, arg4
arg4, arg5
arg5, arg6
arg6) = do
    rarg1 <- arg1 -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal arg1
arg1
    rarg2 <- toJSVal arg2
    rarg3 <- toJSVal arg3
    rarg4 <- toJSVal arg4
    rarg5 <- toJSVal arg5
    rarg6 <- toJSVal arg6
    return [rarg1, rarg2, rarg3, rarg4, rarg5, rarg6]
----------------------------------------------------------------------------
-- | Frees references to a callback
freeFunction :: Function -> IO ()
freeFunction :: Function -> IO ()
freeFunction (Function JSVal
x) = JSVal -> IO ()
freeFunction_ffi JSVal
x
-----------------------------------------------------------------------------
instance FromJSVal Function where
  fromJSVal :: JSVal -> IO (Maybe Function)
fromJSVal = Maybe Function -> IO (Maybe Function)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Function -> IO (Maybe Function))
-> (JSVal -> Maybe Function) -> JSVal -> IO (Maybe Function)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Function -> Maybe Function
forall a. a -> Maybe a
Just (Function -> Maybe Function)
-> (JSVal -> Function) -> JSVal -> Maybe Function
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSVal -> Function
Function
-----------------------------------------------------------------------------
instance FromJSVal Object where
  fromJSVal :: JSVal -> IO (Maybe Object)
fromJSVal = Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Object -> IO (Maybe Object))
-> (JSVal -> Maybe Object) -> JSVal -> IO (Maybe Object)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object -> Maybe Object
forall a. a -> Maybe a
Just (Object -> Maybe Object)
-> (JSVal -> Object) -> JSVal -> Maybe Object
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSVal -> Object
Object
-----------------------------------------------------------------------------
-- | Lookup a property based on its index
(!!) :: ToObject object => object -> Int -> IO JSVal
!! :: forall object. ToObject object => object -> Int -> IO JSVal
(!!) object
o Int
k = Int -> JSVal -> IO JSVal
getPropIndex_ffi Int
k (JSVal -> IO JSVal) -> IO JSVal -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal (Object -> IO JSVal) -> IO Object -> IO JSVal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< object -> IO Object
forall a. ToObject a => a -> IO Object
toObject object
o
-----------------------------------------------------------------------------
-- | Checks if a t'JSVal' is undefined
isUndefined :: ToJSVal val => val -> IO Bool
isUndefined :: forall val. ToJSVal val => val -> IO Bool
isUndefined val
val = JSVal -> Bool
isUndefined_ffi (JSVal -> Bool) -> IO JSVal -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> val -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal val
val
-----------------------------------------------------------------------------
-- | Checks if a t'JSVal' is null
isNull :: ToJSVal val => val -> IO Bool
isNull :: forall val. ToJSVal val => val -> IO Bool
isNull val
val = JSVal -> Bool
isNull_ffi (JSVal -> Bool) -> IO JSVal -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> val -> IO JSVal
forall a. ToJSVal a => a -> IO JSVal
toJSVal val
val
-----------------------------------------------------------------------------
-- | A JS Object
newtype Object = Object { Object -> JSVal
unObject :: JSVal } deriving newtype (Object -> IO JSVal
(Object -> IO JSVal) -> ToJSVal Object
forall a. (a -> IO JSVal) -> ToJSVal a
$ctoJSVal :: Object -> IO JSVal
toJSVal :: Object -> IO JSVal
ToJSVal, Object -> Object -> Bool
(Object -> Object -> Bool)
-> (Object -> Object -> Bool) -> Eq Object
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Object -> Object -> Bool
== :: Object -> Object -> Bool
$c/= :: Object -> Object -> Bool
/= :: Object -> Object -> Bool
Eq)
-----------------------------------------------------------------------------
-- | A JS Functionn
newtype Function = Function { Function -> JSVal
unFunction :: JSVal } deriving newtype (Function -> IO JSVal
(Function -> IO JSVal) -> ToJSVal Function
forall a. (a -> IO JSVal) -> ToJSVal a
$ctoJSVal :: Function -> IO JSVal
toJSVal :: Function -> IO JSVal
ToJSVal, Function -> Function -> Bool
(Function -> Function -> Bool)
-> (Function -> Function -> Bool) -> Eq Function
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Function -> Function -> Bool
== :: Function -> Function -> Bool
$c/= :: Function -> Function -> Bool
/= :: Function -> Function -> Bool
Eq)
-----------------------------------------------------------------------------
instance (FromJSVal a, FromJSVal b) => FromJSVal (a,b) where
    fromJSVal :: JSVal -> IO (Maybe (a, b))
fromJSVal JSVal
r = MaybeT IO (a, b) -> IO (Maybe (a, b))
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT IO (a, b) -> IO (Maybe (a, b)))
-> MaybeT IO (a, b) -> IO (Maybe (a, b))
forall a b. (a -> b) -> a -> b
$ (,) (a -> b -> (a, b)) -> MaybeT IO a -> MaybeT IO (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> JSVal -> Int -> MaybeT IO a
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
0 MaybeT IO (b -> (a, b)) -> MaybeT IO b -> MaybeT IO (a, b)
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO b
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
1
    {-# INLINE fromJSVal #-}
instance (FromJSVal a, FromJSVal b, FromJSVal c) => FromJSVal (a,b,c) where
    fromJSVal :: JSVal -> IO (Maybe (a, b, c))
fromJSVal JSVal
r = MaybeT IO (a, b, c) -> IO (Maybe (a, b, c))
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT IO (a, b, c) -> IO (Maybe (a, b, c)))
-> MaybeT IO (a, b, c) -> IO (Maybe (a, b, c))
forall a b. (a -> b) -> a -> b
$ (,,) (a -> b -> c -> (a, b, c))
-> MaybeT IO a -> MaybeT IO (b -> c -> (a, b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> JSVal -> Int -> MaybeT IO a
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
0 MaybeT IO (b -> c -> (a, b, c))
-> MaybeT IO b -> MaybeT IO (c -> (a, b, c))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO b
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
1 MaybeT IO (c -> (a, b, c)) -> MaybeT IO c -> MaybeT IO (a, b, c)
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO c
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
2
    {-# INLINE fromJSVal #-}
instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d) => FromJSVal (a,b,c,d) where
    fromJSVal :: JSVal -> IO (Maybe (a, b, c, d))
fromJSVal JSVal
r = MaybeT IO (a, b, c, d) -> IO (Maybe (a, b, c, d))
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT IO (a, b, c, d) -> IO (Maybe (a, b, c, d)))
-> MaybeT IO (a, b, c, d) -> IO (Maybe (a, b, c, d))
forall a b. (a -> b) -> a -> b
$ (,,,) (a -> b -> c -> d -> (a, b, c, d))
-> MaybeT IO a -> MaybeT IO (b -> c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> JSVal -> Int -> MaybeT IO a
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
0 MaybeT IO (b -> c -> d -> (a, b, c, d))
-> MaybeT IO b -> MaybeT IO (c -> d -> (a, b, c, d))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO b
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
1 MaybeT IO (c -> d -> (a, b, c, d))
-> MaybeT IO c -> MaybeT IO (d -> (a, b, c, d))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO c
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
2 MaybeT IO (d -> (a, b, c, d))
-> MaybeT IO d -> MaybeT IO (a, b, c, d)
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO d
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
3
    {-# INLINE fromJSVal #-}
instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d, FromJSVal e) => FromJSVal (a,b,c,d,e) where
    fromJSVal :: JSVal -> IO (Maybe (a, b, c, d, e))
fromJSVal JSVal
r = MaybeT IO (a, b, c, d, e) -> IO (Maybe (a, b, c, d, e))
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT IO (a, b, c, d, e) -> IO (Maybe (a, b, c, d, e)))
-> MaybeT IO (a, b, c, d, e) -> IO (Maybe (a, b, c, d, e))
forall a b. (a -> b) -> a -> b
$ (,,,,) (a -> b -> c -> d -> e -> (a, b, c, d, e))
-> MaybeT IO a -> MaybeT IO (b -> c -> d -> e -> (a, b, c, d, e))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> JSVal -> Int -> MaybeT IO a
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
0 MaybeT IO (b -> c -> d -> e -> (a, b, c, d, e))
-> MaybeT IO b -> MaybeT IO (c -> d -> e -> (a, b, c, d, e))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO b
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
1 MaybeT IO (c -> d -> e -> (a, b, c, d, e))
-> MaybeT IO c -> MaybeT IO (d -> e -> (a, b, c, d, e))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO c
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
2 MaybeT IO (d -> e -> (a, b, c, d, e))
-> MaybeT IO d -> MaybeT IO (e -> (a, b, c, d, e))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO d
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
3 MaybeT IO (e -> (a, b, c, d, e))
-> MaybeT IO e -> MaybeT IO (a, b, c, d, e)
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO e
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
4
    {-# INLINE fromJSVal #-}
instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d, FromJSVal e, FromJSVal f) => FromJSVal (a,b,c,d,e,f) where
    fromJSVal :: JSVal -> IO (Maybe (a, b, c, d, e, f))
fromJSVal JSVal
r = MaybeT IO (a, b, c, d, e, f) -> IO (Maybe (a, b, c, d, e, f))
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT IO (a, b, c, d, e, f) -> IO (Maybe (a, b, c, d, e, f)))
-> MaybeT IO (a, b, c, d, e, f) -> IO (Maybe (a, b, c, d, e, f))
forall a b. (a -> b) -> a -> b
$ (,,,,,) (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> MaybeT IO a
-> MaybeT IO (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> JSVal -> Int -> MaybeT IO a
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
0 MaybeT IO (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> MaybeT IO b
-> MaybeT IO (c -> d -> e -> f -> (a, b, c, d, e, f))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO b
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
1 MaybeT IO (c -> d -> e -> f -> (a, b, c, d, e, f))
-> MaybeT IO c -> MaybeT IO (d -> e -> f -> (a, b, c, d, e, f))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO c
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
2 MaybeT IO (d -> e -> f -> (a, b, c, d, e, f))
-> MaybeT IO d -> MaybeT IO (e -> f -> (a, b, c, d, e, f))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO d
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
3 MaybeT IO (e -> f -> (a, b, c, d, e, f))
-> MaybeT IO e -> MaybeT IO (f -> (a, b, c, d, e, f))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO e
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
4 MaybeT IO (f -> (a, b, c, d, e, f))
-> MaybeT IO f -> MaybeT IO (a, b, c, d, e, f)
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO f
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
5
    {-# INLINE fromJSVal #-}
instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d, FromJSVal e, FromJSVal f, FromJSVal g) => FromJSVal (a,b,c,d,e,f,g) where
    fromJSVal :: JSVal -> IO (Maybe (a, b, c, d, e, f, g))
fromJSVal JSVal
r = MaybeT IO (a, b, c, d, e, f, g) -> IO (Maybe (a, b, c, d, e, f, g))
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT IO (a, b, c, d, e, f, g)
 -> IO (Maybe (a, b, c, d, e, f, g)))
-> MaybeT IO (a, b, c, d, e, f, g)
-> IO (Maybe (a, b, c, d, e, f, g))
forall a b. (a -> b) -> a -> b
$ (,,,,,,) (a -> b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> MaybeT IO a
-> MaybeT IO (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> JSVal -> Int -> MaybeT IO a
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
0 MaybeT IO (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> MaybeT IO b
-> MaybeT IO (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO b
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
1 MaybeT IO (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> MaybeT IO c
-> MaybeT IO (d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO c
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
2 MaybeT IO (d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> MaybeT IO d -> MaybeT IO (e -> f -> g -> (a, b, c, d, e, f, g))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO d
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
3 MaybeT IO (e -> f -> g -> (a, b, c, d, e, f, g))
-> MaybeT IO e -> MaybeT IO (f -> g -> (a, b, c, d, e, f, g))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO e
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
4 MaybeT IO (f -> g -> (a, b, c, d, e, f, g))
-> MaybeT IO f -> MaybeT IO (g -> (a, b, c, d, e, f, g))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO f
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
5 MaybeT IO (g -> (a, b, c, d, e, f, g))
-> MaybeT IO g -> MaybeT IO (a, b, c, d, e, f, g)
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO g
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
6
    {-# INLINE fromJSVal #-}
instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d, FromJSVal e, FromJSVal f, FromJSVal g, FromJSVal h) => FromJSVal (a,b,c,d,e,f,g,h) where
    fromJSVal :: JSVal -> IO (Maybe (a, b, c, d, e, f, g, h))
fromJSVal JSVal
r = MaybeT IO (a, b, c, d, e, f, g, h)
-> IO (Maybe (a, b, c, d, e, f, g, h))
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT IO (a, b, c, d, e, f, g, h)
 -> IO (Maybe (a, b, c, d, e, f, g, h)))
-> MaybeT IO (a, b, c, d, e, f, g, h)
-> IO (Maybe (a, b, c, d, e, f, g, h))
forall a b. (a -> b) -> a -> b
$ (,,,,,,,) (a -> b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> MaybeT IO a
-> MaybeT
     IO (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> JSVal -> Int -> MaybeT IO a
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
0 MaybeT
  IO (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> MaybeT IO b
-> MaybeT
     IO (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO b
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
1 MaybeT IO (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> MaybeT IO c
-> MaybeT IO (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO c
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
2 MaybeT IO (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> MaybeT IO d
-> MaybeT IO (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO d
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
3 MaybeT IO (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> MaybeT IO e
-> MaybeT IO (f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO e
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
4 MaybeT IO (f -> g -> h -> (a, b, c, d, e, f, g, h))
-> MaybeT IO f -> MaybeT IO (g -> h -> (a, b, c, d, e, f, g, h))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO f
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
5 MaybeT IO (g -> h -> (a, b, c, d, e, f, g, h))
-> MaybeT IO g -> MaybeT IO (h -> (a, b, c, d, e, f, g, h))
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO g
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
6 MaybeT IO (h -> (a, b, c, d, e, f, g, h))
-> MaybeT IO h -> MaybeT IO (a, b, c, d, e, f, g, h)
forall a b. MaybeT IO (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> JSVal -> Int -> MaybeT IO h
forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
7
    {-# INLINE fromJSVal #-}
-----------------------------------------------------------------------------
jf :: FromJSVal a => JSVal -> Int -> MaybeT IO a
jf :: forall a. FromJSVal a => JSVal -> Int -> MaybeT IO a
jf JSVal
r Int
n = IO (Maybe a) -> MaybeT IO a
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (IO (Maybe a) -> MaybeT IO a) -> IO (Maybe a) -> MaybeT IO a
forall a b. (a -> b) -> a -> b
$ do
  x <- Int -> JSVal -> IO JSVal
getPropIndex_ffi Int
n JSVal
r
  if isUndefined_ffi r
    then return Nothing
    else fromJSVal x
-----------------------------------------------------------------------------