Updates for purescript-0.8.2

Author: telser

.travis.yml

@@ -1,7 +1,7 @@
 language: node_js
 sudo: false
 node_js:
-  - 0.10
+  - 4
 env:
   - PATH=$HOME/purescript:$PATH
 install:

src/Data/List.purs

@@ -22,7 +22,7 @@ module Data.List
   , null
   , length
 
-  , (:), cons
+  , (:)
   , snoc
   , insert
   , insertBy
@@ -197,9 +197,7 @@ length = foldl (\acc _ -> acc + 1) 0
 -- | a list.
 -- |
 -- | Running time: `O(1)`
-cons :: forall a. a -> List a -> List a
-cons = Cons
-infixr 6 cons as :
+infixr 6 Cons as :
 
 -- | Append an element to the end of an array, creating a new array.
 -- |
@@ -286,11 +284,11 @@ infixl 8 index as !!
 
 -- | Find the index of the first element equal to the specified element.
 elemIndex :: forall a. (Eq a) => a -> List a -> Maybe Int
-elemIndex x = findIndex (== x)
+elemIndex x = findIndex (_ == x)
 
 -- | Find the index of the last element equal to the specified element.
 elemLastIndex :: forall a. (Eq a) => a -> List a -> Maybe Int
-elemLastIndex x = findLastIndex (== x)
+elemLastIndex x = findLastIndex (_ == x)
 
 -- | Find the first index for which a predicate holds.
 findIndex :: forall a. (a -> Boolean) -> List a -> Maybe Int
@@ -370,7 +368,7 @@ reverse = go Nil
 -- |
 -- | Running time: `O(n)`, where `n` is the total number of elements.
 concat :: forall a. List (List a) -> List a
-concat = (>>= id)
+concat = (_ >>= id)
 
 -- | Apply a function to each element in a list, and flatten the results
 -- | into a single, new list.

src/Data/List/Lazy.purs

@@ -385,7 +385,7 @@ reverse xs = go nil (step xs)
 -- |
 -- | Running time: `O(n)`, where `n` is the total number of elements.
 concat :: forall a. List (List a) -> List a
-concat = (>>= id)
+concat = (_ >>= id)
 
 -- | Apply a function to each element in a list, and flatten the results
 -- | into a single, new list.

test/Test/Data/List.purs

@@ -1,11 +1,11 @@
 module Test.Data.List (testList) where
 
