Merge pull request #141 from gabejohnson/eff->effect

Remove `Eff` in favor of `Effect`

Author: garyb

bower.json

@@ -1,7 +1,7 @@
 {
   "name": "purescript-dom",
   "homepage": "https://github.com/purescript-web/purescript-dom",
-  "description": "PureScript type definitions and effect for interacting with the DOM",
+  "description": "PureScript type definitions for interacting with the DOM",
   "keywords": [
     "purescript"
   ],
@@ -30,7 +30,8 @@
     "purescript-media-types": "^3.0.0",
     "purescript-nullable": "^3.0.0",
     "purescript-prelude": "^3.0.0",
-    "purescript-unsafe-coerce": "^3.0.0"
+    "purescript-unsafe-coerce": "^3.0.0",
+    "purescript-effect": "^0.1.0"
   },
   "devDependencies": {
     "purescript-test-unit": "^11.0.0",

src/DOM.purs

@@ -4,10 +4,9 @@ module DOM.Event.Event
   ) where
 
 import Prelude
-import Control.Monad.Eff (Eff)
+import Control.Monad.Effect (Effect)
 import Data.Enum (toEnum)
 import Data.Maybe (fromJust)
-import DOM (DOM)
 import DOM.Event.EventPhase (EventPhase)
 import DOM.Event.Types (Event, EventType)
 import DOM.Event.Types (Event) as T
@@ -32,17 +31,11 @@ foreign import eventPhaseIndex :: Event -> Int
 
 -- | Prevents the event from bubbling up to futher event listeners. Other event
 -- | listeners on the current target will still fire.
-foreign import stopPropagation
-  :: forall eff
-   . Event
-  -> Eff (dom :: DOM | eff) Unit
+foreign import stopPropagation :: Event -> Effect Unit
 
 -- | Prevents all other listeners for the event from being called. This includes
 -- | event listeners added to the current target after the current listener.
-foreign import stopImmediatePropagation
-  :: forall eff
-   . Event
-  -> Eff (dom :: DOM | eff) Unit
+foreign import stopImmediatePropagation :: Event -> Effect Unit
 
 -- | Indicates whether the event will bubble up through the DOM or not.
 foreign import bubbles :: Event -> Boolean
@@ -51,10 +44,7 @@ foreign import bubbles :: Event -> Boolean
 foreign import cancelable :: Event -> Boolean
 
 -- | Cancels the event if it can be cancelled.
-foreign import preventDefault
-  :: forall eff
-   . Event
-  -> Eff (dom :: DOM | eff) Unit
+foreign import preventDefault :: Event -> Effect Unit
 
 -- | Indicates whether `preventDefault` was called on the event.
 foreign import defaultPrevented :: Event -> Boolean

src/DOM/Event/Event.purs

@@ -2,7 +2,7 @@
 
 exports.eventListener = function (fn) {
   return function (event) {
-    return fn(event)();
+    return fn(event);
   };
 };
 

src/DOM/Event/EventTarget.js

@@ -1,44 +1,39 @@
 module DOM.Event.EventTarget where
 
 import Prelude
-import Control.Monad.Eff (kind Effect, Eff)
-import Control.Monad.Eff.Exception (EXCEPTION)
-import DOM (DOM)
+import Control.Monad.Effect (Effect)
 import DOM.Event.Types (EventTarget, Event, EventType)
 
 -- | A boxed function that can be used as an event listener. This is necessary
--- | due to the underlying implementation of Eff functions.
-foreign import data EventListener :: # Effect -> Type
+-- | due to the underlying implementation of Effect functions.
+foreign import data EventListener :: Type
 
--- | Creates an EventListener from a normal PureScript Eff function.
+-- | Creates an EventListener from a normal PureScript Effect function.
 foreign import eventListener
-  :: forall eff a
-   . (Event -> Eff eff a)
-  -> EventListener eff
+  :: forall a
+   . (Event -> Effect a)
+  -> Effect EventListener
 
 -- | Adds a listener to an event target. The boolean argument indicates whether
 -- | the listener should be added for the "capture" phase.
 foreign import addEventListener
-  :: forall eff
-   . EventType
-  -> EventListener (dom :: DOM | eff)
+  :: EventType
+  -> EventListener
   -> Boolean
   -> EventTarget
