Initial commit

Author: garyb

.gitignore

@@ -0,0 +1,7 @@
+/.*
+!/.gitignore
+!/.travis.yml
+/output/
+/node_modules/
+/bower_components/
+/tmp/

README.md

@@ -0,0 +1,63 @@
+# Module Documentation
+
+## Module Type.Proxy
+
+
+The `Proxy` type and values are for situations where type information is
+required for an input to determine the type of an output, but where it is
+not possible or convenient to provide a _value_ for the input.
+
+A hypothetical example: if you have a class that is used to handle the
+result of an AJAX request, you may want to use this information to set the
+expected content type of the request, so you might have a class something
+like this:
+
+``` purescript
+class AjaxResponse a where
+  responseType :: a -> ResponseType
+  fromResponse :: Foreign -> a
+```
+
+The problem here is `responseType` requires a value of type `a`, but we
+won't have a value of that type until the request has been completed. The
+solution is to use a `Proxy` type instead:
+
+``` purescript
+class AjaxResponse a where
+  responseType :: Proxy a -> ResponseType
+  fromResponse :: Foreign -> a
+```
+
+We can now call `responseType (Proxy :: Proxy SomeContentType)` to produce
+a `ResponseType` for `SomeContentType` without having to construct some
+empty version of `SomeContentType` first.
+
+#### `Proxy`
+
+``` purescript
+data Proxy a
+  = Proxy 
+```
+
+Value proxy for kind `*` types.
+
+#### `Proxy2`
+
+``` purescript
+data Proxy2 (a :: * -> *)
+  = Proxy2 
+```
+
+Value proxy for kind `* -> *` types.
+
+#### `Proxy3`
+
+``` purescript
+data Proxy3 (a :: * -> * -> *)
+  = Proxy3 
+```
+
+Value proxy for kind `* -> * -> *` types.
+
+
+

bower.json

@@ -0,0 +1,20 @@
+{
+  "name": "purescript-proxy",
+  "homepage": "https://github.com/purescript/purescript-proxy",
+  "description": "Value proxy for type inputs",
+  "keywords": [
+    "purescript"
+  ],
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "bower_components",
+    "node_modules",
+    "output",
+    "test",
+    "tmp",
+    "bower.json",
+    "gulpfile.js",
+    "package.json"
+  ]
+}

gulpfile.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var gulp = require("gulp");
+var plumber = require("gulp-plumber");
+var purescript = require("gulp-purescript");
+var jsvalidate = require("gulp-jsvalidate");
+
+gulp.task("make", function() {
+  return gulp.src(["src/**/*.purs", "bower_components/purescript-*/src/**/*.purs"])
+    .pipe(plumber())
+    .pipe(purescript.pscMake());
+});
+
+gulp.task("jsvalidate", ["make"], function () {
+  return gulp.src("output/**/*.js")
+    .pipe(plumber())
+    .pipe(jsvalidate());
+});
+
+gulp.task("docs", function () {
+  return gulp.src("src/**/*.purs")
+    .pipe(plumber())
+    .pipe(purescript.pscDocs())
+    .pipe(gulp.dest("README.md"));
+});
+
+gulp.task("default", ["jsvalidate", "docs"]);

package.json

@@ -0,0 +1,9 @@
+{
+  "private": true,
+  "devDependencies": {
+    "gulp": "^3.8.11",
+    "gulp-jsvalidate": "^1.0.1",
+    "gulp-plumber": "^1.0.0",
+    "gulp-purescript": "^0.3.1"
+  }
+}

src/Type/Proxy.purs

@@ -0,0 +1,38 @@
+-- | The `Proxy` type and values are for situations where type information is
+-- | required for an input to determine the type of an output, but where it is
+-- | not possible or convenient to provide a _value_ for the input.
+-- |
+-- | A hypothetical example: if you have a class that is used to handle the
+-- | result of an AJAX request, you may want to use this information to set the
+-- | expected content type of the request, so you might have a class something
+-- | like this:
+-- |
+-- | ``` purescript
+-- | class AjaxResponse a where
+-- |   responseType :: a -> ResponseType
+-- |   fromResponse :: Foreign -> a
+-- | ```
+-- |
+-- | The problem here is `responseType` requires a value of type `a`, but we
+-- | won't have a value of that type until the request has been completed. The
+-- | solution is to use a `Proxy` type instead:
+-- |
+-- | ``` purescript
+-- | class AjaxResponse a where
+-- |   responseType :: Proxy a -> ResponseType
+-- |   fromResponse :: Foreign -> a
+-- | ```
+-- |
+-- | We can now call `responseType (Proxy :: Proxy SomeContentType)` to produce
+-- | a `ResponseType` for `SomeContentType` without having to construct some
+-- | empty version of `SomeContentType` first.
+module Type.Proxy where
+
+-- | Value proxy for kind `*` types.
+data Proxy a = Proxy
+
+-- | Value proxy for kind `* -> *` types.
+data Proxy2 (a :: * -> *) = Proxy2
+
+-- | Value proxy for kind `* -> * -> *` types.
+data Proxy3 (a :: * -> * -> *) = Proxy3