patroon 0.4.3 → 1.0.0

package/README.md

@@ -192,8 +192,8 @@ builtin node error constructors in this example.
 
 ```js ./tape-test
 patroon(
-  TypeError, 'is a type error',
-  Error, 'is an error'
+  instanceOf(TypeError), 'is a type error',
+  instanceOf(Error), 'is an error'
 )(new Error())
 ```
 ```
@@ -213,8 +213,8 @@ Because of this you can match a TypeError with an Error.
 
 ```js ./tape-test
 patroon(
-  Error, 'matches on error',
-  TypeError, 'matches on type error'
+  instanceOf(Error), 'matches on error',
+  instanceOf(TypeError), 'matches on type error'
 )(new TypeError())
 ```
 ```
@@ -226,9 +226,9 @@ Here you should use the every helper.
 
 ```js ./tape-test
 patroon(
-  every(TypeError, { value: 20 }), 'type error where value is 20',
-  every(Error, { value: 30 }), 'error where value is 30',
-  every(Error, { value: 20 }), 'error where value is 20'
+  every(instanceOf(TypeError), { value: 20 }), 'type error where value is 20',
+  every(instanceOf(Error), { value: 30 }), 'error where value is 30',
+  every(instanceOf(Error), { value: 20 }), 'error where value is 20'
 )(Object.assign(new TypeError(), { value: 20 }))
 ```
 ```
@@ -251,6 +251,35 @@ patroon([], 'is array')([])
 patroon(Array, 'is array')([])
 ```
 
+A less intuitive case:
+
+```js ./tape-test > /dev/null
+patroon({}, 'is object')([])
+patroon([], 'is array')({})
+```
+
+Patroon allows this because Arrays can have properties defined.
+
+```js ./tape-test > /dev/null
+const array = []
+array.prop = 42
+
+patroon({prop: _}, 'has prop')(array)
+```
+
+The other way around is also allowed even if it seems weird.
+
+```js ./tape-test > /dev/null
+const object = {0: 42}
+patroon([42], 'has 0th')(object)
+```
+
+If you do not desire this loose behavior you can use a predicate to make sure
+something is an array or object.
+
+```js ./tape-test > /dev/null
+patroon(Array.isArray, 'is array')([])
+```
 
 ### Reference
 
@@ -259,7 +288,7 @@ helper.
 
 ```js ./tape-test
 patroon(
-  Error, 'is an instance of Error',
+  instanceOf(Error), 'is an instance of Error',
   reference(Error), 'is the Error constructor'
 )(Error)
 ```
@@ -488,12 +517,12 @@ const oneIsTwo = patroon(1, 2)
 oneIsTwo(3)
 ```
 ```
-/home/ant/projects/patroon/src/index.js:88
-    if (isNil(found)) { throw new NoMatchError(`Not able to match any pattern for value ${JSON.stringify(args)}`) }
-                        ^
+[ 3 ]
+/home/ant/projects/patroon/src/index.js:92
+      throw error
+      ^
 
-NoMatchError: Not able to match any pattern for value [3]
-    at /home/ant/projects/patroon/src/index.js:88:31
+NoMatchError: Not able to match any pattern for arguments
 ```
 
 #### UnevenArgumentCountError
@@ -504,12 +533,12 @@ Another error that occurs is when the patroon function is not used correctly.
 patroon(1)
 ```
 ```
-/home/ant/projects/patroon/src/index.js:81
+/home/ant/projects/patroon/src/index.js:79
   if (!isEven(list.length)) { throw new UnevenArgumentCountError('Patroon should have an even amount of arguments.') }
                               ^
 
 UnevenArgumentCountError: Patroon should have an even amount of arguments.
-    at patroon (/home/ant/projects/patroon/src/index.js:81:37)
+    at patroon (/home/ant/projects/patroon/src/index.js:79:37)
 ```
 
 #### PatroonError
@@ -517,7 +546,7 @@ UnevenArgumentCountError: Patroon should have an even amount of arguments.
 All errors patroon produces can be matched against the PatroonError using `instanceof`.
 
 ```js ./tape-test
-const isPatroonError = patroon(PatroonError, 'patroon is causing an error')
+const isPatroonError = patroon(instanceOf(PatroonError), 'patroon is causing an error')
 
 isPatroonError(new NoMatchError())
 isPatroonError(new UnevenArgumentCountError())
@@ -545,7 +574,7 @@ npx nyc npm t | npx tap-nyc
 npx nyc check-coverage
 ```
 ```
-    > patroon@0.4.2 test
+    > patroon@1.0.0 test
     > tape ./src/index.test.js
     -------------|---------|----------|---------|---------|-------------------
     File         | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
@@ -559,7 +588,7 @@ npx nyc check-coverage
   total:     15
   passing:   15
 
-  duration:  722ms
+  duration:  1s
 
 ```
 

package/README.mz

@@ -142,8 +142,8 @@ builtin node error constructors in this example.
 
 ```js ./tape-test
 patroon(
-  TypeError, 'is a type error',
-  Error, 'is an error'
+  instanceOf(TypeError), 'is a type error',
+  instanceOf(Error), 'is an error'
 )(new Error())
 ```
 
@@ -157,8 +157,8 @@ Because of this you can match a TypeError with an Error.
 
 ```js ./tape-test
 patroon(
-  Error, 'matches on error',
-  TypeError, 'matches on type error'
+  instanceOf(Error), 'matches on error',
+  instanceOf(TypeError), 'matches on type error'
 )(new TypeError())
 ```
 
