Updates for 0.11

bower.json

@@ -20,19 +20,19 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-datetime": "^2.0.0",
-    "purescript-enums": "^2.0.0",
-    "purescript-exceptions": "^2.0.0",
-    "purescript-foldable-traversable": "^2.0.0",
-    "purescript-foreign": "^3.0.0",
-    "purescript-js-date": "^3.0.0",
-    "purescript-media-types": "^2.0.0",
-    "purescript-nullable": "^2.0.0",
-    "purescript-prelude": "^2.1.0",
-    "purescript-unsafe-coerce": "^2.0.0"
+    "purescript-datetime": "^3.0.0",
+    "purescript-enums": "^3.0.0",
+    "purescript-exceptions": "^3.0.0",
+    "purescript-foldable-traversable": "^3.0.0",
+    "purescript-foreign": "^4.0.0",
+    "purescript-js-date": "^4.0.0",
+    "purescript-media-types": "^3.0.0",
+    "purescript-nullable": "^3.0.0",
+    "purescript-prelude": "^3.0.0",
+    "purescript-unsafe-coerce": "^3.0.0"
   },
   "devDependencies": {
-    "purescript-aff": "^2.0.0",
+    "purescript-aff": "^3.0.0",
     "purescript-test-unit": "^10.0.0",
     "purescript-exitcodes": "^2.0.0",
     "purescript-phantom": "^1.0.1"

package.json

@@ -2,14 +2,14 @@
   "private": true,
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "eslint src && pulp build --censor-lib --strict"
+    "build": "eslint src && pulp build -- --censor-lib --strict"
   },
   "devDependencies": {
     "eslint": "^3.8.1",
     "phantomjs-prebuilt": "^2.1.13",
-    "pulp": "^9.0.1",
-    "purescript-psa": "^0.3.9",
-    "purescript": "^0.10.6",
+    "pulp": "^11.0.0",
+    "purescript-psa": "^0.5.0",
+    "purescript": "^0.11.1",
     "rimraf": "^2.5.4"
   }
 }

src/DOM.purs

@@ -1,5 +1,7 @@
 module DOM where
 
+import Control.Monad.Eff (kind Effect)
+
 -- | Effect type for when the DOM is being manipulated or mutable values are
 -- | being read from the DOM.
-foreign import data DOM :: !
+foreign import data DOM :: Effect

src/DOM/CSS/Event/Types.purs

@@ -5,17 +5,13 @@ module DOM.CSS.Event.Types
   ) where
 
 import Data.Foreign (Foreign, F, unsafeReadTagged)
-import Data.Foreign.Class (class IsForeign)
 import DOM.Event.Types (Event)
 import Unsafe.Coerce as U
 
-foreign import data TransitionEvent :: *
+foreign import data TransitionEvent :: Type
 
 transitionEventToEvent :: TransitionEvent -> Event
 transitionEventToEvent = U.unsafeCoerce
 
 readTransitionEvent :: Foreign -> F TransitionEvent
 readTransitionEvent = unsafeReadTagged "TransitionEvent"
-
-instance isForeignTransitionEvent :: IsForeign TransitionEvent where
-  read = readTransitionEvent

src/DOM/Event/EventTarget.purs

@@ -1,14 +1,14 @@
 module DOM.Event.EventTarget where
 
 import Prelude
-import Control.Monad.Eff (Eff)
+import Control.Monad.Eff (kind Effect, Eff)
 import Control.Monad.Eff.Exception (EXCEPTION)
 import DOM (DOM)
 import DOM.Event.Types (EventTarget, Event, EventType)
 
 -- | A boxed function that can be used as an event listener. This is necessary
 -- | due to the underling implementation of Eff functions.
-foreign import data EventListener :: # ! -> *
+foreign import data EventListener :: # Effect -> Type
 
 -- | Creates an EventListener from a normal PureScript Eff function.
 foreign import eventListener

src/DOM/Event/Types.purs

@@ -41,12 +41,11 @@ module DOM.Event.Types
 import Prelude
 import Data.Either (Either(..))
 import Data.Foreign (F, Foreign, unsafeReadTagged)
-import Data.Foreign.Class (class IsForeign)
 import Data.Newtype (class Newtype)
 import Unsafe.Coerce as U
 
 -- | Basic type for all DOM events.
-foreign import data Event :: *
+foreign import data Event :: Type
 
 -- | The type of strings used for event types.
 newtype EventType = EventType String
