Updates for PureScript 0.9

Author: garyb

.gitignore

@@ -1,5 +1,6 @@
+/.*
+!/.gitignore
+!/.travis.yml
 /bower_components/
 /node_modules/
 /output/
-/.psci*
-/src/.webpack.js

.travis.yml

@@ -1,7 +1,7 @@
 language: node_js
-sudo: required
 dist: trusty
-node_js: 5
+sudo: required
+node_js: 6
 env:
   - PATH=$HOME/purescript:$PATH
 install:
@@ -11,15 +11,13 @@ install:
   - chmod a+x $HOME/purescript
   - npm install -g bower
   - npm install
-  - bower install
 script:
-  - npm run build
+  - bower install --production
+  - npm run -s build
+  - bower install
+  - npm -s test
 after_success:
 - >-
   test $TRAVIS_TAG &&
-  psc-publish > .pursuit.json &&
-  curl -X POST http://pursuit.purescript.org/packages \
-    -d @.pursuit.json \
-    -H 'Accept: application/json' \
-    -H "Authorization: token ${GITHUB_TOKEN}"
-
+  echo $GITHUB_TOKEN | pulp login &&
+  echo y | pulp publish --no-push

bower.json

@@ -11,20 +11,17 @@
     "type": "git",
     "url": "git://github.com/purescript-contrib/purescript-profunctor-lenses.git"
   },
-  "devDependencies": {
-    "purescript-console": "^0.1.0"
-  },
   "dependencies": {
-    "purescript-const": "~0.5.0",
-    "purescript-coproducts": "~0.4.0",
-    "purescript-functors": "~0.1.0",
-    "purescript-identity": "~0.4.0",
-    "purescript-lists": "~0.7.0",
-    "purescript-maps": "~0.5.2",
-    "purescript-profunctor": "~0.3.0",
-    "purescript-sets": "~0.5.1",
-    "purescript-unsafe-coerce": "~0.1.0",
-    "purescript-transformers": "~0.8.1",
-    "purescript-functor-compose": "~0.0.1"
+    "purescript-const": "^v1.0.0-rc.1",
+    "purescript-functor-coproducts": "^v1.0.0-rc.1",
+    "purescript-functor-products": "^v1.0.0-rc.1",
+    "purescript-identity": "^v1.0.0-rc.1",
+    "purescript-profunctor": "^v1.0.0-rc.1",
+    "purescript-sets": "^v1.0.0-rc.1",
+    "purescript-unsafe-coerce": "^v1.0.0-rc.1",
+    "purescript-transformers": "^v1.0.0-rc.1"
+  },
+  "devDependencies": {
+    "purescript-console": "^1.0.0-rc.1"
   }
 }

package.json

@@ -1,12 +1,13 @@
 {
   "private": true,
   "scripts": {
-    "postinstall": "bower install",
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "pulp test"
+    "build": "pulp build --censor-lib --strict",
+    "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^8.1.1",
+    "pulp": "^8.2.0",
+    "purescript-psa": "^0.3.8",
     "rimraf": "^2.5.0"
   }
 }

src/Data/Lens.purs

@@ -22,12 +22,12 @@ module Data.Lens
   , module Data.Lens.Common
   ) where
 
