https://github.com/junosuarez/node-connective
node module: combine predicate (bool returning) functions with propositional logic connectives (and, or, not)
https://github.com/junosuarez/node-connective
Last synced: 11 months ago
JSON representation
node module: combine predicate (bool returning) functions with propositional logic connectives (and, or, not)
- Host: GitHub
- URL: https://github.com/junosuarez/node-connective
- Owner: junosuarez
- License: mit
- Created: 2013-02-08T03:22:43.000Z (over 13 years ago)
- Default Branch: master
- Last Pushed: 2013-02-11T05:30:01.000Z (over 13 years ago)
- Last Synced: 2025-08-16T04:07:55.908Z (11 months ago)
- Language: JavaScript
- Size: 96.7 KB
- Stars: 3
- Watchers: 6
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
# connective
combine predicate (bool returning) functions with propositional logic connectives (and, or, not)
## installation
$ npm install connective
## usage
```js
var connective = require('connective')
var or = connective.or
var and = connective.and
var not = connective.not
function wearsFlannel (person) {
return person.wearing === 'flannel'
}
function ridesBikes (person) {
return person.rides === 'bikes'
}
var isSquare = not(or(wearsFlannel, ridesBikes))
var isHipster = and(wearsFlannel, ridesBikes)
var isLumberjack = and(wearsFlannel, not(ridesBikes))
var people = {
jon: { wearing: 'flannel', rides: 'nothing'}
kurt: { wearing: 'flannel', rides: 'bikes'}
bob: { wearing: 'hoodie', rides: 'scooters'}
}
for(var name in people) {
var person = people[name]
console.log(name, isSquare(person), isHipster(person), isLumberjack(person))
}
```
## about
In propositional logic, boolean statements are joined together by connectives. Logicians would call them conjunctions, disjunctions, and negations, but programmers know them as `&&`, `||`, and `!`. The problem with using these language-level connective operators is that they apply at evaluation time, and thus aren't very composable.
Functions which take a value and return a boolean are known as predicates. They are useful, for example, in conditional branching, validation, and business rules.
The functions in `connective` let you compose predicates into composite expressions which can be used as functions and evaluated later against other data.
## api
In describing function signatures below, `Predicate` is a function which takes any number of arguments and returns a `boolean`: `function(...) => boolean`
### `connective.or: function (term1 : Predicate, ..., termN : Predicate) => Predicate`
Returns a Predicate combining one or more Predicate terms with a logical `or` (disjunction), roughly equivalent to writing
function (x) { return Predicate1(x) || Predicate2(x) }
The returned Predicate will pass through its `this` context and arguments to each of the Predicate terms which are necessary to evaluate the expression.
### `connective.and: function (term1 : Predicate, ... termN : Predicate) => Predicate`
Returns a Predicate combining one or more Predicate terms with a logical `and` (conjunction), roughly equivalent to writing
function (x) { return Predicate1(x) && Predicate2(x) }
The returned Predicate will pass through its `this` context and arguments to each of the Predicate terms.
### `connective.not: function (term : Predicate) => Predicate`
Returns a Predicate negating `term`, roughly equivalent to writing
function (x) { return !Predicate(x) }
The returned Predicate will pass through its `this` context and arguments to `term`
## running the tests
$ npm install
$ npm test
## contributors
jden
## license
MIT. (c) 2013 Agile Diagnosis. See LICENSE.md