@@ -56,7 +55,7 @@ derive newtype instance eqEventType :: Eq EventType
 derive newtype instance ordEventType :: Ord EventType
 
 -- | A DOM item that can emit events.
-foreign import data EventTarget :: *
+foreign import data EventTarget :: Type
 
 readEventTarget :: Foreign -> F EventTarget
 readEventTarget = _readEventTarget Left Right
@@ -67,126 +66,90 @@ foreign import _readEventTarget
   -> Foreign
   -> F EventTarget
 
-instance isForeignEventTarget :: IsForeign EventTarget where
-  read = readEventTarget
-
-foreign import data CustomEvent :: *
+foreign import data CustomEvent :: Type
 
 customEventToEvent :: CustomEvent -> Event
 customEventToEvent = U.unsafeCoerce
 
 readCustomEvent :: Foreign -> F CustomEvent
 readCustomEvent = unsafeReadTagged "CustomEvent"
 
-instance isForeignCustomEvent :: IsForeign CustomEvent where
-  read = readCustomEvent
-
-foreign import data UIEvent :: *
+foreign import data UIEvent :: Type
 
 uiEventToEvent :: UIEvent -> Event
 uiEventToEvent = U.unsafeCoerce
 
 readUIEvent :: Foreign -> F UIEvent
 readUIEvent = unsafeReadTagged "UIEvent"
 
-instance isForeignUIEvent :: IsForeign UIEvent where
-  read = readUIEvent
-
-foreign import data FocusEvent :: *
+foreign import data FocusEvent :: Type
 
 focusEventToEvent :: FocusEvent -> Event
 focusEventToEvent = U.unsafeCoerce
 
 readFocusEvent :: Foreign -> F FocusEvent
 readFocusEvent = unsafeReadTagged "FocusEvent"
 
-instance isForeignFocusEvent :: IsForeign FocusEvent where
-  read = readFocusEvent
-
-foreign import data MouseEvent :: *
+foreign import data MouseEvent :: Type
 
 mouseEventToEvent :: MouseEvent -> Event
 mouseEventToEvent = U.unsafeCoerce
 
 readMouseEvent :: Foreign -> F MouseEvent
 readMouseEvent = unsafeReadTagged "MouseEvent"
 
-instance isForeignMouseEvent :: IsForeign MouseEvent where
-  read = readMouseEvent
-
-foreign import data WheelEvent :: *
+foreign import data WheelEvent :: Type
 
 wheelEventToEvent :: WheelEvent -> Event
 wheelEventToEvent = U.unsafeCoerce
 
 readWheelEvent :: Foreign -> F WheelEvent
 readWheelEvent = unsafeReadTagged "WheelEvent"
 
-instance isForeignWheelEvent :: IsForeign WheelEvent where
-  read = readWheelEvent
-
-foreign import data TouchEvent :: *
+foreign import data TouchEvent :: Type
 
 touchEventToEvent :: TouchEvent -> Event
 touchEventToEvent = U.unsafeCoerce
 
 readTouchEvent :: Foreign -> F TouchEvent
 readTouchEvent = unsafeReadTagged "TouchEvent"
 
-instance isForeignTouchEvent :: IsForeign TouchEvent where
-  read = readTouchEvent
-
-foreign import data InputEvent :: *
+foreign import data InputEvent :: Type
 
 inputEventToEvent :: InputEvent -> Event
 inputEventToEvent = U.unsafeCoerce
 
 readInputEvent :: Foreign -> F InputEvent
 readInputEvent = unsafeReadTagged "InputEvent"
 
-instance isForeignInputEvent :: IsForeign InputEvent where
-  read = readInputEvent
-
-foreign import data KeyboardEvent :: *
+foreign import data KeyboardEvent :: Type
 
 keyboardEventToEvent :: KeyboardEvent -> Event
 keyboardEventToEvent = U.unsafeCoerce
 
 readKeyboardEvent :: Foreign -> F KeyboardEvent
 readKeyboardEvent = unsafeReadTagged "KeyboardEvent"
 
-instance isForeignKeyboardEvent :: IsForeign KeyboardEvent where
-  read = readKeyboardEvent
-
-foreign import data CompositionEvent :: *
+foreign import data CompositionEvent :: Type
 
 compositionEventToEvent :: CompositionEvent -> Event
 compositionEventToEvent = U.unsafeCoerce
 
 readCompositionEvent :: Foreign -> F CompositionEvent
 readCompositionEvent = unsafeReadTagged "CompositionEvent"
 
