Use Data.Foreign.unsafeReadTagged for coercions

This replaces the usage of the FFI for type coercions with
Data.Foreign.

Author: ianbollinger

src/DOM/Event/CompositionEvent.js

@@ -1,14 +1,5 @@
-/* global CompositionEvent */
 "use strict";
 
-exports._eventToCompositionEvent = function (just) {
-  return function (nothing) {
-    return function (e) {
-      return e instanceof CompositionEvent ? just(e) : nothing;
-    };
-  };
-};
-
 exports.data_ = function (e) {
   return e.data;
 };

src/DOM/Event/CompositionEvent.purs

@@ -4,18 +4,12 @@ module DOM.Event.CompositionEvent (
     data_
     ) where
 
-import Data.Maybe (Maybe(..))
-import DOM.Event.Types (CompositionEvent, Event)
+import Prelude
+import Data.Foreign (F, toForeign)
+import DOM.Event.Types (CompositionEvent, Event, readCompositionEvent)
 import DOM.Event.Types (CompositionEvent, compositionEventToEvent, readCompositionEvent) as T
 
-eventToCompositionEvent :: Event -> Maybe CompositionEvent
-eventToCompositionEvent = _eventToCompositionEvent Just Nothing
-
-foreign import _eventToCompositionEvent
-  :: forall a
-   . (a -> Maybe a)
-  -> Maybe a
-  -> Event
-  -> Maybe CompositionEvent
+eventToCompositionEvent :: Event -> F CompositionEvent
+eventToCompositionEvent = readCompositionEvent <<< toForeign
 
 foreign import data_ :: CompositionEvent -> String

src/DOM/Event/FocusEvent.js

@@ -1,14 +1,5 @@
-/* global FocusEvent */
 "use strict";
 
-exports._eventToFocusEvent = function (just) {
-  return function (nothing) {
-    return function (e) {
-      return e instanceof FocusEvent ? just(e) : nothing;
-    };
-  };
-};
-
 exports.relatedTargetNullable = function (e) {
   return e.relatedTarget;
 };

src/DOM/Event/FocusEvent.purs

@@ -5,20 +5,14 @@ module DOM.Event.FocusEvent
   ) where
 
 import Prelude
-import Data.Maybe (Maybe (..))
+import Data.Foreign (F, toForeign)
+import Data.Maybe (Maybe)
 import Data.Nullable (Nullable, toMaybe)
-import DOM.Event.Types (Event, EventTarget, FocusEvent)
+import DOM.Event.Types (Event, EventTarget, FocusEvent, readFocusEvent)
 import DOM.Event.Types (FocusEvent, focusEventToEvent, readFocusEvent) as T
 
-eventToFocusEvent :: Event -> Maybe FocusEvent
-eventToFocusEvent = _eventToFocusEvent Just Nothing
-
-foreign import _eventToFocusEvent
-  :: forall a
-   . (a -> Maybe a)
-  -> Maybe a
-  -> Event
-  -> Maybe FocusEvent
+eventToFocusEvent :: Event -> F FocusEvent
+eventToFocusEvent = readFocusEvent <<< toForeign
 
 foreign import relatedTargetNullable :: FocusEvent -> Nullable EventTarget
 

src/DOM/Event/KeyboardEvent.js

@@ -1,14 +1,5 @@
-/* global KeyboardEvent */
 "use strict";
 
-exports._eventToKeyboardEvent = function (just) {
-  return function (nothing) {
-    return function (e) {
-      return e instanceof KeyboardEvent ? just(e) : nothing;
-    };
-  };
-};
-
 exports.key = function (e) {
   return e.key;
 };

src/DOM/Event/KeyboardEvent.purs

@@ -20,20 +20,14 @@ module DOM.Event.KeyboardEvent
 import Prelude
 import Control.Monad.Eff (Eff)
 import Data.Enum (class BoundedEnum, class Enum, Cardinality(..), defaultPred, defaultSucc, toEnum)
+import Data.Foreign (F, toForeign)
 import Data.Maybe (Maybe(..), fromJust)
 import DOM (DOM)
