Merge pull request #6 from purescript/0.8-updates

Updates for PureScript 0.8

Author: garyb

.travis.yml

@@ -1,14 +1,24 @@
 language: node_js
-sudo: false
-node_js:
-  - 0.10
+sudo: required
+dist: trusty
+node_js: 5
 env:
   - PATH=$HOME/purescript:$PATH
 install:
   - TAG=$(wget -q -O - https://github.com/purescript/purescript/releases/latest --server-response --max-redirect 0 2>&1 | sed -n -e 's/.*Location:.*tag\///p')
   - wget -O $HOME/purescript.tar.gz https://github.com/purescript/purescript/releases/download/$TAG/linux64.tar.gz
   - tar -xvf $HOME/purescript.tar.gz -C $HOME/
   - chmod a+x $HOME/purescript
+  - npm install -g bower
   - npm install
+  - bower install
 script:
-  - npm run build
+  - npm 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}"

README.md

@@ -12,6 +12,6 @@ Unfoldable functors.
 bower install purescript-unfoldable
 ```
 
-## Module documentation
+## Documentation
 
-- [Data.Unfoldable](docs/Data/Unfoldable.md)
+Module documentation is [published on Pursuit](http://pursuit.purescript.org/packages/purescript-unfoldable).

bower.json

@@ -2,9 +2,6 @@
   "name": "purescript-unfoldable",
   "homepage": "https://github.com/purescript/purescript-unfoldable",
   "description": "Unfoldable Functors",
-  "keywords": [
-    "purescript"
-  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -20,11 +17,11 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-arrays": "^0.4.0",
-    "purescript-tuples": "^0.4.0"
+    "purescript-arrays": "^1.0.0-rc.1",
+    "purescript-tuples": "^1.0.0-rc.1"
   },
   "devDependencies": {
-    "purescript-console": "^0.1.0",
-    "purescript-assert": "^0.1.0"
+    "purescript-assert": "^1.0.0-rc.1",
+    "purescript-console": "^1.0.0-rc.1"
   }
 }

docs/Data/Unfoldable.md

@@ -1,11 +1,12 @@
 {
   "private": true,
   "scripts": {
-    "postinstall": "pulp dep install",
-    "build": "pulp build && pulp test && rimraf docs && pulp docs"
+    "clean": "rimraf output && rimraf .pulp-cache",
+    "build": "pulp build",
+    "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^4.0.2",
-    "rimraf": "^2.4.1"
+    "pulp": "^8.1.0",
+    "rimraf": "^2.5.0"
   }
 }

examples/Collatz.purs

@@ -6,15 +6,16 @@
 
 module Data.Unfoldable where
 
-import Prelude (class Applicative, unit, const, (-), (<=), return, bind, ($))
+import Prelude
 
-import Data.Maybe (Maybe(Nothing, Just))
-import Data.Tuple (Tuple(Tuple))
-import Data.Array.ST (pushSTArray, emptySTArray, runSTArray)
-import Data.Traversable (class Traversable, sequence)
 import Control.Monad.Eff (untilE, runPure)
 import Control.Monad.ST (writeSTRef, readSTRef, newSTRef)
 
+import Data.Array.ST (pushSTArray, emptySTArray, runSTArray)
+import Data.Maybe (Maybe(..))
+import Data.Traversable (class Traversable, sequence)
+import Data.Tuple (Tuple(..))
+
 -- | This class identifies data structures which can be _unfolded_,
 -- | generalizing `unfoldr` on arrays.
 -- |
@@ -33,20 +34,20 @@ instance unfoldableArray :: Unfoldable Array where
     untilE $ do
       b1 <- readSTRef seed
       case f b1 of
-        Nothing -> return true
+        Nothing -> pure true
         Just (Tuple a b2) -> do
           pushSTArray arr a
           writeSTRef seed b2
-          return false
-    return arr))
+          pure false
+    pure arr))
 
 -- | Replicate a value some natural number of times.
 -- | For example:
 -- |
 -- | ~~~ purescript
 -- | replicate 2 "foo" == ["foo", "foo"] :: Array String
 -- | ~~~
-replicate :: forall f a. (Unfoldable f) => Int -> a -> f a
+replicate :: forall f a. Unfoldable f => Int -> a -> f a
 replicate n v = unfoldr step n
   where
     step :: Int -> Maybe (Tuple a Int)
@@ -55,8 +56,12 @@ replicate n v = unfoldr step n
       else Just (Tuple v (i - 1))
 
 -- | Perform an Applicative action `n` times, and accumulate all the results.
-replicateA :: forall m f a. (Applicative m, Unfoldable f, Traversable f) =>
-              Int -> m a -> m (f a)
+replicateA
+  :: forall m f a
+   . (Applicative m, Unfoldable f, Traversable f)
+  => Int
+  -> m a
+  -> m (f a)
 replicateA n m = sequence (replicate n m)
 
 -- | The container with no elements - unfolded with zero iterations.
@@ -65,7 +70,7 @@ replicateA n m = sequence (replicate n m)
 -- | ~~~ purescript
 -- | none == [] :: forall a. Array a
 -- | ~~~
-none :: forall f a. (Unfoldable f) => f a
+none :: forall f a. Unfoldable f => f a
 none = unfoldr (const Nothing) unit
 
 -- | Contain a single value.
@@ -74,5 +79,5 @@ none = unfoldr (const Nothing) unit
 -- | ~~~ purescript
 -- | singleton "foo" == ["foo"] :: Array String
 -- | ~~~
-singleton :: forall f a. (Unfoldable f) => a -> f a
+singleton :: forall f a. Unfoldable f => a -> f a
 singleton = replicate 1

package.json

@@ -2,24 +2,42 @@ module Test.Main where
 
 import Prelude
 
-import Control.Monad.Eff (Eff())
-import Control.Monad.Eff.Console
-import Data.Maybe
-import Data.Unfoldable
-import Test.Assert
+import Control.Monad.Eff (Eff)
+import Control.Monad.Eff.Console (CONSOLE, log, logShow)
 
+import Data.Maybe (Maybe(..))
+import Data.Tuple (Tuple(..))
+import Data.Unfoldable as U
+
+import Test.Assert (ASSERT, assert)
+
+collatz :: Int -> Array Int
+collatz = U.unfoldr step
+  where
+  step 1 = Nothing
+  step n =
+    Just $
+      Tuple n $
+        if n `mod` 2 == 0
+        then n / 2
+        else n * 3 + 1
+
+main :: Eff (assert :: ASSERT, console :: CONSOLE) Unit
 main = do
+  log "Collatz 1000"
+  logShow $ collatz 1000
+
   log "Test none"
-  assert $ none == [] :: Array Unit
+  assert $ U.none == [] :: Array Unit
 
   log "Test singleton"
-  assert $ singleton unit == [unit]
+  assert $ U.singleton unit == [unit]
 
   log "Test replicate"
-  assert $ replicate 3 "foo" == ["foo", "foo", "foo"]
+  assert $ U.replicate 3 "foo" == ["foo", "foo", "foo"]
 
   log "Test replicateA"
-  assert $ replicateA 3 [1,2] == [
+  assert $ U.replicateA 3 [1,2] == [
     [1,1,1],[1,1,2], [1,2,1],[1,2,2],
     [2,1,1],[2,1,2], [2,2,1],[2,2,2]
   ]