-  -> Eff (dom :: DOM | eff) Unit
+  -> Effect Unit
 
 -- | Removes a listener to an event target. The boolean argument indicates
 -- | whether the listener should be removed for the "capture" phase.
 foreign import removeEventListener
-  :: forall eff
-   . EventType
-  -> EventListener (dom :: DOM | eff)
+  :: EventType
+  -> EventListener
   -> Boolean
   -> EventTarget
-  -> Eff (dom :: DOM | eff) Unit
+  -> Effect Unit
 
 -- | Dispatches an event from an event target.
 foreign import dispatchEvent
-  :: forall eff
-   . Event
+  :: Event
   -> EventTarget
-  -> Eff (dom :: DOM, err :: EXCEPTION | eff) Boolean
+  -> Effect Boolean

src/DOM/Event/EventTarget.purs

@@ -32,11 +32,10 @@ module DOM.Event.KeyboardEvent
   ) where
 
 import Prelude
-import Control.Monad.Eff (Eff)
+import Control.Monad.Effect (Effect)
 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, readKeyboardEvent)
 import DOM.Event.Types (KeyboardEvent, keyboardEventToEvent, readKeyboardEvent) as T
 
@@ -108,7 +107,6 @@ foreign import repeat :: KeyboardEvent -> Boolean
 foreign import isComposing :: KeyboardEvent -> Boolean
 
 foreign import getModifierState
-  :: forall eff
-   . String
+  :: String
   -> KeyboardEvent
-  -> Eff (dom :: DOM | eff) Boolean
+  -> Effect Boolean

src/DOM/Event/KeyboardEvent.purs

@@ -18,11 +18,10 @@ module DOM.Event.MouseEvent
   ) where
 
 import Prelude
-import Control.Monad.Eff (Eff)
+import Control.Monad.Effect (Effect)
 import Data.Foreign (F, toForeign)
 import Data.Maybe (Maybe)
 import Data.Nullable (Nullable, toMaybe)
-import DOM (DOM)
 import DOM.Event.Types (Event, EventTarget, MouseEvent, readMouseEvent)
 import DOM.Event.Types (MouseEvent, mouseEventToEvent, readMouseEvent) as T
 
@@ -59,7 +58,6 @@ relatedTarget = toMaybe <$> _relatedTarget
 foreign import buttons :: MouseEvent -> Int
 
 foreign import getModifierState
-  :: forall eff
-   . String
+  :: String
   -> MouseEvent
-  -> Eff (dom :: DOM | eff) Boolean
+  -> Effect Boolean

src/DOM/Event/MouseEvent.purs

@@ -9,31 +9,30 @@ module DOM.File.FileReader
   ) where
 
 import Prelude
-import Control.Monad.Eff (Eff)
-import DOM (DOM)
+import Control.Monad.Effect (Effect)
 import DOM.File.FileReader.ReadyState (toEnumReadyState, ReadyState)
 import DOM.File.Types (Blob, FileReader)
 import Data.Foreign (Foreign)
 import Data.Maybe (fromJust)
 import Partial.Unsafe (unsafePartial)
 
-foreign import fileReader :: forall eff. Eff (dom :: DOM | eff) FileReader
+foreign import fileReader :: Effect FileReader
 
-foreign import error :: forall eff. FileReader -> Eff (dom :: DOM | eff) Foreign
+foreign import error :: FileReader -> Effect Foreign
 
-foreign import readyStateImpl :: forall eff. FileReader -> Eff (dom :: DOM | eff) Int
+foreign import readyStateImpl :: FileReader -> Effect Int
 
-readyState :: forall eff. FileReader -> Eff (dom :: DOM | eff) ReadyState
+readyState :: FileReader -> Effect ReadyState
 readyState fr = do
   rs <- readyStateImpl fr
   pure $ unsafePartial $ fromJust $ toEnumReadyState rs
 
-foreign import result :: forall eff. FileReader -> Eff (dom :: DOM | eff) Foreign
+foreign import result :: FileReader -> Effect Foreign
 
-foreign import abort :: FileReader -> forall eff. Eff (dom :: DOM | eff) Unit
+foreign import abort :: FileReader -> Effect Unit
 
-foreign import readAsText :: Blob -> FileReader -> forall eff. Eff (dom :: DOM | eff) Unit
+foreign import readAsText :: Blob -> FileReader -> Effect Unit
 