-import Data.Lens.Iso
-import Data.Lens.Lens
-import Data.Lens.Prism
-import Data.Lens.Traversal
+import Data.Lens.Iso (AnIso, AnIsoP, Iso, IsoP, Optic, Exchange(..), Re(..), au, auf, cloneIso, curried, flipped, iso, re, runRe, uncurried, under, withIso)
+import Data.Lens.Lens (ALens, ALensP, Lens, LensP, cloneLens, lens, lens', withLens)
+import Data.Lens.Prism (APrism, APrismP, Prism, PrismP, Review, ReviewP, clonePrism, is, isn't, matching, nearly, only, prism, prism', review, withPrism)
+import Data.Lens.Traversal (Traversal, TraversalP, element, elementsOf, failover, itraverseOf, sequenceOf, traverseOf, traversed)
 import Data.Lens.Types
-import Data.Lens.Setter
-import Data.Lens.Getter
-import Data.Lens.Fold
-import Data.Lens.Common
+import Data.Lens.Setter (IndexedSetter, Setter, SetterP, Indexed(..), addModifying, addOver, appendModifying, appendOver, assign, assignJust, conjModifying, conjOver, disjModifying, disjOver, divModifying, divOver, iover, modifying, mulModifying, mulOver, over, set, setJust, subModifying, subOver, (%=), (%~), (&&=), (&&~), (*=), (*~), (++=), (++~), (+=), (+~), (-=), (-~), (.=), (.~), (//=), (//~), (<>=), (<>~), (?=), (?~), (||=), (||~))
+import Data.Lens.Getter (Fold, Getter, IndexedFold, IndexedGetter, Optic, Indexed(..), iuse, iview, to, use, view, viewOn, (^.))
+import Data.Lens.Fold (Fold, FoldP, allOf, andOf, anyOf, elemOf, filtered, findOf, firstOf, foldMapOf, foldOf, folded, foldlOf, foldrOf, has, hasn't, iallOf, ianyOf, ifoldMapOf, ifoldlOf, ifoldrOf, itoListOf, itraverseOf_, lastOf, lengthOf, maximumOf, minimumOf, notElemOf, orOf, preview, previewOn, productOf, replicated, sequenceOf_, sumOf, toListOf, toListOfOn, unfolded, (^..), (^?))
+import Data.Lens.Common (_1, _2, _Just, _Left, _Nothing, _Right, first, left, right, second, united)

src/Data/Lens/At.purs

@@ -11,7 +11,7 @@ import Data.Maybe (Maybe(..), maybe)
 import Data.Set as S
 import Data.StrMap as SM
 
-import Data.Lens (LensP(), lens)
+import Data.Lens (LensP, lens)
 import Data.Lens.Index (class Index)
 
 class (Index m a b) <= At m a b where

src/Data/Lens/Common.purs

@@ -1,15 +1,12 @@
 -- | This module defines common lenses and prisms.
-
 module Data.Lens.Common
   ( module Data.Lens.Lens.Tuple
   , module Data.Lens.Lens.Unit
-  , module Data.Lens.Lens.Void
   , module Data.Lens.Prism.Either
   , module Data.Lens.Prism.Maybe
   ) where
 
-import Data.Lens.Lens.Tuple
-import Data.Lens.Lens.Unit
-import Data.Lens.Lens.Void
-import Data.Lens.Prism.Either
-import Data.Lens.Prism.Maybe
+import Data.Lens.Lens.Tuple (_1, _2, first, second)
+import Data.Lens.Lens.Unit (united)
+import Data.Lens.Prism.Either (_Left, _Right, left, right)
+import Data.Lens.Prism.Maybe (_Just, _Nothing)

src/Data/Lens/Fold.purs

@@ -1,5 +1,4 @@
 -- | This module defines functions for working with folds.
-
 module Data.Lens.Fold
   ( (^?), previewOn
   , (^..), toListOfOn
@@ -13,10 +12,12 @@ module Data.Lens.Fold
 
 import Prelude
 
-import Control.Apply ((*>))
-
 import Data.Either (Either(..), either)
 import Data.Foldable (class Foldable, foldMap)
+import Data.HeytingAlgebra (tt, ff)
+import Data.Lens.Internal.Forget (Forget (..), runForget)
+import Data.Lens.Types (Fold, FoldP) as ExportTypes
+import Data.Lens.Types (IndexedFold, Fold, OpticP, Indexed(..))
 import Data.List (List(..), (:))
 import Data.Maybe (Maybe(..), maybe)
 import Data.Maybe.First (First(..), runFirst)
@@ -32,15 +33,6 @@ import Data.Profunctor (dimap)
 import Data.Profunctor.Choice (class Choice, right)
 import Data.Tuple (Tuple(..), uncurry)
 
-import Data.Lens.Internal.Void (coerce)
-import Data.Lens.Internal.Forget (Forget (..), runForget)
-import Data.Lens.Types (Fold(), FoldP()) as ExportTypes
-import Data.Lens.Types (Optic(), OpticP(), Fold())
-import Data.Lens.Types (IndexedOptic(), IndexedFold(), Indexed(..))
-
-infixl 8 previewOn as ^?
-infixl 8 toListOfOn as ^..
-
 -- | Previews the first value of a fold, if there is any.
 preview :: forall s t a b. Fold (First a) s t a b -> s -> Maybe a
 preview p = runFirst <<< foldMapOf p (First <<< Just)
@@ -49,6 +41,8 @@ preview p = runFirst <<< foldMapOf p (First <<< Just)
 previewOn :: forall s t a b. s -> Fold (First a) s t a b -> Maybe a
 previewOn s p = preview p s
 
+infixl 8 previewOn as ^?
+
 -- | Folds all foci of a `Fold` to one. Note that this is the same as `view`.
 foldOf :: forall s t a b. Fold a s t a b -> s -> a
 foldOf p = runForget (p (Forget id))
@@ -125,11 +119,22 @@ findOf p f = foldrOf p (\a -> maybe (if f a then Just a else Nothing) Just) Noth
 
 -- | Sequence the foci of a `Fold`, pulling out an `Applicative`, and ignore
 -- | the result. If you need the result, see `sequenceOf` for `Traversal`s.
-sequenceOf_ :: forall f s t a b. (Applicative f) => Fold (Endo (f Unit)) s t (f a) b -> s -> f Unit
+sequenceOf_
+  :: forall f s t a b
+   . Applicative f
+  => Fold (Endo (f Unit)) s t (f a) b
+  -> s
+  -> f Unit
 sequenceOf_ p = flip runEndo (pure unit) <<< foldMapOf p \f -> Endo (f *> _)
 
 -- | Traverse the foci of a `Fold`, discarding the results.
-traverseOf_ :: forall f s t a b r. (Applicative f) => Fold (Endo (f Unit)) s t a b -> (a -> f r) -> s -> f Unit
+traverseOf_
+  :: forall f s t a b r
+   . Applicative f
+  => Fold (Endo (f Unit)) s t a b
+  -> (a -> f r)
+  -> s
+  -> f Unit
 traverseOf_ p f = foldrOf p (\a fu -> void (f a) *> fu) (pure unit)
 
 -- | Collects the foci of a `Fold` into a list.
@@ -140,17 +145,23 @@ toListOf p = foldrOf p (:) Nil
 toListOfOn :: forall s t a b. s -> Fold (Endo (List a)) s t a b -> List a
 toListOfOn s p = toListOf p s
 
+infixl 8 toListOfOn as ^..
+
 -- | Determines whether a `Fold` has at least one focus.
-has :: forall s t a b r. (BooleanAlgebra r) => Fold (Disj r) s t a b -> s -> r
-has p = runDisj <<< foldMapOf p (const (Disj top))
+has :: forall s t a b r. HeytingAlgebra r => Fold (Disj r) s t a b -> s -> r
+has p = runDisj <<< foldMapOf p (const (Disj tt))
 
 -- | Determines whether a `Fold` does not have a focus.
-hasn't :: forall s t a b r. (BooleanAlgebra r) => Fold (Conj r) s t a b -> s -> r
-hasn't p = runConj <<< foldMapOf p (const (Conj bottom))
+hasn't :: forall s t a b r. HeytingAlgebra r => Fold (Conj r) s t a b -> s -> r
+hasn't p = runConj <<< foldMapOf p (const (Conj ff))
 
 -- | Filters on a predicate.
 filtered :: forall p a. (Choice p) => (a -> Boolean) -> OpticP p a a
-filtered f = dimap (\x -> if f x then Right x else Left x) (either id id) <<< right
+filtered f =
+  right >>>
+    dimap
+      (\x -> if f x then Right x else Left x)
+      (either id id)
 
 -- | Replicates the elements of a fold.
 replicated :: forall a b t r. (Monoid r) => Int -> Fold r a b a t
@@ -163,40 +174,94 @@ folded :: forall g a b t r. (Monoid r, Foldable g) => Fold r (g a) b a t
 folded = Forget <<< foldMap <<< runForget
 
 -- | Builds a `Fold` using an unfold.
-unfolded :: forall r s t a b. (Monoid r) => (s -> Maybe (Tuple a s)) -> Fold r s t a b
-unfolded f p = Forget go where
+unfolded
+  :: forall r s t a b
+   . Monoid r
+  => (s -> Maybe (Tuple a s))
+  -> Fold r s t a b
+unfolded f p = Forget go
+  where
   go = maybe mempty (\(Tuple a sn) -> runForget p a <> go sn) <<< f
 
 -- | Fold map over an `IndexedFold`.
-ifoldMapOf :: forall r i s t a b. IndexedFold r i s t a b -> (i -> a -> r) -> s -> r
+ifoldMapOf
+  :: forall r i s t a b
+   . IndexedFold r i s t a b
+  -> (i -> a -> r)
+  -> s
+  -> r
 ifoldMapOf p f = runForget $ p $ Indexed $ Forget (uncurry f)
 
 -- | Right fold over an `IndexedFold`.
-ifoldrOf :: forall i s t a b r. IndexedFold (Endo r) i s t a b -> (i -> a -> r -> r) -> r -> s -> r
+ifoldrOf
+  :: forall i s t a b r
+   . IndexedFold (Endo r) i s t a b
+  -> (i -> a -> r -> r)
+  -> r
+  -> s
+  -> r
 ifoldrOf p f r = flip runEndo r <<< ifoldMapOf p (\i -> Endo <<< f i)
 
 -- | Left fold over an `IndexedFold`.
-ifoldlOf :: forall i s t a b r. IndexedFold (Dual (Endo r)) i s t a b -> (i -> r -> a -> r) -> r -> s -> r
-ifoldlOf p f r = flip runEndo r <<< runDual <<< ifoldMapOf p (\i -> Dual <<< Endo <<< flip (f i))
+ifoldlOf
+  :: forall i s t a b r
+   . IndexedFold (Dual (Endo r)) i s t a b
+  -> (i -> r -> a -> r)
+  -> r
+  -> s
+  -> r
+ifoldlOf p f r =
+  flip runEndo r
+    <<< runDual
+    <<< ifoldMapOf p (\i -> Dual <<< Endo <<< flip (f i))
 
 -- | Whether all foci of an `IndexedFold` satisfy a predicate.
-iallOf :: forall i s t a b r. (BooleanAlgebra r) => IndexedFold (Conj r) i s t a b -> (i -> a -> r) -> s -> r
+iallOf
+  :: forall i s t a b r
+   . HeytingAlgebra r
+   => IndexedFold (Conj r) i s t a b
+   -> (i -> a -> r)
+   -> s
+   -> r
 iallOf p f = runConj <<< ifoldMapOf p (\i -> Conj <<< f i)
 
 -- | Whether any focus of an `IndexedFold` satisfies a predicate.
-ianyOf :: forall i s t a b r. (BooleanAlgebra r) => IndexedFold (Disj r) i s t a b -> (i -> a -> r) -> s -> r
+ianyOf
+  :: forall i s t a b r
+   . HeytingAlgebra r
+  => IndexedFold (Disj r) i s t a b
+  -> (i -> a -> r)
+  -> s
+  -> r
 ianyOf p f = runDisj <<< ifoldMapOf p (\i -> Disj <<< f i)
 
--- | Find the first focus of an `IndexedFold` that satisfies a predicate, if there is any.
-ifindOf :: forall i s t a b. IndexedFold (Endo (Maybe a)) i s t a b -> (i -> a -> Boolean) -> s -> Maybe a
-ifindOf p f = ifoldrOf p (\i a -> maybe (if f i a then Just a else Nothing) Just) Nothing
+-- | Find the first focus of an `IndexedFold` that satisfies a predicate, if
+-- | there is any.
+ifindOf
+  :: forall i s t a b
+   . IndexedFold (Endo (Maybe a)) i s t a b
+  -> (i -> a -> Boolean)
+  -> s
+  -> Maybe a
+ifindOf p f =
+  ifoldrOf
+    p
+    (\i a -> maybe (if f i a then Just a else Nothing) Just)
+    Nothing
 
 -- | Collects the foci of an `IndexedFold` into a list.
-itoListOf :: forall i s t a b. IndexedFold (Endo (List (Tuple i a))) i s t a b -> s -> List (Tuple i a)
+itoListOf
+  :: forall i s t a b
+   . IndexedFold (Endo (List (Tuple i a))) i s t a b
+  -> s
+  -> List (Tuple i a)
 itoListOf p = ifoldrOf p (\i x xs -> Tuple i x : xs) Nil
 
 -- | Traverse the foci of an `IndexedFold`, discarding the results.
 itraverseOf_
   :: forall i f s t a b r. (Applicative f)
-  => IndexedFold (Endo (f Unit)) i s t a b -> (i -> a -> f r) -> s -> f Unit
+  => IndexedFold (Endo (f Unit)) i s t a b
+  -> (i -> a -> f r)
+  -> s
+  -> f Unit
 itraverseOf_ p f = ifoldrOf p (\i a fu -> void (f i a) *> fu) (pure unit)

src/Data/Lens/Getter.purs

@@ -1,24 +1,17 @@
 -- | This module defines functions for working with getters.
-
 module Data.Lens.Getter
   ( (^.), viewOn
   , view, to, use, iview, iuse
   , module Data.Lens.Types
   ) where
 
-import Prelude (id, (<<<), ($))
+import Prelude
 
-import Data.Const (Const(..), getConst)
-import Data.Functor.Contravariant (class Contravariant, cmap)
-import Data.Profunctor (class Profunctor, lmap)
-import Data.Profunctor.Star (Star(..), runStar)
-import Data.Tuple (Tuple (..))
 import Control.Monad.State.Class (class MonadState, gets)
 
-import Data.Lens.Internal.Forget (Forget (..), runForget)
-import Data.Lens.Types (Getter(), Fold(), Optic())
-import Data.Lens.Types (IndexedGetter(), Indexed (..))
-import Data.Lens.Types (IndexedFold())
+import Data.Lens.Internal.Forget (Forget(..), runForget)
+import Data.Lens.Types (Getter, Fold, Optic, IndexedGetter, Indexed(..), IndexedFold)
+import Data.Tuple (Tuple)
 
 infixl 8 viewOn as ^.
 

src/Data/Lens/Index.purs

@@ -5,16 +5,15 @@ module Data.Lens.Index
 
 import Prelude
 
-import Data.Identity (Identity())
+import Data.Array as A
+import Data.Identity (Identity)
+import Data.Lens.Internal.Wander (wander)
+import Data.Lens.Types (TraversalP)
 import Data.Map as M
-import Data.Maybe (Maybe(), maybe, fromMaybe)
+import Data.Maybe (Maybe, maybe, fromMaybe)
 import Data.Set as S
 import Data.StrMap as SM
-import Data.Array as A
-
 import Data.Traversable (traverse)
-import Data.Lens.Internal.Wander (wander)
-import Data.Lens.Types (TraversalP())
 
 class Index m a b where
   ix :: a -> TraversalP m b