Merge branch 'compiler/0.12' into with-index-result

Author: garyb

bower.json

@@ -17,13 +17,14 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-bifunctors": "^3.0.0",
-    "purescript-maybe": "^3.0.0"
+    "purescript-bifunctors": "#compiler/0.12",
+    "purescript-maybe": "#compiler/0.12",
+    "purescript-orders": "#compiler/0.12"
   },
   "devDependencies": {
-    "purescript-assert": "^3.0.0",
-    "purescript-console": "^3.0.0",
-    "purescript-integers": "^3.0.0",
-    "purescript-math": "^2.0.0"
+    "purescript-assert": "#compiler/0.12",
+    "purescript-console": "#compiler/0.12",
+    "purescript-integers": "#compiler/0.12",
+    "purescript-math": "#compiler/0.12"
   }
 }

package.json

@@ -7,8 +7,8 @@
   },
   "devDependencies": {
     "eslint": "^3.17.1",
-    "pulp": "^10.0.4",
-    "purescript-psa": "^0.5.0-rc.1",
+    "pulp": "^11.0.0",
+    "purescript-psa": "^0.5.1",
     "rimraf": "^2.6.1"
   }
 }

src/Data/Bifoldable.purs

@@ -3,8 +3,6 @@ module Data.Bifoldable where
 import Prelude
 
 import Control.Apply (applySecond)
-
-import Data.Monoid (class Monoid, mempty)
 import Data.Monoid.Conj (Conj(..))
 import Data.Monoid.Disj (Disj(..))
 import Data.Monoid.Dual (Dual(..))
@@ -127,7 +125,7 @@ bifoldMapDefaultL f g = bifoldl (\m a -> m <> f a) (\m b -> m <> g b) mempty
 
 -- | Fold a data structure, accumulating values in a monoidal type.
 bifold :: forall t m. Bifoldable t => Monoid m => t m m -> m
-bifold = bifoldMap id id
+bifold = bifoldMap identity identity
 
 -- | Traverse a data structure, accumulating effects using an `Applicative` functor,
 -- | ignoring the final result.
@@ -160,7 +158,7 @@ bisequence_
   => Applicative f
   => t (f a) (f b)
   -> f Unit
-bisequence_ = bitraverse_ id id
+bisequence_ = bitraverse_ identity identity
 
 -- | Test whether a predicate holds at any position in a data structure.
 biany

src/Data/Bitraversable.purs

@@ -92,7 +92,7 @@ bisequenceDefault
   => Applicative f
   => t (f a) (f b)
   -> f (t a b)
-bisequenceDefault = bitraverse id id
+bisequenceDefault = bitraverse identity identity
 
 -- | Traverse a data structure, accumulating effects and results using an `Applicative` functor.
 bifor

src/Data/Foldable.purs

@@ -7,6 +7,7 @@ module Data.Foldable
   , for_
   , sequence_
   , oneOf
+  , oneOfMap
   , intercalate
   , surroundMap
   , surround
@@ -18,6 +19,8 @@ module Data.Foldable
   , product
   , elem
   , notElem
+  , indexl
+  , indexr
   , find
   , findMap
   , maximum
@@ -31,11 +34,9 @@ module Data.Foldable
 import Prelude
 
 import Control.Plus (class Plus, alt, empty)
-
 import Data.Maybe (Maybe(..))
 import Data.Maybe.First (First(..))
 import Data.Maybe.Last (Last(..))
-import Data.Monoid (class Monoid, mempty)
 import Data.Monoid.Additive (Additive(..))
 import Data.Monoid.Conj (Conj(..))
 import Data.Monoid.Disj (Disj(..))
@@ -170,11 +171,11 @@ instance foldableMultiplicative :: Foldable Multiplicative where
 
 -- | Fold a data structure, accumulating values in some `Monoid`.
 fold :: forall f m. Foldable f => Monoid m => f m -> m
-fold = foldMap id
+fold = foldMap identity
 