-import Prelude
+import Prelude (Unit, (*), zero, (/=), mod, (+), (==), ($), bind, pure, void, show, (<), (&&), compare, flip, const, (<<<), map, negate)
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Console (CONSOLE(), log)
-import Data.Foldable
-import Data.Monoid.Additive
-import Data.List
+import Data.Foldable (foldMap, foldl)
+import Data.Monoid.Additive (Additive(Additive))
+import Data.List (List(Nil, Cons), (..), length, range, foldM, unzip, zip, zipWithA, zipWith, intersectBy, intersect, (\\), deleteBy, delete, unionBy, union, nubBy, nub, groupBy, group', group, span, dropWhile, drop, takeWhile, take, sortBy, sort, catMaybes, mapMaybe, filterM, filter, concat, concatMap, reverse, alterAt, modifyAt, updateAt, deleteAt, insertAt, findLastIndex, findIndex, elemLastIndex, elemIndex, (!!), uncons, init, tail, last, head, insertBy, insert, snoc, null, replicateM, replicate, singleton, fromFoldable, transpose, (:))
 import Data.Maybe (Maybe(..), isNothing)
 import Data.Maybe.Unsafe (fromJust)
 import Data.Tuple (Tuple(..))
@@ -120,12 +120,12 @@ testList = do
   assert $ elemLastIndex 4 (l [1, 2, 1]) == Nothing
 
   log "findIndex should return the index of an item that a predicate returns true for in an list"
-  assert $ findIndex (/= 1) (l [1, 2, 1]) == Just 1
-  assert $ findIndex (== 3) (l [1, 2, 1]) == Nothing
+  assert $ findIndex (_ /= 1) (l [1, 2, 1]) == Just 1
+  assert $ findIndex (_ == 3) (l [1, 2, 1]) == Nothing
 
   log "findLastIndex should return the last index of an item in an list"
-  assert $ findLastIndex (/= 1) (l [2, 1, 2]) == Just 2
-  assert $ findLastIndex (== 3) (l [2, 1, 2]) == Nothing
+  assert $ findLastIndex (_ /= 1) (l [2, 1, 2]) == Just 2
+  assert $ findLastIndex (_ == 3) (l [2, 1, 2]) == Nothing
 
   log "insertAt should add an item at the specified index"
   assert $ (insertAt 0 1 (l [2, 3])) == Just (l [1, 2, 3])
@@ -150,22 +150,22 @@ testList = do
   assert $ (updateAt 1 9 nil) == Nothing
 
   log "modifyAt should update an item at the specified index"
-  assert $ (modifyAt 0 (+ 1) (l [1, 2, 3])) == Just (l [2, 2, 3])
-  assert $ (modifyAt 1 (+ 1) (l [1, 2, 3])) == Just (l [1, 3, 3])
+  assert $ (modifyAt 0 (_ + 1) (l [1, 2, 3])) == Just (l [2, 2, 3])
+  assert $ (modifyAt 1 (_ + 1) (l [1, 2, 3])) == Just (l [1, 3, 3])
 
   log "modifyAt should return Nothing if the index is out of range"
-  assert $ (modifyAt 1 (+ 1) nil) == Nothing
+  assert $ (modifyAt 1 (_ + 1) nil) == Nothing
 
   log "alterAt should update an item at the specified index when the function returns Just"
-  assert $ (alterAt 0 (Just <<< (+ 1)) (l [1, 2, 3])) == Just (l [2, 2, 3])
-  assert $ (alterAt 1 (Just <<< (+ 1)) (l [1, 2, 3])) == Just (l [1, 3, 3])
+  assert $ (alterAt 0 (Just <<< (_ + 1)) (l [1, 2, 3])) == Just (l [2, 2, 3])
+  assert $ (alterAt 1 (Just <<< (_ + 1)) (l [1, 2, 3])) == Just (l [1, 3, 3])
 
   log "alterAt should drop an item at the specified index when the function returns Nothing"
   assert $ (alterAt 0 (const Nothing) (l [1, 2, 3])) == Just (l [2, 3])
   assert $ (alterAt 1 (const Nothing) (l [1, 2, 3])) == Just (l [1, 3])
 
   log "alterAt should return Nothing if the index is out of range"
-  assert $ (alterAt 1 (Just <<< (+ 1)) nil) == Nothing
+  assert $ (alterAt 1 (Just <<< (_ + 1)) nil) == Nothing
 
   log "reverse should reverse the order of items in an list"
   assert $ (reverse (l [1, 2, 3])) == l [3, 2, 1]
@@ -204,22 +204,22 @@ testList = do
   assert $ (take 1 nil) == nil
 
   log "takeWhile should keep all values that match a predicate from the front of an list"
-  assert $ (takeWhile (/= 2) (l [1, 2, 3])) == l [1]
-  assert $ (takeWhile (/= 3) (l [1, 2, 3])) == l [1, 2]
-  assert $ (takeWhile (/= 1) nil) == nil
+  assert $ (takeWhile (_ /= 2) (l [1, 2, 3])) == l [1]
+  assert $ (takeWhile (_ /= 3) (l [1, 2, 3])) == l [1, 2]
+  assert $ (takeWhile (_ /= 1) nil) == nil
 
   log "drop should remove the specified number of items from the front of an list"
   assert $ (drop 1 (l [1, 2, 3])) == l [2, 3]
   assert $ (drop 2 (l [1, 2, 3])) == l [3]
   assert $ (drop 1 nil) == nil
 
   log "dropWhile should remove all values that match a predicate from the front of an list"
-  assert $ (dropWhile (/= 1) (l [1, 2, 3])) == l [1, 2, 3]
-  assert $ (dropWhile (/= 2) (l [1, 2, 3])) == l [2, 3]
-  assert $ (dropWhile (/= 1) nil) == nil
+  assert $ (dropWhile (_ /= 1) (l [1, 2, 3])) == l [1, 2, 3]
+  assert $ (dropWhile (_ /= 2) (l [1, 2, 3])) == l [2, 3]
+  assert $ (dropWhile (_ /= 1) nil) == nil
 
   log "span should split an list in two based on a predicate"
-  let spanResult = span (< 4) (l [1, 2, 3, 4, 5, 6, 7])
+  let spanResult = span (_ < 4) (l [1, 2, 3, 4, 5, 6, 7])
   assert $ spanResult.init == l [1, 2, 3]
   assert $ spanResult.rest == l [4, 5, 6, 7]
 

test/Test/Data/List/Lazy.purs

@@ -1,9 +1,9 @@
 module Test.Data.List.Lazy (testListLazy) where
 
-import Prelude
+import Prelude (Unit, (*), zero, (/=), mod, (==), ($), bind, show, (<), (&&), map, const, (+), (<<<), negate, compare, flip)
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Console (CONSOLE(), log)
-import Data.List.Lazy
+import Data.List.Lazy (List, nil, cons, zip, zipWith, intersectBy, intersect, (\\), deleteBy, delete, unionBy, union, nubBy, nub, groupBy, group, span, dropWhile, drop, takeWhile, take, catMaybes, mapMaybe, range, filter, concat, concatMap, reverse, alterAt, modifyAt, updateAt, deleteAt, insertAt, (!!), uncons, init, tail, last, head, insertBy, insert, length, null, singleton, fromFoldable, transpose, (:))
 import Data.Maybe (Maybe(..), isNothing)
 import Data.Maybe.Unsafe (fromJust)
 import Data.Tuple (Tuple(..))
@@ -136,12 +136,12 @@ testListLazy = do
   assert $ (updateAt 1 9 (l [1, 2, 3])) == (l [1, 9, 3])
 
   log "modifyAt should update an item at the specified index"
-  assert $ (modifyAt 0 (+ 1) (l [1, 2, 3])) == (l [2, 2, 3])
-  assert $ (modifyAt 1 (+ 1) (l [1, 2, 3])) == (l [1, 3, 3])
+  assert $ (modifyAt 0 (_ + 1) (l [1, 2, 3])) == (l [2, 2, 3])
+  assert $ (modifyAt 1 (_ + 1) (l [1, 2, 3])) == (l [1, 3, 3])
 
   log "alterAt should update an item at the specified index when the function returns Just"
-  assert $ (alterAt 0 (Just <<< (+ 1)) (l [1, 2, 3])) == (l [2, 2, 3])
-  assert $ (alterAt 1 (Just <<< (+ 1)) (l [1, 2, 3])) == (l [1, 3, 3])
+  assert $ (alterAt 0 (Just <<< (_ + 1)) (l [1, 2, 3])) == (l [2, 2, 3])
+  assert $ (alterAt 1 (Just <<< (_ + 1)) (l [1, 2, 3])) == (l [1, 3, 3])
 
   log "alterAt should drop an item at the specified index when the function returns Nothing"
   assert $ (alterAt 0 (const Nothing) (l [1, 2, 3])) == (l [2, 3])
@@ -184,22 +184,22 @@ testListLazy = do
   assert $ (take 1 nil') == nil'
 
   log "takeWhile should keep all values that match a predicate from the front of an list"
-  assert $ (takeWhile (/= 2) (l [1, 2, 3])) == l [1]
-  assert $ (takeWhile (/= 3) (l [1, 2, 3])) == l [1, 2]
-  assert $ (takeWhile (/= 1) nil') == nil'
+  assert $ (takeWhile (_ /= 2) (l [1, 2, 3])) == l [1]
+  assert $ (takeWhile (_ /= 3) (l [1, 2, 3])) == l [1, 2]
+  assert $ (takeWhile (_ /= 1) nil') == nil'
 
   log "drop should remove the specified number of items from the front of an list"
   assert $ (drop 1 (l [1, 2, 3])) == l [2, 3]
   assert $ (drop 2 (l [1, 2, 3])) == l [3]
   assert $ (drop 1 nil') == nil'
 
   log "dropWhile should remove all values that match a predicate from the front of an list"
-  assert $ (dropWhile (/= 1) (l [1, 2, 3])) == l [1, 2, 3]
-  assert $ (dropWhile (/= 2) (l [1, 2, 3])) == l [2, 3]
-  assert $ (dropWhile (/= 1) nil') == nil'
+  assert $ (dropWhile (_ /= 1) (l [1, 2, 3])) == l [1, 2, 3]
+  assert $ (dropWhile (_ /= 2) (l [1, 2, 3])) == l [2, 3]
+  assert $ (dropWhile (_ /= 1) nil') == nil'
 
   log "span should split an list in two based on a predicate"
-  let spanResult = span (< 4) (l [1, 2, 3, 4, 5, 6, 7])
+  let spanResult = span (_ < 4) (l [1, 2, 3, 4, 5, 6, 7])
   assert $ spanResult.init == l [1, 2, 3]
   assert $ spanResult.rest == l [4, 5, 6, 7]
 

test/Test/Data/List/Unsafe.purs

@@ -1,10 +1,10 @@
 module Test.Data.List.Unsafe (testListUnsafe) where
 
-import Prelude
+import Prelude (Unit, bind, (==), ($))
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Console (CONSOLE(), log)
 import Data.List (List(..), fromFoldable)
-import Data.List.Unsafe
+import Data.List.Unsafe (init, tail, last, head)
 import Test.Assert (ASSERT(), assert, assertThrows)
 
 testListUnsafe :: forall eff. Eff (assert :: ASSERT, console :: CONSOLE | eff) Unit

test/Test/Data/List/ZipList.purs

@@ -1,15 +1,10 @@
 module Test.Data.List.ZipList (testZipList) where
 
-import Prelude
+import Prelude (class Eq, Unit, (<<<), (<*>), (<$>), (==), ($), const, (*), bind, (+))
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Console (CONSOLE(), log)
-import Data.Foldable
-import Data.Monoid.Additive
 import Data.List.Lazy as LazyList
 import Data.List.ZipList (ZipList(..))
-import Data.Maybe (Maybe(..), isNothing)
-import Data.Maybe.Unsafe (fromJust)
-import Data.Tuple (Tuple(..))
 import Data.Array as Array
 import Test.Assert (ASSERT(), assert)
 

test/Test/Main.purs

@@ -1,13 +1,13 @@
 module Test.Main where
 
-import Prelude
+import Prelude (Unit, bind)
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Console (CONSOLE())
 import Test.Assert (ASSERT())
-import Test.Data.List
-import Test.Data.List.Lazy
-import Test.Data.List.ZipList
-import Test.Data.List.Unsafe
+import Test.Data.List (testList)
+import Test.Data.List.Lazy (testListLazy)
+import Test.Data.List.ZipList (testZipList)
+import Test.Data.List.Unsafe (testListUnsafe)
 
 main :: forall eff. Eff (assert :: ASSERT, console :: CONSOLE | eff) Unit
 main = do