-foreign import readAsArrayBuffer :: Blob -> FileReader -> forall eff. Eff (dom :: DOM | eff) Unit
+foreign import readAsArrayBuffer :: Blob -> FileReader -> Effect Unit
 
-foreign import readAsDataURL :: Blob -> FileReader -> forall eff. Eff (dom :: DOM | eff) Unit
+foreign import readAsDataURL :: Blob -> FileReader -> Effect Unit

src/DOM/File/FileReader.purs

@@ -1,7 +1,6 @@
 module DOM.HTML where
 
-import Control.Monad.Eff (Eff)
-import DOM (DOM)
+import Control.Monad.Effect (Effect)
 import DOM.HTML.Types (Window)
 
-foreign import window :: forall eff. Eff (dom :: DOM | eff) Window
+foreign import window :: Effect Window

src/DOM/HTML.purs

@@ -7,26 +7,25 @@ module DOM.HTML.Document
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import DOM (DOM)
+import Control.Monad.Effect (Effect)
 import DOM.HTML.Document.ReadyState (ReadyState(..)) as Exports
 import DOM.HTML.Document.ReadyState (ReadyState, parseReadyState)
 import DOM.HTML.Types (HTMLElement, HTMLDocument)
 import Data.Maybe (Maybe, fromJust)
 import Data.Nullable (Nullable, toMaybe)
 import Partial.Unsafe (unsafePartial)
 
-foreign import _body :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) (Nullable HTMLElement)
+foreign import _body :: HTMLDocument -> Effect (Nullable HTMLElement)
 
-body :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) (Maybe HTMLElement)
+body :: HTMLDocument -> Effect (Maybe HTMLElement)
 body = map toMaybe <<< _body
 
-foreign import _readyState :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) String
+foreign import _readyState :: HTMLDocument -> Effect String
 
-readyState :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) ReadyState
+readyState :: HTMLDocument -> Effect ReadyState
 readyState = map (unsafePartial fromJust <<< parseReadyState) <<< _readyState
 
-foreign import _activeElement :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) (Nullable HTMLElement)
+foreign import _activeElement :: HTMLDocument -> Effect (Nullable HTMLElement)
 
-activeElement :: forall eff. HTMLDocument -> Eff (dom :: DOM | eff) (Maybe HTMLElement)
+activeElement :: HTMLDocument -> Effect (Maybe HTMLElement)
 activeElement = map toMaybe <<< _activeElement

src/DOM/HTML/Document.purs

@@ -11,8 +11,7 @@ module DOM.HTML.Event.DataTransfer
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import DOM (DOM)
+import Control.Monad.Effect (Effect)
 import DOM.File.Types (FileList)
 import Data.Maybe (Maybe)
 import Data.MediaType (MediaType(..))
@@ -37,46 +36,43 @@ foreign import _files :: DataTransfer -> Nullable FileList
 foreign import types :: DataTransfer -> Array String
 
 foreign import getDataImpl
-  :: forall eff
-   . String
+  :: String
   -> DataTransfer
-  -> Eff (dom :: DOM | eff) String
+  -> Effect String
 
 -- | Retrieves the data for a given media type, or an empty string if data for
 -- | that type does not exist or the data transfer object contains no data.
 getData
-  :: forall eff. MediaType -> DataTransfer -> Eff (dom :: DOM | eff) String
+  :: MediaType -> DataTransfer -> Effect String
 getData (MediaType format) dt = getDataImpl format dt
 
 foreign import setDataImpl
-  :: forall eff
-   . String
+  :: String
   -> String
   -> DataTransfer
-  -> Eff (dom :: DOM | eff) Unit
+  -> Effect Unit
 
 -- | Sets the data transfer object's data for a given media format.
 -- |
 -- | Example:
 -- |
 -- |     setData textPlain "Foo" dataTransfer
 setData
-  :: forall eff
-   . MediaType
+  :: MediaType
   -> String
   -> DataTransfer
-  -> Eff (dom :: DOM | eff) Unit
+  -> Effect Unit
 setData (MediaType format) dat dt = setDataImpl format dat dt
 
-foreign import dropEffectImpl :: forall eff. DataTransfer -> Eff (dom :: DOM | eff) String
+foreign import dropEffectImpl :: DataTransfer -> Effect String
 
 data DropEffect = Copy | Link | Move | None
 
 derive instance eqDropEffect :: Eq DropEffect
 derive instance ordDropEffect :: Ord DropEffect
 
 --| Gets the data transfer object's drop effect.
