reorg


Type checking and polymorphism via fallbacks.

Installation

``
$ npm install reorg
`




Examples

`js
var fn = reorg(function(str, obj, cb) {
cb(str, JSON.stringify(obj));
}, "string", "object");

var next = function(a, b) {
console.log("A:", a, "B:", b);
}

fn(next);
// => A: B: {}

fn("Hello", next);
// => "A: Hello B: {}"

fn({ key : "val"}, next);
// => A: B: {"key":"val"}

fn("Hello", {"key": "val" }, next);
// => A: Hello B: {"key":"val"}

var anotherFn = reorg(function(requiredString, optionalCallback) {
optionalCallback(requiredString);
}, "string!", ["function", function() {}]);

anotherFn();
// => Error: Expected argument undefined to be of type string

anotherFn("Hello");
// => executes, disappearing into space
`




API

reorg ⇒ function
[.args(argv, constraints, [truncate])](#reorg.args) => Array
.checkArg(arg, constraint) ⇒ Object
.isType(arg, type) ⇒ Boolean
.defaultForType(type) ⇒ \*




$3

Adds type checking and polymorphism to a function.

Returns: function - Returns wrapped function.

| Param | Type | Description |
| --- | --- | --- |
| fn | function | The function to wrap. |
| ...constraint | Contraint | Splat of constraints |

Example
`js
var newFn = reorg(function(requiredString, optionalCallback) {
optionalCallback(requiredString);
}, "string!", ["function", function(next) { next(); }]);
`




$3

Checks an array of arguments against an array of constraints, and optionally
truncates the results.

Returns: Array - Array of reorganized arguments.

| Param | Type | Default | Description |
| --- | --- | --- | --- |
| argv | Array | | The arguments array to check. |
| constraints | Array | | An of corresponding constraints. |
| [truncate] | Boolean | false | If true, truncates results at longer of argv/constraints. |

$3

Checks single argument against a constraint. Returns object containing
fallback value if pass fails.

The following are valid constraints:{
* "string"
* "string!" (indicates required)
* ["string", "Fallback string"]
* ["string!", "Fallback string"]
* [testFn, fallbackValue]
* [["string", testFn1, testFn2], fallbackValue]}

Returns: Object - Returns {pass, fallback}.

| Param | Type | Description |
| --- | --- | --- |
| arg | \* | The argument to check. |
| constraint | Constraint | The constraint to check against. |

Example
`js
reorg.checkArg(123, "string");
// => { pass : false, fallback : "" }
`



$3


Checks if an argument is of a type. type` can include primitive types,
"array", or a function

Returns: Boolean - Whether the check passes/fails.

| Param | Type | Description |
| --- | --- | --- |
| arg | \* | The value to check. |
| type | String | function | A type or predicate to check against. |

$3

Fallback values for types. Throws error if not string, object or array.

Kind: static method of reorg
Returns: \* - A default value.

| Param | Type | Description |
| --- | --- | --- |
| type | String | Indicates which type for which we want fallback. |

License

MIT