Updates for RC

Author: garyb

.gitignore

@@ -1,5 +1,8 @@
-.psci
-/output/
-/node_modules/
+/.*
+!/.gitignore
+!/.jscsrc
+!/.jshintrc
+!/.travis.yml
 /bower_components/
-/tmp/
+/node_modules/
+/output/

.jscsrc

@@ -0,0 +1,12 @@
+{
+  "preset": "grunt",
+  "disallowSpacesInAnonymousFunctionExpression": null,
+  "requireSpacesInAnonymousFunctionExpression": {
+    "beforeOpeningRoundBrace": true,
+    "beforeOpeningCurlyBrace": true
+  },
+  "disallowSpacesInsideObjectBrackets": null,
+  "requireSpacesInsideObjectBrackets": "all",
+  "validateQuoteMarks": "\"",
+  "requireCurlyBraces": null
+}

.jshintrc

@@ -0,0 +1,19 @@
+{
+  "bitwise": true,
+  "eqeqeq": true,
+  "forin": true,
+  "freeze": true,
+  "funcscope": true,
+  "futurehostile": true,
+  "globalstrict": true,
+  "latedef": true,
+  "maxparams": 1,
+  "noarg": true,
+  "nocomma": true,
+  "nonew": true,
+  "notypeof": true,
+  "singleGroups": true,
+  "undef": true,
+  "unused": true,
+  "eqnull": true
+}

.travis.yml

@@ -8,8 +8,7 @@ install:
   - 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 bower grunt-cli -g
-  - npm install
-  - bower update 
+  - npm install bower gulp -g
+  - npm install && bower install
 script:
-  - grunt
+  - gulp

Gruntfile.js

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Phil Freeman
+Copyright (c) 2014 PureScript
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

LICENSE-MIT renamed to LICENSE

@@ -1,68 +1,15 @@
-# Module Documentation
+# purescript-exists
 