--- | Similar to 'foldl', but the result is encapsulated in a monad. 
+-- | Similar to 'foldl', but the result is encapsulated in a monad.
 -- |
--- | Note: this function is not generally stack-safe, e.g., for monads which 
+-- | Note: this function is not generally stack-safe, e.g., for monads which
 -- | build up thunks a la `Eff`.
 foldM :: forall f m a b. Foldable f => Monad m => (a -> b -> m a) -> a -> f b -> m a
 foldM f a0 = foldl (\ma b -> ma >>= flip f b) (pure a0)
@@ -227,12 +228,16 @@ for_ = flip traverse_
 -- | sequence_ [ trace "Hello, ", trace " world!" ]
 -- | ```
 sequence_ :: forall a f m. Applicative m => Foldable f => f (m a) -> m Unit
-sequence_ = traverse_ id
+sequence_ = traverse_ identity
 
 -- | Combines a collection of elements using the `Alt` operation.
 oneOf :: forall f g a. Foldable f => Plus g => f (g a) -> g a
 oneOf = foldr alt empty
 
+-- | Folds a structure into some `Plus`.
+oneOfMap :: forall f g a b. Foldable f => Plus g => (a -> g b) -> f a -> g b
+oneOfMap f = foldr (alt <<< f) empty
+
 -- | Fold a data structure, accumulating values in some `Monoid`,
 -- | combining adjacent elements using the specified separator.
 intercalate :: forall f m. Foldable f => Monoid m => m -> f m -> m
@@ -280,19 +285,19 @@ surroundMap d t f = unwrap (foldMap joined f) d
 -- | = "*1*2*3*"
 -- | ```
 surround :: forall f m. Foldable f => Semigroup m => m -> f m -> m
-surround d = surroundMap d id
+surround d = surroundMap d identity
 
 -- | The conjunction of all the values in a data structure. When specialized
 -- | to `Boolean`, this function will test whether all of the values in a data
 -- | structure are `true`.
 and :: forall a f. Foldable f => HeytingAlgebra a => f a -> a
-and = all id
+and = all identity
 
 -- | The disjunction of all the values in a data structure. When specialized
 -- | to `Boolean`, this function will test whether any of the values in a data
 -- | structure is `true`.
 or :: forall a f. Foldable f => HeytingAlgebra a => f a -> a
-or = any id
+or = any identity
 
 -- | `all f` is the same as `and <<< map f`; map a function over the structure,
 -- | and then get the conjunction of the results.
@@ -320,6 +325,30 @@ elem = any <<< (==)
 notElem :: forall a f. Foldable f => Eq a => a -> f a -> Boolean
 notElem x = not <<< elem x
 
+-- | Try to get nth element from the left in a data structure
+indexl :: forall a f. Foldable f => Int -> f a -> Maybe a
+indexl idx = _.elem <<< foldl go { elem: Nothing, pos: 0 }
+  where
+  go cursor a =
+    case cursor.elem of
+      Just _ -> cursor
+      _ ->
+        if cursor.pos == idx
+          then { elem: Just a, pos: cursor.pos }
+          else { pos: cursor.pos + 1, elem: cursor.elem }
+
+-- | Try to get nth element from the right in a data structure
+indexr :: forall a f. Foldable f => Int -> f a -> Maybe a
+indexr idx = _.elem <<< foldr go { elem: Nothing, pos: 0 }
+  where
+  go a cursor =
+    case cursor.elem of
+      Just _ -> cursor
+      _ ->
+        if cursor.pos == idx
+          then { elem: Just a, pos: cursor.pos }
+          else { pos: cursor.pos + 1, elem: cursor.elem }
+
 -- | Try to find an element in a data structure which satisfies a predicate.
 find :: forall a f. Foldable f => (a -> Boolean) -> f a -> Maybe a
 find p = foldl go Nothing

src/Data/FoldableWithIndex.purs