-dropEffect :: forall eff. DataTransfer -> Eff (dom :: DOM | eff) DropEffect
+dropEffect :: DataTransfer -> Effect DropEffect
 dropEffect dt = do
   de <- dropEffectImpl dt
   pure $ unsafePartial $ case de of
@@ -86,10 +82,10 @@ dropEffect dt = do
     "none" -> None
     _ -> crashWith "Impossible according to https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/dropEffect"
 
-foreign import setDropEffectImpl :: forall eff. String -> DataTransfer -> Eff (dom :: DOM | eff) Unit
+foreign import setDropEffectImpl :: String -> DataTransfer -> Effect Unit
 
 --| Sets the data transfer object's drop effect.
-setDropEffect :: forall eff. DropEffect -> DataTransfer -> Eff (dom :: DOM | eff) Unit
+setDropEffect :: DropEffect -> DataTransfer -> Effect Unit
 setDropEffect de = setDropEffectImpl case de of
   Copy -> "copy"
   Link -> "link"

src/DOM/HTML/Event/DataTransfer.purs

@@ -2,31 +2,30 @@ module DOM.HTML.HTMLAnchorElement where
 
 import Prelude (Unit)
 
-import Control.Monad.Eff (Eff)
+import Control.Monad.Effect (Effect)
 
-import DOM (DOM)
 import DOM.HTML.Types (HTMLAnchorElement)
 import DOM.Node.Types (DOMTokenList)
 
-foreign import target :: forall eff. HTMLAnchorElement -> Eff (dom :: DOM | eff) String
-foreign import setTarget :: forall eff. String -> HTMLAnchorElement -> Eff (dom :: DOM | eff) Unit
+foreign import target :: HTMLAnchorElement -> Effect String
+foreign import setTarget :: String -> HTMLAnchorElement -> Effect Unit
 
-foreign import download :: forall eff. HTMLAnchorElement -> Eff (dom :: DOM | eff) String
-foreign import setDownload :: forall eff. String -> HTMLAnchorElement -> Eff (dom :: DOM | eff) Unit
+foreign import download :: HTMLAnchorElement -> Effect String
+foreign import setDownload :: String -> HTMLAnchorElement -> Effect Unit
 
-foreign import rel :: forall eff. HTMLAnchorElement -> Eff (dom :: DOM | eff) String
-foreign import setRel :: forall eff. String -> HTMLAnchorElement -> Eff (dom :: DOM | eff) Unit
+foreign import rel :: HTMLAnchorElement -> Effect String
+foreign import setRel :: String -> HTMLAnchorElement -> Effect Unit
 
-foreign import rev :: forall eff. HTMLAnchorElement -> Eff (dom :: DOM | eff) String
-foreign import setRev :: forall eff. String -> HTMLAnchorElement -> Eff (dom :: DOM | eff) Unit
+foreign import rev :: HTMLAnchorElement -> Effect String
+foreign import setRev :: String -> HTMLAnchorElement -> Effect Unit
 
-foreign import relList :: forall eff. HTMLAnchorElement -> Eff (dom :: DOM | eff) DOMTokenList
+foreign import relList :: HTMLAnchorElement -> Effect DOMTokenList
 
-foreign import hreflang :: forall eff. HTMLAnchorElement -> Eff (dom :: DOM | eff) String
-foreign import setHreflang :: forall eff. String -> HTMLAnchorElement -> Eff (dom :: DOM | eff) Unit
+foreign import hreflang :: HTMLAnchorElement -> Effect String
+foreign import setHreflang :: String -> HTMLAnchorElement -> Effect Unit
 
-foreign import type_ :: forall eff. HTMLAnchorElement -> Eff (dom :: DOM | eff) String
-foreign import setType :: forall eff. String -> HTMLAnchorElement -> Eff (dom :: DOM | eff) Unit
+foreign import type_ :: HTMLAnchorElement -> Effect String
+foreign import setType :: String -> HTMLAnchorElement -> Effect Unit
 
-foreign import text :: forall eff. HTMLAnchorElement -> Eff (dom :: DOM | eff) String
-foreign import setText :: forall eff. String -> HTMLAnchorElement -> Eff (dom :: DOM | eff) Unit
+foreign import text :: HTMLAnchorElement -> Effect String
+foreign import setText :: String -> HTMLAnchorElement -> Effect Unit