Couple of new attrs

src/OpticUI/Components.purs

@@ -3,11 +3,11 @@ module OpticUI.Components
   , textField
   ) where
 --------------------------------------------------------------------------------
-import           Prelude
-import           OpticUI.Core
-import           OpticUI.Markup
-import qualified OpticUI.Markup.HTML as H
-import           Data.Maybe   (maybe)
+import Prelude             (class Applicative, (++), ($), id, (<<<))
+import Data.Maybe          (maybe)
+import OpticUI.Core        (UI, ui, updatePure, with)
+import OpticUI.Markup      (Markup, Prop)
+import OpticUI.Markup.HTML as H
 --------------------------------------------------------------------------------
 
 textField :: forall eff m k. (Applicative m) => Array Prop -> UI eff m k Markup String String

src/OpticUI/Core.purs

@@ -17,22 +17,22 @@ module OpticUI.Core
   , foreach
   ) where
 --------------------------------------------------------------------------------
-import Prelude
-import Data.Profunctor            (Profunctor)
-import Data.Profunctor.Choice     (Choice)
-import Data.Profunctor.Strong     (Strong)
-import Control.Apply
-import Control.Monad.State
+import Prelude (class Applicative, class Functor, class Apply, class Semigroup,
+                Unit, (<<<), ($), (<>), (+), pure, map, (>>=), append, flip)
+import Control.Apply              ((*>))
+import Control.Monad.State        (state, evalState)
 import Control.Monad.Eff          (Eff ())
-import Data.Monoid                (Monoid, mempty)
-import Data.Lens
-import Data.Maybe (maybe)
-import Data.Map as M
-import Data.Profunctor.Star
-import Data.Traversable           (Traversable, traverse, sequence)
+import Data.Monoid                (class Monoid, mempty)
+import Data.Maybe                 (maybe)
+import Data.Traversable           (class Traversable, traverse, sequence)
 import Data.Tuple                 (Tuple (..))
 import Data.Either                (Either (..), either)
-import Data.Functor.Contravariant (Contravariant, cmap)
+import Data.Functor.Contravariant (class Contravariant, cmap)
+import Data.Profunctor            (class Profunctor)
+import Data.Profunctor.Choice     (class Choice)
+import Data.Profunctor.Strong     (class Strong)
+import Data.Profunctor.Star       (Star(Star), runStar)
+import Data.Lens                  (Traversal, APrismP, clonePrism, preview, review)
 --------------------------------------------------------------------------------
 
 -- | The type of user interface components in `OpticUI`.

src/OpticUI/Internal/VirtualDOM.purs

@@ -1,7 +1,7 @@
 module OpticUI.Internal.VirtualDOM where
 --------------------------------------------------------------------------------
-import Prelude
-import Data.Monoid       (Monoid)
+import Prelude           (class Semigroup, Unit)
+import Data.Monoid       (class Monoid)
 import Control.Monad.Eff (Eff ())
 import Data.Function     (Fn2 (), runFn2)
 import DOM               (DOM ())

src/OpticUI/Markup.purs

@@ -1,13 +1,13 @@
 module OpticUI.Markup where
 --------------------------------------------------------------------------------