-import DOM.Event.Types (Event, KeyboardEvent)
+import DOM.Event.Types (Event, KeyboardEvent, readKeyboardEvent)
 import DOM.Event.Types (KeyboardEvent, keyboardEventToEvent, readKeyboardEvent) as T
 
-eventToKeyboardEvent :: Event -> Maybe KeyboardEvent
-eventToKeyboardEvent = _eventToKeyboardEvent Just Nothing
-
-foreign import _eventToKeyboardEvent
-  :: forall a
-   . (a -> Maybe a)
-  -> Maybe a
-  -> Event
-  -> Maybe KeyboardEvent
+eventToKeyboardEvent :: Event -> F KeyboardEvent
+eventToKeyboardEvent = readKeyboardEvent <<< toForeign
 
 foreign import key :: KeyboardEvent -> String
 

src/DOM/Event/MouseEvent.js

@@ -1,14 +1,5 @@
-/* global MouseEvent */
 "use strict";
 
-exports._eventToMouseEvent = function (just) {
-  return function (nothing) {
-    return function (e) {
-      return e instanceof MouseEvent ? just(e) : nothing;
-    };
-  };
-};
-
 exports.screenX = function (e) {
   return e.screenX;
 };

src/DOM/Event/MouseEvent.purs

@@ -17,21 +17,15 @@ module DOM.Event.MouseEvent
 
 import Prelude
 import Control.Monad.Eff (Eff)
-import Data.Maybe (Maybe(..))
+import Data.Foreign (F, toForeign)
+import Data.Maybe (Maybe)
 import Data.Nullable (Nullable, toMaybe)
 import DOM (DOM)
-import DOM.Event.Types (Event, EventTarget, MouseEvent)
+import DOM.Event.Types (Event, EventTarget, MouseEvent, readMouseEvent)
 import DOM.Event.Types (MouseEvent, mouseEventToEvent, readMouseEvent) as T
 
-eventToMouseEvent :: Event -> Maybe MouseEvent
-eventToMouseEvent = _eventToMouseEvent Just Nothing
-
-foreign import _eventToMouseEvent
-  :: forall a
-   . (a -> Maybe a)
-  -> Maybe a
-  -> Event
-  -> Maybe MouseEvent
+eventToMouseEvent :: Event -> F MouseEvent
+eventToMouseEvent = readMouseEvent <<< toForeign
 
 foreign import screenX :: MouseEvent -> Int
 

src/DOM/Event/WheelEvent.js

@@ -1,14 +1,5 @@
-/* global WheelEvent */
 "use strict";
 
-exports._eventToWheelEvent = function (just) {
-  return function (nothing) {
-    return function (e) {
-      return e instanceof WheelEvent ? just(e) : nothing;
-    };
-  };
-};
-
 exports.deltaX = function (e) {
   return e.deltaX;
 };

src/DOM/Event/WheelEvent.purs

@@ -13,19 +13,13 @@ module DOM.Event.WheelEvent
 
 import Prelude
 import Data.Enum (class BoundedEnum, class Enum, Cardinality(..), defaultPred, defaultSucc, toEnum)
+import Data.Foreign (F, toForeign)
 import Data.Maybe (Maybe(..), fromJust)
-import DOM.Event.Types (Event, WheelEvent)
+import DOM.Event.Types (Event, WheelEvent, readWheelEvent)
 import DOM.Event.Types (WheelEvent, readWheelEvent, wheelEventToEvent) as T
 
-eventToWheelEvent :: Event -> Maybe WheelEvent
-eventToWheelEvent = _eventToWheelEvent Just Nothing
-
-foreign import _eventToWheelEvent
-  :: forall a
-   . (a -> Maybe a)
-  -> Maybe a
-  -> Event
-  -> Maybe WheelEvent
+eventToWheelEvent :: Event -> F WheelEvent
+eventToWheelEvent = readWheelEvent <<< toForeign
 
 foreign import deltaX :: WheelEvent -> Number