@@ -11,6 +11,9 @@ module Data.FoldableWithIndex
   , allWithIndex
   , anyWithIndex
   , findWithIndex
+  , foldrDefault
+  , foldlDefault
+  , foldMapDefault
   ) where
 
 import Prelude
@@ -20,7 +23,6 @@ import Data.FunctorWithIndex (mapWithIndex)
 import Data.Maybe (Maybe(..))
 import Data.Maybe.First (First)
 import Data.Maybe.Last (Last)
-import Data.Monoid (class Monoid, mempty)
 import Data.Monoid.Additive (Additive)
 import Data.Monoid.Conj (Conj(..))
 import Data.Monoid.Disj (Disj(..))
@@ -29,15 +31,15 @@ import Data.Monoid.Endo (Endo(..))
 import Data.Monoid.Multiplicative (Multiplicative)
 import Data.Newtype (unwrap)
 
--- | A `Foldable` with an additional index.  
+-- | A `Foldable` with an additional index.
 -- | A `FoldableWithIndex` instance must be compatible with its `Foldable`
 -- | instance
 -- | ```purescript
 -- | foldr f = foldrWithIndex (const f)
 -- | foldl f = foldlWithIndex (const f)
 -- | foldMap f = foldMapWithIndex (const f)
 -- | ```
--- | 
+-- |
 -- | Default implementations are provided by the following functions:
 -- |
 -- | - `foldrWithIndexDefault`
@@ -153,9 +155,9 @@ instance foldableWithIndexMultiplicative :: FoldableWithIndex Unit Multiplicativ
   foldMapWithIndex f = foldMap $ f unit
 
 
--- | Similar to 'foldlWithIndex', but the result is encapsulated in a monad. 
+-- | Similar to 'foldlWithIndex', but the result is encapsulated in a monad.
 -- |
--- | Note: this function is not generally stack-safe, e.g., for monads which 
+-- | Note: this function is not generally stack-safe, e.g., for monads which
 -- | build up thunks a la `Eff`.
 foldWithIndexM
   :: forall i f m a b
@@ -269,10 +271,32 @@ findWithIndex
   -> Maybe { index :: i, value :: a }
 findWithIndex p = foldlWithIndex go Nothing
   where
-  go
-    :: i
-    -> Maybe { index :: i, value :: a }
-    -> a
-    -> Maybe { index :: i, value :: a }
-  go i Nothing x | p i x = Just { index: i, value: x }
-  go _ r _ = r
+    go
+      :: i
+      -> Maybe { index :: i, value :: a }
+      -> a
+      -> Maybe { index :: i, value :: a }
+    go i Nothing x | p i x = Just { index: i, value: x }
+    go _ r _ = r
+
+-- | A default implementation of `foldr` using `foldrWithIndex`
+foldrDefault
+  :: forall i f a b
+   . FoldableWithIndex i f
+  => (a -> b -> b) -> b -> f a -> b
+foldrDefault f = foldrWithIndex (const f)
+
+-- | A default implementation of `foldl` using `foldlWithIndex`
+foldlDefault
+  :: forall i f a b
+   . FoldableWithIndex i f
+  => (b -> a -> b) -> b -> f a -> b
+foldlDefault f = foldlWithIndex (const f)
+
+-- | A default implementation of `foldMap` using `foldMapWithIndex`
+foldMapDefault
+  :: forall i f a m
+   . FoldableWithIndex i f
+  => Monoid m
+  => (a -> m) -> f a -> m
+foldMapDefault f = foldMapWithIndex (const f)

src/Data/FunctorWithIndex.purs

@@ -1,5 +1,5 @@
 module Data.FunctorWithIndex