@@ -167,9 +167,9 @@ Here you should use the every helper.
 
 ```js ./tape-test
 patroon(
-  every(TypeError, { value: 20 }), 'type error where value is 20',
-  every(Error, { value: 30 }), 'error where value is 30',
-  every(Error, { value: 20 }), 'error where value is 20'
+  every(instanceOf(TypeError), { value: 20 }), 'type error where value is 20',
+  every(instanceOf(Error), { value: 30 }), 'error where value is 30',
+  every(instanceOf(Error), { value: 20 }), 'error where value is 20'
 )(Object.assign(new TypeError(), { value: 20 }))
 ```
 
@@ -189,6 +189,35 @@ patroon([], 'is array')([])
 patroon(Array, 'is array')([])
 ```
 
+A less intuitive case:
+
+```js ./tape-test > /dev/null
+patroon({}, 'is object')([])
+patroon([], 'is array')({})
+```
+
+Patroon allows this because Arrays can have properties defined.
+
+```js ./tape-test > /dev/null
+const array = []
+array.prop = 42
+
+patroon({prop: _}, 'has prop')(array)
+```
+
+The other way around is also allowed even if it seems weird.
+
+```js ./tape-test > /dev/null
+const object = {0: 42}
+patroon([42], 'has 0th')(object)
+```
+
+If you do not desire this loose behavior you can use a predicate to make sure
+something is an array or object.
+
+```js ./tape-test > /dev/null
+patroon(Array.isArray, 'is array')([])
+```
 
 ### Reference
 
@@ -197,7 +226,7 @@ helper.
 
 ```js ./tape-test
 patroon(
-  Error, 'is an instance of Error',
+  instanceOf(Error), 'is an instance of Error',
   reference(Error), 'is the Error constructor'
 )(Error)
 ```
@@ -390,7 +419,7 @@ patroon(1)
 All errors patroon produces can be matched against the PatroonError using `instanceof`.
 
 ```js ./tape-test
-const isPatroonError = patroon(PatroonError, 'patroon is causing an error')
+const isPatroonError = patroon(instanceOf(PatroonError), 'patroon is causing an error')
 
 isPatroonError(new NoMatchError())
 isPatroonError(new UnevenArgumentCountError())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patroon",
-  "version": "0.4.3",
+  "version": "1.0.0",
   "description": "Pattern matching library",
   "repository": "github:bas080/patroon",
   "main": "./src/index.js",

package/src/helpers.js

@@ -8,10 +8,6 @@ const toPairs = items => {
 
 const isNil = x => !(x != null)
 
-function isConstructor (func) {
-  return Boolean(func && typeof func === 'function' && func.prototype && func.prototype.constructor)
-}
-
 function isDefined (x) {
   return x != null
 }
@@ -24,7 +20,6 @@ const is = Ctor => instance => isDefined(instance) && (instance.constructor ===
 module.exports = {
   isDefined,
   always: x => () => x,
-  isConstructor,
   is,
   toPairs,
   isNil,

package/src/index.js

@@ -1,5 +1,5 @@
 const { mapLeaves, path, PathError } = require('./walkable')()
-const { isConstructor, isFunction, equals, T, is, tryCatch, isEven, isNil, toPairs, always } = require('./helpers')
+const { isFunction, equals, T, is, tryCatch, isEven, isNil, toPairs, always } = require('./helpers')
 
 const deprecated = (fn, message) => (...args) => {
   console.error(`[patroon] deprecated: ${message}`)
@@ -41,8 +41,6 @@ const predicate = pattern => {
   const normalize = (value, pth) => {
     if (isRegExp(value)) return arg => value.test(arg)
 
-    if (isConstructor(value)) { return is(value) }
-
     if (isFunction(value)) { return arg => value(path(pth, arg)) }
 
     return arg => equals(path(pth, arg), value)
@@ -85,7 +83,14 @@ const patroon = (...list) => {
   return (...args) => {
     const found = patterns.find(([matches]) => matches(...args))
 
-    if (isNil(found)) { throw new NoMatchError(`Not able to match any pattern for value ${JSON.stringify(args)}`) }
+    if (isNil(found)) {
+      const error = new NoMatchError('Not able to match any pattern for arguments')
+      error.arguments = args
+
+      console.error(args)
+
+      throw error
+    }
 
     return found[1](...args)
   }
@@ -95,6 +100,10 @@ function reference (any) {
   return value => any === value
 }
 
+function instanceOf (ctor) {
+  return value => value instanceof ctor
+}
+
 module.exports = Object.assign(patroon, {
   NoMatchError,
   UnevenArgumentCountError,
@@ -107,5 +116,6 @@ module.exports = Object.assign(patroon, {
   reference,
   typed,
   t: typed,
+  instanceOf,
   _: T
 })

package/src/index.test.js

@@ -2,6 +2,7 @@ const { test } = require('tape')
 const { check, gen } = require('tape-check')
 const {
   reference,
+  instanceOf,
   typed,
   t,
   ref,
@@ -39,9 +40,9 @@ test('Match using reference', t => {
 
 test('Matches on type and value', t => {
   patroon(
-    every(Error, { x: 20 }), () => t.fail(),
-    every(Error, { x: 10 }), () => t.end(),
-    every(Error), () => t.fail()
+    every(instanceOf(Error), { x: 20 }), () => t.fail(),
+    every(instanceOf(Error), { x: 10 }), () => t.end(),
+    instanceOf(Error), () => t.fail()
   )(Object.assign(new Error(), { x: 10 }))
 })
 

package/tape-test

@@ -4,6 +4,7 @@ cat <(echo '
 const {
   _,
   every,
+  instanceOf,
   some,
   multi,
   reference,