-## Module Data.Exists
+[![Build Status](https://travis-ci.org/purescript/purescript-exists.svg?branch=master)](https://travis-ci.org/purescript/purescript-exists)
 
-#### `Exists`
+Existential types as a library.
 
-``` purescript
-data Exists :: (* -> *) -> *
-```
-
-This type constructor can be used to existentially quantify over a type of kind `*`.
-
-Specifically, the type `Exists f` is isomorphic to the existential type `exists a. f a`.
-
-Existential types can be encoded using universal types (`forall`) for endofunctors in more general
-categories. The benefit of this library is that, by using the FFI, we can create an efficient
-representation of the existential by simply hiding type information.
-
-For example, consider the type `exists s. Tuple s (s -> Tuple s a)` which represents infinite streams
-of elements of type `a`.
+## Installation
 
-This type can be constructed by creating a type constructor `StreamF` as follows:
-
-```purescript
-data StreamF a s = StreamF s (s -> Tuple s a) 
 ```
-
-We can then define the type of streams using `Exists`:
-
-```purescript
-type Stream a = Exists (StreamF a)
+bower install purescript-exists
 ```
 
-#### `mkExists`
-
-``` purescript
-mkExists :: forall f a. f a -> Exists f
-```
-
-The `mkExists` function is used to introduce a value of type `Exists f`, by providing a value of
-type `f a`, for some type `a` which will be hidden in the existentially-quantified type.
-
-For example, to create a value of type `Stream Number`, we might use `mkExists` as follows:
-
-```purescript
-nats :: Stream Number
-nats = mkExists $ StreamF 0 (\n -> Tuple (n + 1) n)
-```
-
-#### `runExists`
-
-``` purescript
-runExists :: forall f r. (forall a. f a -> r) -> Exists f -> r
-```
-
-The `runExists` function is used to eliminate a value of type `Exists f`. The rank 2 type ensures
-that the existentially-quantified type does not escape its scope. Since the function is required
-to work for _any_ type `a`, it will work for the existentially-quantified type.
-
-For example, we can write a function to obtain the head of a stream by using `runExists` as follows:
+## Module documentation
 
-```purescript
-head :: forall a. Stream a -> a
-head = runExists head'
-  where
-  head' :: forall s. StreamF a s -> a
-  head' (StreamF s f) = snd (f s) 
-```
+- [Data.Exists](docs/Data.Exists.md)

README.md

@@ -2,20 +2,22 @@
   "name": "purescript-exists",
   "description": "Existential types as a library",
   "keywords": ["purescript"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/purescript/purescript-exists.git"
+  },
   "ignore": [
     "**/.*",
     "bower_components",
     "node_modules",
     "output",
-    "tests",
-    "output",
-    "js",
-    "tmp",
+    "test",
     "bower.json",
-    "Gruntfile.js",
+    "gulpfile.js",
     "package.json"
   ],
   "devDependencies": {
-    "purescript-console": "~0.1.0"
+    "purescript-console": "^0.1.0"
   }
 }

bower.json

@@ -0,0 +1,68 @@
+## Module Data.Exists
+
+#### `Exists`
+
+``` purescript
+data Exists :: (* -> *) -> *
+```
+
+This type constructor can be used to existentially quantify over a type of kind `*`.
+
+Specifically, the type `Exists f` is isomorphic to the existential type `exists a. f a`.
+
+Existential types can be encoded using universal types (`forall`) for endofunctors in more general
+categories. The benefit of this library is that, by using the FFI, we can create an efficient
+representation of the existential by simply hiding type information.
+
+For example, consider the type `exists s. Tuple s (s -> Tuple s a)` which represents infinite streams
+of elements of type `a`.
+
+This type can be constructed by creating a type constructor `StreamF` as follows:
+
+```purescript
+data StreamF a s = StreamF s (s -> Tuple s a) 
+```
+
+We can then define the type of streams using `Exists`:
+
+```purescript
+type Stream a = Exists (StreamF a)
+```
+
+#### `mkExists`
+
+``` purescript
+mkExists :: forall f a. f a -> Exists f
+```
+
+The `mkExists` function is used to introduce a value of type `Exists f`, by providing a value of
+type `f a`, for some type `a` which will be hidden in the existentially-quantified type.
+
+For example, to create a value of type `Stream Number`, we might use `mkExists` as follows:
+
+```purescript
+nats :: Stream Number
+nats = mkExists $ StreamF 0 (\n -> Tuple (n + 1) n)
+```
+
+#### `runExists`
+
+``` purescript
+runExists :: forall f r. (forall a. f a -> r) -> Exists f -> r
+```
+
+The `runExists` function is used to eliminate a value of type `Exists f`. The rank 2 type ensures
+that the existentially-quantified type does not escape its scope. Since the function is required
+to work for _any_ type `a`, it will work for the existentially-quantified type.
+
+For example, we can write a function to obtain the head of a stream by using `runExists` as follows:
+
+```purescript
+head :: forall a. Stream a -> a
+head = runExists head'
+  where
+  head' :: forall s. StreamF a s -> a
+  head' (StreamF s f) = snd (f s) 
+```
+
+

docs/Data.Exists.md

@@ -0,0 +1,68 @@
+/* jshint node: true */
+"use strict";
+
+var gulp = require("gulp");
+var jshint = require("gulp-jshint");
+var jscs = require("gulp-jscs");
+var plumber = require("gulp-plumber");
+var purescript = require("gulp-purescript");
+var rimraf = require("rimraf");
+var run = require("gulp-run");
+
+var sources = [
+  "src/**/*.purs",
+  "bower_components/purescript-*/src/**/*.purs"
+];
+
+var foreigns = [
+  "src/**/*.js",
+  "bower_components/purescript-*/src/**/*.js"
+];
+
+gulp.task("clean-docs", function (cb) {
+  rimraf("docs", cb);
+});
+
+gulp.task("clean-output", function (cb) {
+  rimraf("output", cb);
+});
+
+gulp.task("clean", ["clean-docs", "clean-output"]);
+
+gulp.task("lint", function() {
+  return gulp.src("src/**/*.js")
+    .pipe(jshint())
+    .pipe(jshint.reporter())
+    .pipe(jscs());
+});
+
+gulp.task("make", ["lint"], function() {
+  return gulp.src(sources)
+    .pipe(plumber())
+    .pipe(purescript.pscMake({ ffi: foreigns }));
+});
+
+gulp.task("docs", ["clean-docs"], function () {
+  return gulp.src(sources)
+    .pipe(plumber())
+    .pipe(purescript.pscDocs({
+      docgen: {
+        "Data.Exists": "docs/Data.Exists.md"
+      }
+    }));
+});
+
+gulp.task("dotpsci", function () {
+  return gulp.src(sources)
+    .pipe(plumber())
+    .pipe(purescript.dotPsci());
+});
+
+gulp.task("test", ["make"], function() {
+  return gulp.src(sources.concat(["test/**/*.purs"]))
+    .pipe(plumber())
+    .pipe(purescript.psc({ main: "Test.Main", ffi: foreigns }))
+    .pipe(run("node"));
+});
+
+gulp.task("default", ["make", "docs", "dotpsci", "test"]);

gulpfile.js

@@ -1,16 +1,12 @@
 {
-  "name": "purescript-exists",
-  "version": "0.1.0",
-  "description": "Existential types as a library",
-  "main": "",
   "private": true,
-  "author": "Phil Freeman",
-  "license": "MIT",
-  "dependencies": {
-    "grunt": "~0.4.4",
-    "grunt-contrib-copy": "~0.5.0",
-    "grunt-contrib-clean": "~0.5.0",
-    "grunt-execute": "~0.1.5",
-    "grunt-purescript": "~0.6.0"
+  "devDependencies": {
+    "gulp": "^3.8.11",
+    "gulp-jscs": "^1.6.0",
+    "gulp-jshint": "^1.10.0",
+    "gulp-plumber": "^1.0.0",
+    "gulp-purescript": "^0.5.0-rc.1",
+    "gulp-run": "^1.6.8",
+    "rimraf": "^2.3.3"
   }
 }