-  ( class FunctorWithIndex, mapWithIndex
+  ( class FunctorWithIndex, mapWithIndex, mapDefault
   ) where
 
 import Prelude
@@ -13,11 +13,10 @@ import Data.Monoid.Disj (Disj)
 import Data.Monoid.Dual (Dual)
 import Data.Monoid.Multiplicative (Multiplicative)
 
-
--- | A `Functor` with an additional index.  
+-- | A `Functor` with an additional index.
 -- | Instances must satisfy a modified form of the `Functor` laws
 -- | ```purescript
--- | mapWithIndex (\_ a -> a) = id
+-- | mapWithIndex (\_ a -> a) = identity
 -- | mapWithIndex f . mapWithIndex g = mapWithIndex (\i -> f i <<< g i)
 -- | ```
 -- | and be compatible with the `Functor` instance
@@ -55,3 +54,7 @@ instance functorWithIndexDisj :: FunctorWithIndex Unit Disj where
 
 instance functorWithIndexMultiplicative :: FunctorWithIndex Unit Multiplicative where
   mapWithIndex f = map $ f unit
+
+-- | A default implementation of Functor's `map` in terms of `mapWithIndex`
+mapDefault :: forall i f a b. FunctorWithIndex i f => (a -> b) -> f a -> f b
+mapDefault f = mapWithIndex (const f)

src/Data/Semigroup/Foldable.purs

@@ -7,12 +7,18 @@ module Data.Semigroup.Foldable
   , sequence1_
   , foldMap1Default
   , fold1Default
+  , intercalate
+  , intercalateMap
   ) where
 
 import Prelude
+
 import Data.Foldable (class Foldable)
 import Data.Monoid.Dual (Dual(..))
 import Data.Monoid.Multiplicative (Multiplicative(..))
+import Data.Newtype (ala)
+import Data.Ord.Max (Max(..))
+import Data.Ord.Min (Min(..))
 
 -- | `Foldable1` represents data structures with a minimum of one element that can be _folded_.
 -- |
@@ -33,7 +39,7 @@ class Foldable t <= Foldable1 t where
 
 -- | A default implementation of `fold1` using `foldMap1`.
 fold1Default :: forall t m. Foldable1 t => Semigroup m => t m -> m
-fold1Default = foldMap1 id
+fold1Default = foldMap1 identity
 
 -- | A default implementation of `foldMap1` using `fold1`.
 foldMap1Default :: forall t m a. Foldable1 t => Functor t => Semigroup m => (a -> m) -> t a -> m
@@ -70,4 +76,34 @@ for1_ = flip traverse1_
 -- | Perform all of the effects in some data structure in the order
 -- | given by the `Foldable1` instance, ignoring the final result.
 sequence1_ :: forall t f a. Foldable1 t => Apply f => t (f a) -> f Unit
-sequence1_ = traverse1_ id
+sequence1_ = traverse1_ identity
+
+maximum :: forall f a. Ord a => Foldable1 f => f a -> a
+maximum = ala Max foldMap1
+
+minimum :: forall f a. Ord a => Foldable1 f => f a -> a
+minimum = ala Min foldMap1
+
+-- | Internal. Used by intercalation functions.
+newtype JoinWith a = JoinWith (a -> a)
+
+joinee :: forall a. JoinWith a -> a -> a
+joinee (JoinWith x) = x
+
+instance semigroupJoinWith :: Semigroup a => Semigroup (JoinWith a) where
+  append (JoinWith a) (JoinWith b) = JoinWith $ \j -> a j <> j <> b j
+
+-- | Fold a data structure using a `Semigroup` instance,
+-- | combining adjacent elements using the specified separator.
+intercalate :: forall f m. Foldable1 f => Semigroup m => m -> f m -> m
+intercalate = flip intercalateMap identity
+
+-- | Fold a data structure, accumulating values in some `Semigroup`,
+-- | combining adjacent elements using the specified separator.
+intercalateMap
+  :: forall f m a
+   . Foldable1 f
+  => Semigroup m
+  => m -> (a -> m) -> f a -> m
+intercalateMap j f foldable =
+  joinee (foldMap1 (JoinWith <<< const <<< f) foldable) j