-instance isForeignCompositionEvent :: IsForeign CompositionEvent where
-  read = readCompositionEvent
-
-foreign import data ProgressEvent :: *
+foreign import data ProgressEvent :: Type
 
 progressEventToEvent :: ProgressEvent -> Event
 progressEventToEvent = U.unsafeCoerce
 
 readProgressEvent :: Foreign -> F ProgressEvent
 readProgressEvent = unsafeReadTagged "ProgressEvent"
 
-instance isForeignProgressEvent :: IsForeign ProgressEvent where
-  read = readProgressEvent
-
-foreign import data ClipboardEvent :: *
+foreign import data ClipboardEvent :: Type
 
 clipboardEventToEvent :: ClipboardEvent -> Event
 clipboardEventToEvent = U.unsafeCoerce
 
 readClipboardEvent :: Foreign -> F ClipboardEvent
 readClipboardEvent = unsafeReadTagged "ClipboardEvent"
-
-instance isForeignClipboardEvent :: IsForeign ClipboardEvent where
-  read = readClipboardEvent

src/DOM/File/Types.purs

@@ -2,15 +2,14 @@ module DOM.File.Types where
 
 import DOM.Event.Types (EventTarget)
 import Data.Foreign (Foreign, F, unsafeReadTagged)
-import Data.Foreign.Class (class IsForeign)
 import Unsafe.Coerce (unsafeCoerce)
 
-foreign import data Blob :: *
-foreign import data BlobURL :: *
-foreign import data File :: *
-foreign import data FileList :: *
-foreign import data FileReader :: *
-foreign import data FileReaderSync :: *
+foreign import data Blob :: Type
+foreign import data BlobURL :: Type
+foreign import data File :: Type
+foreign import data FileList :: Type
+foreign import data FileReader :: Type
+foreign import data FileReaderSync :: Type
 
 fileToBlob :: File -> Blob
 fileToBlob = unsafeCoerce
@@ -20,6 +19,3 @@ fileReaderToEventTarget = unsafeCoerce
 
 readFileList :: Foreign -> F FileList
 readFileList = unsafeReadTagged "FileList"
-
-instance isForeignFileList :: IsForeign FileList where
-  read = readFileList

src/DOM/HTML/Event/DataTransfer.purs

@@ -15,7 +15,7 @@ import Data.Maybe (Maybe)
 import Data.MediaType (MediaType(..))
 import Data.Nullable (Nullable, toMaybe)
 
-foreign import data DataTransfer :: *
+foreign import data DataTransfer :: Type
 
 -- | Contains a list of all the local files available on the data transfer.
 -- | Empty if the drag operation doesn't involve dragging files.

src/DOM/HTML/Event/Types.purs

@@ -11,39 +11,29 @@ module DOM.HTML.Event.Types
   ) where
 
 import Data.Foreign (Foreign, F, unsafeReadTagged)
-import Data.Foreign.Class (class IsForeign)
 import DOM.Event.Types (Event)
 import Unsafe.Coerce as U
 
-foreign import data DragEvent :: *
+foreign import data DragEvent :: Type
 
 dragEventToEvent :: DragEvent -> Event
 dragEventToEvent = U.unsafeCoerce
 
 readDragEvent :: Foreign -> F DragEvent
 readDragEvent = unsafeReadTagged "DragEvent"
 
-instance isForeignDragEvent :: IsForeign DragEvent where
-  read = readDragEvent
-
-foreign import data ErrorEvent :: *
+foreign import data ErrorEvent :: Type
 
 errorEventToEvent :: ErrorEvent -> Event
 errorEventToEvent = U.unsafeCoerce
 
 readErrorEvent :: Foreign -> F ErrorEvent
 readErrorEvent = unsafeReadTagged "ErrorEvent"
 
-instance isForeignErrorEvent :: IsForeign ErrorEvent where
-  read = readErrorEvent
-
-foreign import data HashChangeEvent :: *
+foreign import data HashChangeEvent :: Type
 
 hashChangeEventToEvent :: HashChangeEvent -> Event
 hashChangeEventToEvent = U.unsafeCoerce
 
 readHashChangeEvent :: Foreign -> F HashChangeEvent
 readHashChangeEvent = unsafeReadTagged "HashChangeEvent"
-
-instance isForeignHashChangeEvent :: IsForeign HashChangeEvent where
-  read = readHashChangeEvent