-import Prelude
-import Data.Maybe  (Maybe (..))
-import Data.Exists (Exists (), mkExists)
-import Data.Lens
+import Prelude           (class Semigroup, Unit, (++))
+import Data.Maybe        (Maybe (..))
+import Data.Exists       (Exists (), mkExists)
+import Data.Lens         (PrismP, prism')
 import Control.Monad.Eff (Eff())
-import Data.Monoid (Monoid)
-import DOM.HTML.Types (HTMLElement ())
-import Unsafe.Coerce   (unsafeCoerce)
+import Data.Monoid       (class Monoid)
+import DOM.HTML.Types    (HTMLElement ())
+import Unsafe.Coerce     (unsafeCoerce)
 --------------------------------------------------------------------------------
 
 type TagName   = String

src/OpticUI/Markup/HTML.purs

@@ -1,15 +1,16 @@
 module OpticUI.Markup.HTML where
 --------------------------------------------------------------------------------
-import Prelude hiding (sub, div, map)
-import OpticUI.Markup (Markup (), Prop (), Event (), KeyboardEvent (), element, handle, attr, prop, UniqueStr (),
-                       initializer, finalizer)
+import Prelude            (Unit, (<<<), const, (++), id, ($), show)
 import Data.Maybe         (Maybe (..), maybe)
 import Data.Either        (either)
 import Data.Monoid        (mempty)
 import Data.Foreign       (toForeign)
-import Data.Foreign.Class (IsForeign, readProp)
+import Data.Foreign.Class (class IsForeign, readProp)
 import Control.Monad.Eff  (Eff())
 import DOM.HTML.Types     (HTMLElement ())
+import OpticUI.Markup (Markup (), Prop (), Event (), KeyboardEvent (),
+                       element, handle, attr, prop, UniqueStr (),
+                       initializer, finalizer)
 --------------------------------------------------------------------------------
 
 --------------------------------------------------------------------------------
@@ -396,6 +397,9 @@ wbr = element Nothing "wbr"
 textA :: String -> Prop
 textA = attr "text"
 
+hrefA :: String -> Prop
+hrefA = attr "href"
+
 titleA :: String -> Prop
 titleA = attr "title"
 
@@ -423,6 +427,9 @@ styleA = attr "style"
 valueA :: String -> Prop
 valueA = prop "value"
 
+readonlyA :: Boolean -> Prop
+readonlyA = prop "readOnly"
+
 checkedA :: Boolean -> Prop
 checkedA = prop "checked"
 
@@ -490,29 +497,29 @@ getProp prop = either (const Nothing) Just <<< readProp prop <<< toForeign <<< _
 -- Events
 
 type WheelEvent = (
-    deltaX :: Number, 
-    deltaY :: Number, 
+    deltaX :: Number,
+    deltaY :: Number,
     deltaZ :: Number,
     deltaMode :: Int
 )
 
 type MouseEvent = (
-    button :: Number, 
-    detail :: Number, 
-    relatedTarget :: HTMLElement, 
-    clientX :: Number, 
-    clientY :: Number, 
-    screenX :: Number, 
-    screenY :: Number, 
-    pageX :: Number, 
+    button :: Number,
+    detail :: Number,
+    relatedTarget :: HTMLElement,
+    clientX :: Number,
+    clientY :: Number,
+    screenX :: Number,
+    screenY :: Number,
+    pageX :: Number,
     pageY :: Number,
-    ctrlKey :: Boolean, 
-    shiftKey :: Boolean, 
-    altKey :: Boolean, 
-    metaKey :: Boolean, 
+    ctrlKey :: Boolean,
+    shiftKey :: Boolean,
+    altKey :: Boolean,
+    metaKey :: Boolean,
     which :: Number
 )
 
 type DragEvent = (dataTransfer :: DataTransfer | MouseEvent)
 
-foreign import data DataTransfer :: *
+foreign import data DataTransfer :: *

src/OpticUI/Run.purs

@@ -3,36 +3,38 @@ module OpticUI.Run
   , animate
   ) where
 --------------------------------------------------------------------------------
-import Prelude
-import OpticUI.Internal.VirtualDOM as VD
-import OpticUI.Markup
-import OpticUI.Core
-import Control.Apply ((*>))
-import Control.Monad (when)
-import Control.Monad.Eff (Eff ())
-import Control.Monad.Aff
+import Prelude                   (class Monad, Unit, void, ($), unit, pure,
+                                  (<$>), bind, (<<<), (>>=), return, (+), (==))
+import Control.Apply             ((*>))
+import Control.Monad             (when)
+import Control.Monad.Eff         (Eff ())
 import Control.Monad.State.Trans (StateT (), runStateT)
-import Control.Monad.Free.Trans
-import Control.Monad.Eff.Ref
-import Data.Function (runFn2)
-import Data.Exists (runExists)
-import Data.Maybe (Maybe (..), maybe)
-import Data.Nullable (toNullable, toMaybe)
-import Data.Monoid (Monoid, mempty)
-import Data.Tuple (Tuple (..))
-import Data.Traversable (traverse)
-import Data.Foldable (fold)
-import Data.StrMap (StrMap (), empty)
-import Data.Lens
-import Data.Lens.At
-import DOM (DOM ())
-import DOM.Event.EventTarget (eventListener, addEventListener)
-import DOM.Event.EventTypes (load)
-import DOM.HTML (window)
-import DOM.HTML.Document (body)
-import DOM.HTML.Types (HTMLElement (), htmlElementToNode, windowToEventTarget)
-import DOM.HTML.Window (document)
-import DOM.Node.Node (appendChild)
+import Control.Monad.Eff.Ref     (REF, readRef, writeRef, newRef)
+import Data.Function             (runFn2)
+import Data.Exists               (runExists)
+import Data.Maybe                (Maybe (..), maybe)
+import Data.Nullable             (toNullable, toMaybe)
+import Data.Monoid               (mempty)
+import Data.Tuple                (Tuple (..))
+import Data.Traversable          (traverse)
+import Data.Foldable             (fold)
+import Data.StrMap               (StrMap (), empty)
+import Data.Lens                 (LensP, lens, (?=), use, traversed, lastOf)
+import Data.Lens.At              (at)
+import DOM                       (DOM ())
+import DOM.Event.EventTarget     (eventListener, addEventListener)
+import DOM.Event.EventTypes      (load)
+import DOM.HTML                  (window)
+import DOM.HTML.Document         (body)
+import DOM.HTML.Types            (HTMLElement (), htmlElementToNode,
+                                  windowToEventTarget)
+import DOM.HTML.Window           (document)
+import DOM.Node.Node             (appendChild)
+import OpticUI.Markup            (UniqueStr, Markup(Markup), Node(..),
+                                  Prop(..), PropE(PropE), runFinalizer,
+                                  runInitializer, runEventHandler, _KeyP)
+import OpticUI.Core              (UI, Handler(Handler), Result(Result), runUI)
+import OpticUI.Internal.VirtualDOM as VD
 --------------------------------------------------------------------------------
 
 type AnimateE eff = (dom :: DOM, ref :: REF | eff)

src/OpticUI/Util/Remote.purs

@@ -1,14 +1,17 @@
 module OpticUI.Util.Remote where
 --------------------------------------------------------------------------------
-import Prelude
-import Control.Apply
-import Data.Lens
-import Data.Monoid
-import Data.Maybe
-import Data.Either
-import Data.Traversable
-import Data.Foldable
-import Data.Bifunctor
+import Prelude          (class Semigroup, class Monad, class Bind,
+                         class Applicative, class Apply, class Functor,
+                         Unit, unit, const, pure, append, (>>=))
+import Control.Apply    (lift2)
+import Data.Lens        (PrismP, Prism, prism', prism, sequenceOf, traverseOf,
+                         foldMapOf, foldlOf, foldrOf, over)
+import Data.Monoid      (class Monoid, mempty)
+import Data.Maybe       (Maybe(Nothing, Just))
+import Data.Either      (Either(Left, Right), either)
+import Data.Traversable (class Traversable)
+import Data.Foldable    (class Foldable)
+import Data.Bifunctor   (class Bifunctor)
 --------------------------------------------------------------------------------
 
 -- | A value retrieved from a remote service.

src/OpticUI/Util/State.purs

@@ -1,10 +1,10 @@
 module OpticUI.Util.State (withState) where
 --------------------------------------------------------------------------------
-import Prelude
+import Prelude                   (class Monad, flip)
 import Control.Monad.State.Trans (StateT (), runStateT)
-import Data.Tuple (Tuple (..), fst)
-import Data.Profunctor (lmap)
-import OpticUI.Core
+import Data.Tuple                (Tuple (..), fst)
+import Data.Profunctor           (lmap)
+import OpticUI.Core              (UI, withEffects, with)
 --------------------------------------------------------------------------------
 
 -- | Manage the state of an `UI` component with effects in a state monad