text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Highland.js</title>
    <link rel="stylesheet" href="css/normalize.css">
    <link rel="stylesheet" href="css/foundation.css">
    <link rel="stylesheet" href="fonts/foundation-icons/foundation-icons.css">
    <link rel="stylesheet" href="css/highland.css">
    <link rel="stylesheet" href="css/highlight.github.css">

HIGHLAND

The high-level streams library for Node.js and the browser.

$ npm install highland

        Download
        Download (minified)
         Source code

        Download
        Download (minified)
         Source code

Highland.js

Download

Introduction

Examples

Arrays

Async

Laziness

Back-pressure

Currying

Events

Stream Objects

_(source)

destroy

end

pause

resume

write

Transforms

append

batch

batchWithTimeOrCount

collect

compact

consume

debounce

doto

drop

errors

filter

find

findWhere

group

head

intersperse

invoke

last

latest

map

nfcall

pick

pickBy

pluck

ratelimit

reduce

reduce1

reject

scan

scan1

slice

sort

sortBy

split

splitBy

stopOnError

take

tap

throttle

transduce

uniq

uniqBy

where

Higher-order Streams

concat

flatFilter

flatMap

flatten

fork

merge

mergeWithLimit

observe

otherwise

parallel

pipeline

sequence

series

through

zip

zipAll

zipAll0

Consumption

apply

done

each

pipe

pull

toArray

toCallback

Utils

isStream

log

nil

streamifyAll

wrapCallback

Objects

extend

get

keys

pairs

set

values

Functions

compose

curry

flip

ncurry

partial

seq

Operators

add

not

Introduction

        Re-thinking the
        JavaScript
        utility
        belt,
        Highland manages synchronous and asynchronous code easily, using nothing more than
        standard JavaScript and Node-like streams.
        You may be familiar with Promises, EventEmitters and callbacks, but moving
        between them is far from seamless. Thankfully, there exists a deeper abstraction
        which can free our code. By updating the tools we use on Arrays, and applying them
        to values distributed in time instead of space, we can discard plumbing and
        focus on the important things. With Highland, you can switch between
        synchronous and asynchronous data sources at will, without having to
        re-write your code. Time to dive in!

        Made by @caolan, with help and patience from friends - Leave a tip or fork this :)

Usage in the browser

        Highland can be used both in Node.js and in the browser. When you install the highland package,
        you will find a dist/highland.js file in the package hierarchy.
        This file has been prepared with browserify in order to bring a browser-ready version of highland.

      Simply load this script with a <script> tag, and a highland variable
        will be made available in the global javascript scope.

        If you prefer using highland under the name _ like is done in the examples below,
        you can then simply use:

var _ = highland

        You can also integrate highland in your own browserify bundle using a classical browserify workflow,
        but this is beyond the scope of this documentation.

Examples

Converting to/from Highland Streams

_([1,2,3,4]).toArray(function (xs) {
    // xs is [1,2,3,4]
});

Mapping over a Stream

var doubled = _([1,2,3,4]).map(function (x) {
    return x * 2;
});

Reading files in parallel (4 at once)

var data = _(filenames).map(readFile).parallel(4);

Handling errors

data.errors(function (err, rethrow) {
    // handle or rethrow error
});

Piping to a Node Stream

data.pipe(output);

Piping in data from Node Streams

var output = fs.createWriteStream('output');
var docs = db.createReadStream();

// wrap a node stream and pipe to file
_(docs).filter(isBlogpost).pipe(output);

// or, pipe in a node stream directly:
var through = _.pipeline(_.filter(isBlogpost));
docs.pipe(through).pipe(output);

Handling events

var clicks = _('click', btn).map(1);
var counter = clicks.scan(0, _.add);

counter.each(function (n) {
    $('#count').text(n);
});

Arrays

To work with data in Arrays, just wrap it in _(). The Highland methods are then available on it:

var shouty = _(['foo', 'bar', 'baz']).map(toUpperCase);

These methods return Stream objects, not Arrays, so you can chain together method calls:

_(['foo', 'bar', 'baz']).map(toUpperCase).map(function (x) {
    return {name: x};
});

When using the Highland APIs there is little reason to turn this back into an Array, but if you're calling an outside library you may need to convert it back:

_(['foo', 'bar', 'baz']).map(toUpperCase).toArray(function (xs) {
    // xs will now be ['FOO', 'BAR', 'BAZ]
});

Passing a function to the toArray call may seem a little unfamiliar, but this enables an important trick in Highland. Now, without changing any of your existing code, you could swap out ['foo', 'bar', 'baz'] for an asynchronous data source, and it would just work!

You can also pass Arrays into the top-level functions instead of using methods on the Stream object:

_.map(doubled, [1, 2, 3, 4])  // => 2 4 6 8

Note, this still returns a Stream.

Async

Now, let's see how we might swap out an Array source for an asynchronous one. By passing a function to the Stream constructor we can manually push values onto the Stream:

function getData(filename) {
    // create a new Stream
    return _(function (push, next) {
        // do something async when we read from the Stream
        fs.readFile(filename, function (err, data) {
            push(err, data);
            push(null, _.nil);
        });
    });
};

First, we return a new Stream which when read from will read a file (this is called lazy evaluation). When fs.readFile calls its callback, we push the error and data values onto the Stream. Finally, we push _.nil onto the Stream. This is the "end of stream" marker and will tell any consumers of this stream to stop reading.

Since wrapping a callback is a fairly common thing to do, there is a convenience function:

var getData = _.wrapCallback(fs.readFile);

Now we have a new asynchronous source, we can run the exact same code from the Array examples on it:

getData('myfile').map(toUpperCase).map(function (x) {
    return {name: x};
});

With Highland, we really can have one language to work with both synchronous and asynchronous data, whether it's from a Node Stream, an EventEmitter, a callback or an Array. You can even wrap ES6 or jQuery promises:

var foo = _($.getJSON('/api/foo'));

Laziness

When you call map in Highland, it doesn't go off and immediately map over all your data. Rather it defines your intention, and the hard work occurs as you pull data from the Stream. This is lazy evaluation and it's what enables Highland to manage back-pressure and also the sequencing of asynchronous actions, such as reading from a file.

var calls = 0;

var nums = _(['1', '2', '3']).map(function (x) {
    calls++;
    return Number(x);
});

// calls === 0

To get the map iterator to be called, we must consume the stream. A number of Highland methods will do so (e.g., each, done, apply, toArray, pipe, resume). A stream may only be consumed once and consuming an already-consumed stream will result in undefined behavior.

nums.each(function (n) { console.log(n); });

// calls === 3

Equally, when we tell Highland to map a Stream of filenames to the `readFile` function, it doesn't actually go and read all the files at once, it let's us decide on how we want to read them:

filenames.map(readFile).series();
filenames.map(readFile).parallel(10)

Back-pressure

Since Highland is designed to play nicely with Node Streams, it also support back-pressure. This means that a fast source will not overwhelm a slow consumer.

fastSource.map(slowThing)

In the above example, fastSource will be paused while slowThing does its processing.

Some streams (such as those based on events) cannot be paused. In these cases data is buffered until the consumer is ready to handle it. If you expect a non-pausable source to be consumed by a slow consumer, then you should use methods such as throttle or latest to selectively drop data and regulate the flow.

Occasionally, you'll need to split Streams in your program. At this point, Highland will force you to choose between sharing back-pressure with the new consumer, or letting the existing consumer regulate backpressure and have the new consumer simply observe values as they arrive. Attempting to add two consumers to a Stream without calling fork or observe will throw an error.

// shared back-pressure
source.map(output1);
source.fork().map(output2);

// let the first handle backpressure and the second simply observe
source.map(output);
source.observe().map(_.log);

Currying

As well as calling functions as methods on the Stream object, Highland also exports them at the top-level.

mystream.map(doubled)
// is equivalent to
_.map(doubled, mystream)

By convention, all top-level functions are "curryable", meaning you can partially apply their arguments. In the above example, this could be called as:

_.map(doubled)(mystream);

In real-world use, this means you can define the behaviour you'd like before knowing what stream you'd like to perform it on:

// partially apply the filter() function to create a new function
var getBlogposts = _.filter(function (doc) {
    return doc.type === 'blogpost';
});

// now we can use the new function by completing its arguments
getBlogposts(data); // => new Stream of blogposts

You can curry your own functions too:

var myCurryableFn = _.curry(fn);

Events

Streams can be used to handle events as well as data, control-flow and error propagation. This is often a convenient way to filter and combine events into groups, a common goal on dynamically updated sites.

var inbox = _('message', client).where({recipient: 'me'});

If you expect to receive a lot of events, and perform an async process on each of them, then you should sample the events instead of buffering all of them.

// get a frequent event source
var text = _('keyup', $('#searchbox'));

// Regulate event stream:
// - wait until no keyup events for 1s
// - when read from, only return the latest value
var searches = text.debounce(1000).latest();

// map the search events to an AJAX request
var results = searches.map(searchRequest);

// for each response, display it
results.each(function (result) {
    // display result
});

Stream Objects

 Source

 Link

_(source)

The Stream constructor, accepts an array of values or a generator function
as an optional argument. This is typically the entry point to the Highland
APIs, providing a convenient way of chaining calls together.

Arrays - Streams created from Arrays will emit each value of the Array
and then emit a nil value to signal the end of the Stream.

Generators - These are functions which provide values for the Stream.
They are lazy and can be infinite, they can also be asynchronous (for
example, making a HTTP request). You emit values on the Stream by calling
push(err, val), much like a standard Node.js callback. Once it has been
called, the generator function will not be called again unless you call
next(). This call to next() will signal you've finished processing the
current data and allow for the generator function to be called again. If the
Stream is still being consumed the generator function will then be called
again.

You can also redirect a generator Stream by passing a new source Stream
to read from to next. For example: next(other_stream) - then any subsequent
calls will be made to the new source.

Node Readable Stream - Pass in a Node Readable Stream object to wrap
it with the Highland API. Reading from the resulting Highland Stream will
begin piping the data from the Node Stream to the Highland Stream.

A stream constructed in this way relies on Readable#pipe to end the
Highland Stream once there is no more data. Not all Readable Streams do
this. For example, IncomingMessage will only emit close when the client
aborts communications and will not properly call end. In this case, you
can provide an optional onFinished function with the signature
onFinished(readable, callback) as the second argument.

This function will be passed the Readable and a callback that should called
when the Readable ends. If the Readable ended from an error, the error
should be passed as the first argument to the callback. onFinished should
bind to whatever listener is necessary to detect the Readable's completion.
It may also optionally return a cleanup function that will be called to
unbind any listeners that were added. If the callback is called
multiple times, only the first invocation counts. If the callback is
called after the Readable has already ended (e.g., the pipe
method already called end), it will be ignored.

See this issue for a
discussion on why Highland cannot reliably detect stream completion for
all implementations and why the onFinished function is required.

EventEmitter / jQuery Elements - Pass in both an event name and an
event emitter as the two arguments to the constructor and the first
argument emitted to the event handler will be written to the new Stream.

You can pass a mapping hint as the third argument, which specifies how
event arguments are pushed into the stream. If no mapping hint is provided,
only the first value emitted with the event to the will be pushed onto the
Stream.

If mappingHint is a number, an array of that length will be pushed onto
the stream, containing exactly that many parameters from the event. If it's
an array, it's used as keys to map the arguments into an object which is
pushed to the tream. If it is a function, it's called with the event
arguments, and the returned value is pushed.

Promise - Accepts an ES6 / jQuery style promise and returns a
Highland Stream which will emit a single value (or an error). In case you use
bluebird cancellation Highland Stream will be empty for a cancelled promise.

Iterator - Accepts an ES6 style iterator that implements the iterator protocol:
yields all the values from the iterator using its next() method and terminates when the
iterator's done value returns true. If the iterator's next() method throws, the exception will be emitted as an error,
and the stream will be ended with no further calls to next().

Iterable - Accepts an object that implements the iterable protocol,
i.e., contains a method that returns an object that conforms to the iterator protocol. The stream will use the
iterator defined in the Symbol.iterator property of the iterable object to generate emitted values.

Parameters

                  source
                   - Array | Function | Iterator | Iterable | Promise | Readable Stream | String
                   - (optional) source to take values from from

                  onFinished
                   - Function
                   - (optional) a function that detects when the readable completes. Second argument. Only valid if `source` is a Readable.

                  eventEmitter
                   - EventEmitter | jQuery Element
                   - (optional) An event emitter. Second argument. Only valid if `source` is a String.

                  mappingHint
                   - Array | Function | Number
                   - (optional) how to pass the arguments to the callback. Only valid if `source` is a String.

// from an Array
_([1, 2, 3, 4]);

// using a generator function
_(function (push, next) {
    push(null, 1);
    push(err);
    next();
});

// a stream with no source, can pipe node streams through it etc.
var through = _();

// wrapping a Node Readable Stream so you can easily manipulate it
_(readable).filter(hasSomething).pipe(writeable);

// wrapping a Readable that may signify completion by emitting `close`
// (e.g., IncomingMessage).
_(req, function (req, callback) {
    req.on('end', callback)
        .on('close', callback)
        .on('error', callback);

    return function () {
        req.removeListener('end', callback);
        req.removeListener('close', callback);
        req.removeListener('error', callback);
    };
}).pipe(writable);

// creating a stream from events
_('click', btn).each(handleEvent);

// creating a stream from events with mapping
_('request', httpServer, ['req', 'res']).each(handleEvent);

// from a Promise object
var foo = _($.getJSON('/api/foo'));

//from an iterator
var map = new Map([['a', 1], ['b', 2]]);
var bar = _(map.values()).toArray(_.log);
//=> [1, 2]

//from an iterable
var set = new Set([1, 2, 2, 3, 4]);
var bar = _(set).toArray(_.log);
//=> [ 1, 2, 3, 4]

 Source

 Link

Stream.destroy()

Destroys a stream by unlinking it from any consumers and sources. This will
stop all consumers from receiving events from this stream and removes this
stream as a consumer of any source stream.

This function calls end() on the stream and unlinks it from any piped-to streams.

 Source

 Link

Stream.end()

Ends a Stream. This is the same as sending a nil value as data.
You shouldn't need to call this directly, rather it will be called by
any Node Readable Streams
you pipe in.

Only call this function on streams that were constructed with no source
(i.e., with _()).

mystream.end();

 Source

 Link

Stream.pause()

Pauses the stream. All Highland Streams start in the paused state.

It is unlikely that you will need to manually call this method.

var xs = _(generator);
xs.pause();

 Source

 Link

Stream.resume()

Resumes a paused Stream. This will either read from the Stream's incoming
buffer or request more data from an upstream source. Never call this method
on a stream that has been consumed (via a call to consume or any
other transform).

var xs = _(generator);
xs.resume();

 Source

 Link

Stream.write(x)

Writes a value to the Stream. If the Stream is paused it will go into the
Stream's incoming buffer, otherwise it will be immediately processed and
sent to the Stream's consumers (if any). Returns false if the Stream is
paused, true otherwise. This lets Node's pipe method handle back-pressure.

You shouldn't need to call this yourself, but it may be called by Node
functions which treat Highland Streams as a Node Writable Stream.

Only call this function on streams that were constructed with no source
(i.e., with _()).

Parameters

                  x

                   - the value to write to the Stream

var xs = _();
xs.write(1);
xs.write(2);
xs.end();

xs.toArray(function (ys) {
    // ys will be [1, 2]
});

// Do *not* do this.
var xs2 = _().toArray(_.log);
xs2.write(1); // This call is illegal.

Transforms

 Source

 Link

Stream.append(y)

Adds a value to the end of a Stream.

Parameters

                  y

                   - the value to append to the Stream

_([1, 2, 3]).append(4)  // => 1, 2, 3, 4

 Source

 Link

Stream.batch(n)

Takes one Stream and batches incoming data into arrays of given length

Parameters

                  n
                   - Number
                   - length of the array to batch

_([1, 2, 3, 4, 5]).batch(2)  // => [1, 2], [3, 4], [5]

 Source

 Link

Stream.batchWithTimeOrCount(ms, n)

Takes one Stream and batches incoming data within a maximum time frame
into arrays of a maximum length.

Parameters

                  ms
                   - Number
                   - the maximum milliseconds to buffer a batch

                  n
                   - Number
                   - the maximum length of the array to batch

_(function (push) {
    push(1);
    push(2);
    push(3);
    setTimeout(push, 20, 4);
}).batchWithTimeOrCount(10, 2)

// => [1, 2], [3], [4]

 Source

 Link

Stream.collect()

Groups all values into an Array and passes down the stream as a single
data event. This is a bit like doing toArray, but instead
of accepting a callback and consuming the stream, it passes the value on.

_(['foo', 'bar']).collect().toArray(function (xs) {
    // xs will be [['foo', 'bar']]
});

 Source

 Link

Stream.compact()

Filters a Stream to drop all non-truthy values.

var compacted = _([0, 1, false, 3, null, undefined, 6]).compact();
// => 1, 3, 6

 Source

 Link

Stream.consume(f)

Consumes values from a Stream (once resumed) and returns a new Stream for
you to optionally push values onto using the provided push / next functions.

This function forms the basis of many higher-level Stream operations.
It will not cause a paused stream to immediately resume, but behaves more
like a 'through' stream, handling values as they are read.

Parameters

                  f
                   - Function
                   - the function to handle errors and values

var filter = function (f, source) {
    return source.consume(function (err, x, push, next) {
        if (err) {
            // pass errors along the stream and consume next value
            push(err);
            next();
        }
        else if (x === _.nil) {
            // pass nil (end event) along the stream
            push(null, x);
        }
        else {
            // pass on the value only if the value passes the predicate
            if (f(x)) {
                push(null, x);
            }
            next();
        }
    });
};

 Source

 Link

Stream.debounce(ms)

Holds off pushing data events downstream until there has been no more
data for ms milliseconds. Sends the last value that occurred before
the delay, discarding all other values.

Parameters

                  ms
                   - Number
                   - the milliseconds to wait before sending data

// sends last keyup event after user has stopped typing for 1 second
$('keyup', textbox).debounce(1000);

 Source

 Link

Stream.doto(f)

Creates a new Stream which applies a function to each value from the source
and re-emits the source value. Useful when you want to mutate the value or
perform side effects

Parameters

                  f
                   - Function
                   - the function to apply

var appended = _([[1], [2], [3], [4]]).doto(function (x) {
    x.push(1);
});

_([1, 2, 3]).doto(console.log)
// 1
// 2
// 3
// => 1, 2, 3

 Source

 Link

Stream.drop(n)

Acts as the inverse of take(n) - instead of returning the first n values, it ignores the
first n values and then emits the rest. n must be of type Number, if not the whole stream will
be returned. All errors (even ones emitted before the nth value) will be emitted.

Parameters

                  n
                   - Number
                   - integer representing number of values to read from source

_([1, 2, 3, 4]).drop(2) // => 3, 4

 Source

 Link

Stream.errors(f)

Extracts errors from a Stream and applies them to an error handler
function. Returns a new Stream with the errors removed (unless the error
handler chooses to rethrow them using push). Errors can also be
transformed and put back onto the Stream as values.

Parameters

                  f
                   - Function
                   - the function to pass all errors to

getDocument.errors(function (err, push) {
    if (err.statusCode === 404) {
        // not found, return empty doc
        push(null, {});
    }
    else {
        // otherwise, re-throw the error
        push(err);
    }
});

 Source

 Link

Stream.filter(f)

Creates a new Stream that includes only the values that pass a truth test.

Parameters

                  f
                   - Function
                   - the truth test function

var evens = _([1, 2, 3, 4]).filter(function (x) {
    return x % 2 === 0;
});

 Source

 Link

Stream.find(f)

A convenient form of filter, which returns the first object from a
Stream that passes the provided truth test.

Parameters

                  f
                   - Function
                   - the truth test function which returns a Stream

var docs = [
    {type: 'blogpost', title: 'foo'},
    {type: 'blogpost', title: 'bar'},
    {type: 'comment', title: 'foo'}
];

var f = function (x) {
    return x.type == 'blogpost';
};

_(docs).find(f);
// => {type: 'blogpost', title: 'foo'}

// example with partial application
var firstBlogpost = _.find(f);

firstBlogpost(docs)
// => {type: 'blogpost', title: 'foo'}

 Source

 Link

Stream.findWhere(props)

A convenient form of where, which returns the first object from a
Stream that matches a set of property values. findWhere is to where as find is to filter.

Parameters

                  props
                   - Object
                   - the properties to match against

var docs = [
    {type: 'blogpost', title: 'foo'},
    {type: 'blogpost', title: 'bar'},
    {type: 'comment', title: 'foo'}
];

_(docs).findWhere({type: 'blogpost'})
// => {type: 'blogpost', title: 'foo'}

// example with partial application
var firstBlogpost = _.findWhere({type: 'blogpost'});

firstBlogpost(docs)
// => {type: 'blogpost', title: 'foo'}

 Source

 Link

Stream.group(f)

A convenient form of reduce, which groups items based on a function or property name

Parameters

                  f
                   - Function | String
                   - the function or property name on which to group, toString() is called on the result of a function.

var docs = [
    {type: 'blogpost', title: 'foo'},
    {type: 'blogpost', title: 'bar'},
    {type: 'comment', title: 'foo'}
];

var f = function (x) {
    return x.type;
};

_(docs).group(f); OR _(docs).group('type');
// => {
// =>    'blogpost': [{type: 'blogpost', title: 'foo'}, {type: 'blogpost', title: 'bar'}]
// =>    'comment': [{type: 'comment', title: 'foo'}]
// =>  }

 Source

 Link

Stream.head()

Creates a new Stream with only the first value from the source.

_([1, 2, 3, 4]).head() // => 1

 Source

 Link

Stream.intersperse(sep)

Creates a new Stream with the separator interspersed between the elements of the source.

intersperse is effectively the inverse of splitBy.

Parameters

                  sep
                   - String
                   - the value to intersperse between the source elements

_(['ba', 'a', 'a']).intersperse('n')  // => ba, n, a, n, a
_(['mississippi']).splitBy('ss').intersperse('ss')  // => mi, ss, i, ss, ippi
_(['foo']).intersperse('bar')  // => foo

 Source

 Link

Stream.invoke(method, args)

Calls a named method on each object from the Stream - returning
a new stream with the result of those calls.

Parameters

                  method
                   - String
                   - the method name to call

                  args
                   - Array
                   - the arguments to call the method with

_(['foo', 'bar']).invoke('toUpperCase', [])  // => FOO, BAR

var readFile = _.wrapCallback(fs.readFile);
filenames.flatMap(readFile).invoke('toString', ['utf8']);

 Source

 Link

Stream.last()

Drops all values from the Stream apart from the last one (if any).

_([1, 2, 3, 4]).last()  // => 4

 Source

 Link

Stream.latest()

Creates a new Stream, which when read from, only returns the last
seen value from the source. The source stream does not experience
back-pressure. Useful if you're using a Stream to model a changing
property which you need to query periodically.

// slowThing will always get the last known mouse position
// when it asks for more data from the mousePosition stream
mousePosition.latest().map(slowThing)

 Source

 Link

Stream.map(f)

Creates a new Stream of transformed values by applying a function to each
value from the source. The transformation function can be replaced with
a non-function value for convenience, and it will emit that value
for every data event on the source Stream.

Deprecation warning: The use of the convenience non-function argument for
map is deprecated and will be removed in the next major version.

Parameters

                  f
                   - Function
                   - the transformation function or value to map to

var doubled = _([1, 2, 3, 4]).map(function (x) {
    return x * 2;
});

 Source

 Link

Stream.nfcall(args)

Takes a Stream of callback-accepting node-style functions,
wraps each one into a stream-returning function,
calls them with the arguments provided, and returns the results
as a Stream.

This can be used as a control flow shortcut and draws parallels
with some control flow functions from async.
A few rough correspondences include:

.nfcall([]).series() to async.series()

.nfcall([]).parallel(n) to async.parallelLimit(n)

.nfcall(args) to async.applyEach(..., args)

.nfcall(args).series() to async.applyEachSeries(..., args)

Parameters

                  args
                   - Array
                   - the arguments to call each function with

_([
  function (callback) {
    setTimeout(function () {
      callback(null, 'one');
    }, 200);
  },
  function (callback) {
    setTimeout(function () {
      callback(null, 'two');
    }, 100);
  }
]).nfcall([]).parallel(2).toArray(function (xs) {
  // xs is ['one', 'two'] even though second function had a shorter timeout
});

_([enableSearch, updateSchema]).nfcall(['bucket']).toArray(callback);
// does roughly the same as
async.applyEach([enableSearch, updateSchema], 'bucket', callback);

_([
  fs.appendFile,
  fs.appendFile
]).nfcall(['example.txt', 'hello']).series().toArray(function() {
  // example.txt now contains 'hellohello'
});

 Source

 Link

Stream.pick(properties)

Retrieves copies of all elements in the collection,
with only the whitelisted keys. If one of the whitelisted
keys does not exist, it will be ignored.

Parameters

                  properties
                   - Array
                   - property names to white filter

var dogs = [
     {breed: 'chihuahua', name: 'Princess', age: 5},
     {breed: 'labrador', name: 'Rocky', age: 3},
     {breed: 'german-shepherd', name: 'Waffles', age: 9}
];

_(dogs).pick(['breed', 'age']).toArray(function (xs) {
      // xs is now:
      [
          {breed: 'chihuahua', age: 5},
          {breed: 'labrador', age: 3},
          {breed: 'german-shepherd', age: 9}
      ]
});

_(dogs).pick(['owner']).toArray(function (xs) {
     // xs is now:
     [
         {},
         {},
         {}
     ]
});

 Source

 Link

Stream.pickBy(f)

Retrieves copies of all the elements in the collection
that satisfy a given predicate. Note: When using ES3,
only enumerable elements are selected. Both enumerable
and non-enumerable elements are selected when using ES5.

Parameters

                  f
                   - Function
                   - the predicate function

 var dogs = [
     {breed: 'chihuahua', name: 'Princess', age: 5},
     {breed: 'labrador', name: 'Rocky', age: 3},
     {breed: 'german-shepherd', name: 'Waffles', age: 9}
 ];

 _(dogs).pickBy(function (key, value) {
     return value > 4;
 }).toArray(function (xs) {
   // xs is now:
   [
     { age: 5 },
     {},
     { age: 9 }
   ]
 });

 Source

 Link

Stream.pluck(property)

Retrieves values associated with a given property from all elements in
the collection.

Parameters

                  prop
                   - String
                   - the property to which values should be associated

var docs = [
    {type: 'blogpost', title: 'foo'},
    {type: 'blogpost', title: 'bar'},
    {type: 'comment', title: 'baz'}
];

_(docs).pluck('title').toArray(function (xs) {
   // xs is now ['foo', 'bar', 'baz']
});

 Source

 Link

Stream.ratelimit(num, ms)

Limits number of values through the stream to a maximum of number of values
per window. Errors are not limited but allowed to pass through as soon as
they are read from the source.

Parameters

                  num
                   - Number
                   - the number of operations to perform per window

                  ms
                   - Number
                   - the window of time to limit the operations in (in ms)

_([1, 2, 3, 4, 5]).ratelimit(2, 100);

// after 0ms => 1, 2
// after 100ms => 1, 2, 3, 4
// after 200ms => 1, 2, 3, 4, 5

 Source

 Link

Stream.reduce(memo, iterator)

Boils down a Stream to a single value. The memo is the initial state
of the reduction, and each successive step of it should be returned by
the iterator function. The iterator is passed two arguments:
the memo and the next value.

If the iterator throws an error, the reduction stops and the resulting
stream will emit that error instead of a value.

Note: The order of the memo and iterator arguments will be flipped in
the next major version release.

Parameters

                  memo

                   - the initial state of the reduction

                  iterator
                   - Function
                   - the function which reduces the values

var add = function (a, b) {
    return a + b;
};

_([1, 2, 3, 4]).reduce(0, add)  // => 10

 Source

 Link

Stream.reduce1(iterator)

Same as reduce, but uses the first element as the initial
state instead of passing in a memo value.

Parameters

                  iterator
                   - Function
                   - the function which reduces the values

_([1, 2, 3, 4]).reduce1(add)  // => 10

 Source

 Link

Stream.reject(f)

The inverse of filter.

Parameters

                  f
                   - Function
                   - the truth test function

var odds = _([1, 2, 3, 4]).reject(function (x) {
    return x % 2 === 0;
});

 Source

 Link

Stream.scan(memo, iterator)

Like reduce, but emits each intermediate value of the
reduction as it is calculated.

If the iterator throws an error, the scan will stop and the stream will
emit that error. Any intermediate values that were produced before the
error will still be emitted.

Note: The order of the memo and iterator arguments will be flipped in
the next major version release.

Parameters

                  memo

                   - the initial state of the reduction

                  iterator
                   - Function
                   - the function which reduces the values

_([1, 2, 3, 4]).scan(0, add)  // => 0, 1, 3, 6, 10

 Source

 Link

Stream.scan1(iterator)

Same as scan, but uses the first element as the initial
state instead of passing in a memo value.

Parameters

                  iterator
                   - Function
                   - the function which reduces the values

_([1, 2, 3, 4]).scan1(add)  // => 1, 3, 6, 10

 Source

 Link

Stream.slice(start, end)

Creates a new Stream with the values from the source in the range of start (inclusive) to end (exclusive).
start and end must be of type Number, if start is not a Number it will default to 0
and, likewise, end will default to Infinity: this could result in the whole stream being be
returned.

Parameters

                  start
                   - Number
                   - integer representing index to start reading from source (inclusive)

                  stop
                   - Number
                   - integer representing index to stop reading from source (exclusive)

_([1, 2, 3, 4]).slice(1, 3) // => 2, 3

 Source

 Link

Stream.sort()

Collects all values together then emits each value individually but in sorted order.
The method for sorting the elements is ascending lexical.

var sorted = _(['b', 'z', 'g', 'r']).sort().toArray(_.log);
// => ['b', 'g', 'r', 'z']

 Source

 Link

Stream.sortBy(f)

Collects all values together then emits each value individually in sorted
order. The method for sorting the elements is defined by the comparator
function supplied as a parameter.

The comparison function takes two arguments a and b and should return

a negative number if a should sort before b.

a positive number if a should sort after b.

zero if a and b may sort in any order (i.e., they are equal).

This function must also define a partial
order. If it does not,
the resulting ordering is undefined.

Parameters

                  f
                   - Function
                   - the comparison function

var sorts = _([3, 1, 4, 2]).sortBy(function (a, b) {
    return b - a;
}).toArray(_.log);

//=> [4, 3, 2, 1]

 Source

 Link

Stream.split()

splitBy over newlines.

_(['a\n', 'b\nc\n', 'd', '\ne']).split()  // => a, b, c, d, e
_(['a\r\nb\nc']]).split()  // => a, b, c

 Source

 Link

Stream.splitBy(sep)

Splits the source Stream by a separator and emits the pieces in between, much like splitting a string.

splitBy is effectively the inverse of intersperse.

Parameters

                  sep
                   - String | RegExp
                   - the separator to split on

_(['mis', 'si', 's', 'sippi']).splitBy('ss')  // => mi, i, ippi
_(['ba', 'a', 'a']).intersperse('n').splitBy('n')  // => ba, a, a
_(['foo']).splitBy('bar')  // => foo

 Source

 Link

Stream.stopOnError(f)

Like the errors method, but emits a Stream end marker after
an Error is encountered.

Parameters

                  f
                   - Function
                   - the function to handle an error

brokenStream.stopOnError(function (err) {
    //console.error('Something broke: ' + err);
});

 Source

 Link

Stream.take(n)

Creates a new Stream with the first n values from the source. n must be of type Number,
if not the whole stream will be returned.

Parameters

                  n
                   - Number
                   - integer representing number of values to read from source

_([1, 2, 3, 4]).take(2) // => 1, 2

 Source

 Link

Stream.tap(f)

An alias for the doto method.

Parameters

                  f
                   - Function
                   - the function to apply

_([1, 2, 3]).tap(console.log)

 Source

 Link

Stream.throttle(ms)

Ensures that only one data event is push downstream (or into the buffer)
every ms milliseconds, any other values are dropped.

Parameters

                  ms
                   - Number
                   - the minimum milliseconds between each value

_('mousemove', document).throttle(1000);

 Source

 Link

Stream.transduce(xf)

Applies the transformation defined by the the given transducer to the
stream. A transducer is any function that follows the
Transducer Protocol.
See
transduce-js
for more details on what transducers actually are.

The result object that is passed in through the
Transformer Protocol
will be the push function provided by the consume transform.

Like scan, if the transducer throws an exception, the transform
will stop and emit that error. Any intermediate values that were produced
before the error will still be emitted.

Parameters

                  xf
                   - Function
                   - The transducer.

var xf = require('transducer-js').map(_.add(1));
_([1, 2, 3, 4]).transduce(xf);
// => [2, 3, 4, 5]

 Source

 Link

Stream.uniq()

Filters out all duplicate values from the stream and keeps only the first
occurence of each value, using === to define equality.

Like uniqBy, this transform needs to store a buffer containing
all unique values that has been encountered. Be careful about using this
transform on a stream that has many unique values.

var colors = [ 'blue', 'red', 'red', 'yellow', 'blue', 'red' ]

_(colors).uniq()
// => 'blue'
// => 'red'
// => 'yellow'

 Source

 Link

Stream.uniqBy(compare)

Filters out all duplicate values from the stream and keeps only the first
occurence of each value, using the provided function to define equality.

Note:

Memory: In order to guarantee that each unique item is chosen only once,
we need to keep an internal buffer of all unique values. This may outgrow
the available memory if you are not cautious about the size of your stream
and the number of unique objects you may receive on it.

Errors: The comparison function should never throw an error. However, if
it does, this transform will emit an error for each all that throws. This
means that one value may turn into multiple errors.

Parameters

                  compare
                   - Function
                   - custom equality predicate

var colors = [ 'blue', 'red', 'red', 'yellow', 'blue', 'red' ]

_(colors).uniqBy(function(a, b) { return a[1] === b[1]; })
// => 'blue'
// => 'red'

 Source

 Link

Stream.where(props)

A convenient form of filter, which returns all objects from a Stream
which match a set of property values.

Parameters

                  props
                   - Object
                   - the properties to match against

var docs = [
    {type: 'blogpost', title: 'foo'},
    {type: 'blogpost', title: 'bar'},
    {type: 'comment', title: 'foo'}
];

_(docs).where({title: 'foo'})
// => {type: 'blogpost', title: 'foo'}
// => {type: 'comment', title: 'foo'}

// example with partial application
var getBlogposts = _.where({type: 'blogpost'});

getBlogposts(docs)
// => {type: 'blogpost', title: 'foo'}
// => {type: 'blogpost', title: 'bar'}

Higher-order Streams

 Source

 Link

Stream.concat(ys)

Concatenates a Stream to the end of this Stream.

Be aware that in the top-level export, the args may be in the reverse
order to what you'd expect _([a], [b]) => b, a, as this follows the
convention of other top-level exported functions which do x to y.

Parameters

                  ys
                   - Stream | Array
                   - the values to concatenate onto this Stream

_([1, 2]).concat([3, 4])  // => 1, 2, 3, 4
_.concat([3, 4], [1, 2])  // => 1, 2, 3, 4

 Source

 Link

Stream.flatFilter(f)

Filters using a predicate which returns a Stream. If you need to check
against an asynchronous data source when filtering a Stream, this can
be convenient. The Stream returned from the filter function should have
a Boolean as its first value (all other values on the Stream will be
disregarded).

Parameters

                  f
                   - Function
                   - the truth test function which returns a Stream

var checkExists = _.wrapCallback(fs.access);

filenames.flatFilter(checkExists)

 Source

 Link

Stream.flatMap(f)

Creates a new Stream of values by applying each item in a Stream to an
iterator function which must return a (possibly empty) Stream. Each item on
these result Streams are then emitted on a single output Stream.

This transform is functionally equivalent to .map(f).sequence().

Parameters

                  f
                   - Function
                   - the iterator function

var readFile = _.wrapCallback(fs.readFile);
filenames.flatMap(readFile)

 Source

 Link

Stream.flatten()

Recursively reads values from a Stream which may contain nested Streams
or Arrays. As values or errors are encountered, they are emitted on a
single output Stream.

_([1, [2, 3], [[4]]]).flatten();  // => 1, 2, 3, 4

var nums = _(
    _([1, 2, 3]),
    _([4, _([5, 6]) ])
);

nums.flatten();  // => 1, 2, 3, 4, 5, 6

 Source

 Link

Stream.fork()

Forks a stream, allowing you to add additional consumers with shared
back-pressure. A stream forked to multiple consumers will only pull values
from its source as fast as the slowest consumer can handle them.

Deprecation warning: It is currently possible to fork a stream after
consuming it (e.g., via a transform). This will
no longer be possible in the next major release. If you are going to fork
a stream, always call fork on it.

var xs = _([1, 2, 3, 4]);
var ys = xs.fork();
var zs = xs.fork();

// no values will be pulled from xs until zs also resume
ys.resume();

// now both ys and zs will get values from xs
zs.resume();

 Source

 Link

Stream.merge()

Takes a Stream of Streams and merges their values and errors into a
single new Stream. The merged stream ends when all source streams have
ended.

Note that no guarantee is made with respect to the order in which
values for each stream end up in the merged stream. Values in the
merged stream will, however, respect the order they were emitted from
their respective streams.

var readFile = _.wrapCallback(fs.readFile);

var txt = _(['foo.txt', 'bar.txt']).map(readFile)
var md = _(['baz.md']).map(readFile)

_([txt, md]).merge();
// => contents of foo.txt, bar.txt and baz.txt in the order they were read

 Source

 Link

Stream.mergeWithLimit(n)

Takes a Stream of Streams and merges their values and errors into a
single new Stream, limitting the number of unpaused streams that can
running at any one time.

Note that no guarantee is made with respect to the order in which
values for each stream end up in the merged stream. Values in the
merged stream will, however, respect the order they were emitted from
their respective streams.

Parameters

                  n
                   - Number
                   - the maximum number of streams to run in parallel

var readFile = _.wrapCallback(fs.readFile);

var txt = _(['foo.txt', 'bar.txt']).flatMap(readFile)
var md = _(['baz.md']).flatMap(readFile)
var js = _(['bosh.js']).flatMap(readFile)

_([txt, md, js]).mergeWithLimit(2);
// => contents of foo.txt, bar.txt, baz.txt and bosh.js in the order
// they were read, but bosh.js is not read until either foo.txt and bar.txt
// has completely been read or baz.md has been read

 Source

 Link

Stream.observe()

Observes a stream, allowing you to handle values as they are emitted, without
adding back-pressure or causing data to be pulled from the source. This can
be useful when you are performing two related queries on a stream where one
would block the other. Just be aware that a slow observer could fill up its
buffer and cause memory issues. Where possible, you should use fork.

var xs = _([1, 2, 3, 4]);
var ys = xs.fork();
var zs = xs.observe();

// now both zs and ys will receive data as fast as ys can handle it
ys.resume();

 Source

 Link

Stream.otherwise(ys)

Switches source to an alternate Stream if the current Stream is empty.

Parameters

                  ys
                   - Stream | Function
                   - alternate stream (or stream-returning function) to use if this stream is empty

_([1,2,3]).otherwise(['foo'])  // => 1, 2, 3
_([]).otherwise(['foo'])       // => 'foo'

_.otherwise(_(['foo']), _([1,2,3]))    // => 1, 2, 3
_.otherwise(_(['foo']), _([]))         // => 'foo'

 Source

 Link

Stream.parallel(n)

Takes a Stream of Streams and reads from them in parallel, buffering
the results until they can be returned to the consumer in their original
order.

Parameters

                  n
                   - Number
                   - the maximum number of concurrent reads/buffers

var readFile = _.wrapCallback(fs.readFile);
var filenames = _(['foo.txt', 'bar.txt', 'baz.txt']);

// read from up to 10 files at once
filenames.map(readFile).parallel(10);

 Source

 Link

_.pipeline(...)

Creates a 'Through Stream', which passes data through a pipeline
of functions or other through Streams. This is particularly useful
when combined with partial application of Highland functions to expose a
Node-compatible Through Stream.

This is not a method on a Stream, and it only exposed at the top-level
as _.pipeline. It takes an arbitrary number of arguments.

var through = _.pipeline(
    _.map(parseJSON),
    _.filter(isBlogpost),
    _.reduce(collectCategories)
    _.through(otherPipeline)
);

readStream.pipe(through).pipe(outStream);

// Alternatively, you can use pipeline to manipulate a stream in
// the chained method call style:

var through2 = _.pipeline(function (s) {
    return s.map(parseJSON).filter(isBlogpost); // etc.
});

 Source

 Link

Stream.sequence()

Reads values from a Stream of Streams or Arrays, emitting them on a single
output Stream. This can be thought of as a flatten, just one
level deep, often used for resolving asynchronous actions such as a HTTP
request or reading a file.

var nums = _([
    _([1, 2, 3]),
    _([4, 5, 6])
]);

nums.sequence()  // => 1, 2, 3, 4, 5, 6

// using sequence to read from files in series
var readFile = _.wrapCallback(fs.readFile);
filenames.map(readFile).sequence()

 Source

 Link

Stream.series()

An alias for the sequence method.

var readFile = _.wrapCallback(fs.readFile);
filenames.map(readFile).series()

 Source

 Link

Stream.through(target)

Transforms a stream using an arbitrary target transform.

If target is a function, this transform passes the current Stream to it,
returning the result.

If target is a Duplex
Stream,
this transform pipes the current Stream through it. It will always return a
Highland Stream (instead of the piped to target directly as in
pipe). Any errors emitted will be propagated as Highland errors.

Parameters

                  target
                   - Function | Duplex Stream
                   - the stream to pipe through or a function to call.

function oddDoubler(s) {
    return s.filter(function (x) {
        return x % 2; // odd numbers only
    })
    .map(function (x) {
        return x * 2;
    });
}

_([1, 2, 3, 4]).through(oddDoubler).toArray(function (xs) {
    // xs will be [2, 6]
});

// Can also be used with Node Through Streams
_(filenames).through(jsonParser).map(function (obj) {
    // ...
});

// All errors will be propagated as Highland errors
_(['zz{"a": 1}']).through(jsonParser).errors(function (err) {
  console.log(err); // => SyntaxError: Unexpected token z
});

 Source

 Link

Stream.zip(ys)

Takes two Streams and returns a Stream of corresponding pairs. The size of
the resulting stream is the smaller of the two source streams.

Parameters

                  ys
                   - Array | Stream
                   - the other stream to combine values with

_(['a', 'b', 'c']).zip([1, 2, 3])  // => ['a', 1], ['b', 2], ['c', 3]

_(['a', 'b', 'c']).zip(_([1]))  // => ['a', 1]

 Source

 Link

Stream.zipAll(ys)

Takes a stream and a finite stream of N streams
and returns a stream of the corresponding (N+1)-tuples.

Note: This transform will be renamed zipEach in the next major version
release.

Parameters

                  ys
                   - Array | Stream
                   - the array of streams to combine values with

_([1,2,3]).zipAll([[4, 5, 6], [7, 8, 9], [10, 11, 12]])
// => [ [ 1, 4, 7, 10 ], [ 2, 5, 8, 11 ], [ 3, 6, 9, 12 ] ]

// shortest stream determines length of output stream
_([1, 2, 3, 4]).zipAll([[5, 6, 7, 8], [9, 10, 11, 12], [13, 14]])
// => [ [ 1, 5, 9, 13 ], [ 2, 6, 10, 14 ] ]

 Source

 Link

Stream.zipAll0()

Takes a finite stream of streams and returns a stream where the first
element from each separate stream is combined into a single data event,
followed by the second elements of each stream and so on until the shortest
input stream is exhausted.

Note: This transform will be renamed zipAll in the next major version
release.

_([
    _([1, 2, 3]),
    _([4, 5, 6]),
    _([7, 8, 9]),
    _([10, 11, 12])
]).zipAll0()
// => [ [ 1, 4, 7, 10 ], [ 2, 5, 8, 11 ], [ 3, 6, 9, 12 ] ]

// shortest stream determines length of output stream
_([
    _([1, 2, 3, 4]),
    _([5, 6, 7, 8]),
    _([9, 10, 11, 12]),
    _([13, 14])
]).zipAll0()
// => [ [ 1, 5, 9, 13 ], [ 2, 6, 10, 14 ] ]

Consumption

 Source

 Link

Stream.apply(f)

Applies all values from a Stream as arguments to a function. This method consumes the stream.
f will always be called when the nil token is encountered, even when the stream is empty.

Parameters

                  f
                   - Function
                   - the function to apply arguments to

_([1, 2, 3]).apply(function (a, b, c) {
    // a === 1
    // b === 2
    // c === 3
});

_([1, 2, 3]).apply(function (a) {
    // arguments.length === 3
    // a === 1
});

 Source

 Link

Stream.done(f)

Calls a function once the Stream has ended. This method consumes the stream.
If the Stream has already ended, the function is called immediately.

If an error from the Stream reaches this call, it will emit an error event
(i.e., it will call emit('error') on the stream being consumed).  This
event will cause an error to be thrown if unhandled.

As a special case, it is possible to chain done after a call to
each even though both methods consume the stream.

Parameters

                  f
                   - Function
                   - the callback

var total = 0;
_([1, 2, 3, 4]).each(function (x) {
    total += x;
}).done(function () {
    // total will be 10
});

 Source

 Link

Stream.each(f)

Iterates over every value from the Stream, calling the iterator function
on each of them. This method consumes the Stream.

If an error from the Stream reaches this call, it will emit an error event
(i.e., it will call emit('error') on the stream being consumed).  This
event will cause an error to be thrown if unhandled.

While each consumes the stream, it is possible to chain done (and
only done) after it.

Parameters

                  f
                   - Function
                   - the iterator function

_([1, 2, 3, 4]).each(function (x) {
    // will be called 4 times with x being 1, 2, 3 and 4
});

 Source

 Link

Stream.pipe(dest, options)

Pipes a Highland Stream to a Node Writable Stream
(Highland Streams are also Node Writable Streams). This will pull all the
data from the source Highland Stream and write it to the destination,
automatically managing flow so that the destination is not overwhelmed
by a fast source.

Users may optionally pass an object that may contain any of these fields:

end - Ends the destination when this stream ends. Default: true. This
option has no effect if the destination is either process.stdout or
process.stderr. Those two streams are never ended.

Like Readable#pipe,
this function will throw errors if there is no error handler installed on
the stream. Use through if you are piping to another Highland
stream and want errors as well as values to be propagated.

This function returns the destination so you can chain together pipe calls.

Parameters

                  dest
                   - Writable Stream
                   - the destination to write all data to

                  options
                   - Object
                   - (optional) pipe options.

var source = _(generator);
var dest = fs.createWriteStream('myfile.txt')
source.pipe(dest);

// chained call
source.pipe(through).pipe(dest);

 Source

 Link

Stream.pull(f)

Consumes a single item from the Stream. Unlike consume, this function will
not provide a new stream for you to push values onto, and it will unsubscribe
as soon as it has a single error, value or nil from the source.

You probably won't need to use this directly, but it is used internally by
some functions in the Highland library.

Parameters

                  f
                   - Function
                   - the function to handle data

xs.pull(function (err, x) {
    // do something
});

 Source

 Link

Stream.toArray(f)

Collects all values from a Stream into an Array and calls a function with
the result. This method consumes the stream.

If an error from the Stream reaches this call, it will emit an error event
(i.e., it will call emit('error') on the stream being consumed).  This
event will cause an error to be thrown if unhandled.

Parameters

                  f
                   - Function
                   - the callback to provide the completed Array to

_([1, 2, 3, 4]).toArray(function (x) {
    // parameter x will be [1,2,3,4]
});

 Source

 Link

Stream.toCallback(cb)

Returns the result of a stream to a nodejs-style callback function.

If the stream contains a single value, it will call cb
with the single item emitted by the stream (if present).
If the stream is empty, cb will be called without any arguments.
If an error is encountered in the stream, this function will stop
consumption and call cb with the error.
If the stream contains more than one item, it will stop consumption
and call cb with an error.

Parameters

                  cb
                   - Function
                   - the callback to provide the error/result to

_([1, 2, 3, 4]).collect().toCallback(function (err, result) {
    // parameter result will be [1,2,3,4]
    // parameter err will be null
});

Utils

 Source

 Link

_.isStream(x)

Returns true if x is a Highland Stream.

Parameters

                  x

                   - the object to test

_.isStream('foo')  // => false
_.isStream(_([1,2,3]))  // => true

 Source

 Link

_.log(args..)

Logs values to the console, a simple wrapper around console.log that
it suitable for passing to other functions by reference without having to
call bind.

_.log('Hello, world!');

_([1, 2, 3, 4]).each(_.log);

 Source

 Link

_.nil

The end of stream marker. This is sent along the data channel of a Stream
to tell consumers that the Stream has ended. See the example map code for
an example of detecting the end of a Stream.

Note: nil is setup as a global where possible. This makes it convenient
to access, but more importantly lets Streams from different Highland
instances work together and detect end-of-stream properly. This is mostly
useful for NPM where you may have many different Highland versions installed.

var map = function (iter, source) {
    return source.consume(function (err, val, push, next) {
        if (err) {
            push(err);
            next();
        }
        else if (val === _.nil) {
            push(null, val);
        }
        else {
            push(null, iter(val));
            next();
        }
    });
};

 Source

 Link

_.streamifyAll(source)

Takes an object or a constructor function and returns that object or
constructor with streamified versions of its function properties.
Passed constructors will also have their prototype functions
streamified.  This is useful for wrapping many node style async
functions at once, and for preserving those functions' context.

Parameters

                  source
                   - Object | Function
                   - the function or object with node-style function properties.

var fs = _.streamifyAll(require('fs'));

fs.readFileStream('example.txt').apply(function (data) {
    // data is now the contents of example.txt
});

 Source

 Link

_.wrapCallback(f)

Wraps a node-style async function which accepts a callback, transforming
it to a function which accepts the same arguments minus the callback and
returns a Highland Stream instead. The wrapped function keeps its context,
so you can safely use it as a method without binding (see the second
example below).

wrapCallback also accepts an optional mappingHint, which specifies how
callback arguments are pushed to the stream. This can be used to handle
non-standard callback protocols that pass back more than one value.

mappingHint can be a function, number, or array. See the documentation on
EventEmitter Stream Objects for details on the mapping
hint. If mappingHint is a function, it will be called with all but the
first argument that is passed to the callback. The first is still assumed to
be the error argument.

Parameters

                  f
                   - Function
                   - the node-style function to wrap

                  mappingHint
                   - Array | Function | Number
                   - (optional) how to pass the arguments to the callback

var fs = require('fs');

var readFile = _.wrapCallback(fs.readFile);

readFile('example.txt').apply(function (data) {
    // data is now the contents of example.txt
});

function Reader(file) {
    this.file = file;
}

Reader.prototype.read = function(cb) {
    fs.readFile(this.file, cb);
};

Reader.prototype.readStream = _.wrapCallback(Reader.prototype.read);

Objects

 Source

 Link

_.extend(a, b)

Extends one object with the properties of another. Note: The
arguments are in the reverse order of other libraries such as
underscore. This is so it follows the convention of other functions in
this library and so you can more meaningfully partially apply it.

Parameters

                  a
                   - Object
                   - the properties to extend b with

                  b
                   - Object
                   - the original object to extend

_.extend({name: 'bar'}, {name: 'foo', price: 20})
// => {name: 'bar', price: 20}

// example of partial application
var publish = _.extend({published: true});

publish({title: 'test post'})
// => {title: 'test post', published: true}

 Source

 Link

_.get(prop, obj)

Returns a property from an object.

Parameters

                  prop
                   - String
                   - the property to return

                  obj
                   - Object
                   - the object to read properties from

var obj = {foo: 'bar', baz: 123};
_.get('foo', obj) // => 'bar'

// making use of partial application
var posts = [
  {title: 'one'},
  {title: 'two'},
  {title: 'three'}
];

_(posts).map(_.get('title'))  // => 'one', 'two', 'three'

 Source

 Link

_.keys(obj)

Returns keys from an Object as a Stream.

Parameters

                  obj
                   - Object
                   - the object to return keys from

_.keys({foo: 1, bar: 2, baz: 3})  // => 'foo', 'bar', 'baz'

 Source

 Link

_.pairs(obj)

Returns key/value pairs for an Object as a Stream. Reads properties
lazily, so if you don't read from all keys on an object, not
all properties will be read from (may have an effect where getters
are used).

Parameters

                  obj
                   - Object
                   - the object to return key/value pairs from

_.pairs({foo: 1, bar: 2})  // => ['foo', 1], ['bar', 2]

 Source

 Link

_.set(prop, value, obj)

Updates a property on an object, returning the updated object.

Parameters

                  prop
                   - String
                   - the property to return

                  value

                   - the value to set the property to

                  obj
                   - Object
                   - the object to set properties on

var obj = {foo: 'bar', baz: 123};
_.set('foo', 'wheeee', obj) // => {foo: 'wheeee', baz: 123}

// making use of partial application
var publish = _.set('published', true);

publish({title: 'example'})  // => {title: 'example', published: true}

 Source

 Link

_.values(obj)

Returns values from an Object as a Stream. Reads properties
lazily, so if you don't read from all keys on an object, not
all properties will be read from (may have an effect where getters
are used).

Parameters

                  obj
                   - Object
                   - the object to return values from

_.values({foo: 1, bar: 2, baz: 3})  // => 1, 2, 3

Functions

 Source

 Link

_.compose(fn1, fn2, ...)

Creates a composite function, which is the application of function1 to
the results of function2. You can pass an arbitrary number of arguments
and have them composed. This means you can't partially apply the compose
function itself.

var add1 = add(1);
var mul3 = mul(3);

var add1mul3 = compose(mul3, add1);
add1mul3(2) == 9

 Source

 Link

_.curry(fn, [*arguments])

Transforms a function with specific arity (all arguments must be
defined) in a way that it can be called as a chain of functions until
the arguments list is saturated.

This function is not itself curryable.

Parameters

                  fn
                   - Function
                   - the function to curry

                  args..

                   - any number of arguments to pre-apply to the function

fn = curry(function (a, b, c) {
    return a + b + c;
});

fn(1)(2)(3) == fn(1, 2, 3)
fn(1, 2)(3) == fn(1, 2, 3)
fn(1)(2, 3) == fn(1, 2, 3)

 Source

 Link

_.flip(fn, [x, y])

Evaluates the function fn with the argument positions swapped. Only
works with functions that accept two arguments.

Parameters

                  fn
                   - Function
                   - function to flip argument application for

                  x

                   - parameter to apply to the right hand side of f

                  y

                   - parameter to apply to the left hand side of f

div(2, 4) == 0.5
flip(div, 2, 4) == 2
flip(div)(2, 4) == 2

 Source

 Link

_.ncurry(n, fn, [args...])

Same as curry but with a specific number of arguments. This can be
useful when functions do not explicitly define all its parameters.

This function is not itself curryable.

Parameters

                  n
                   - Number
                   - the number of arguments to wait for before apply fn

                  fn
                   - Function
                   - the function to curry

                  args...

                   - any number of arguments to pre-apply to the function

fn = ncurry(3, function () {
    return Array.prototype.join.call(arguments, '.');
});

fn(1, 2, 3) == '1.2.3';
fn(1, 2)(3) == '1.2.3';
fn(1)(2)(3) == '1.2.3';

 Source

 Link

_.partial(fn, args...)

Partially applies the function (regardless of whether it has had curry
called on it). This will always postpone execution until at least the next
call of the partially applied function.

Parameters

                  fn
                   - Function
                   - function to partial apply

                  args...

                   - the arguments to apply to the function

var addAll = function () {
    var args = Array.prototype.slice.call(arguments);
    return foldl1(add, args);
};
var f = partial(addAll, 1, 2);
f(3, 4) == 10

 Source

 Link

_.seq(fn1, fn2, ...)

The reversed version of compose. Where arguments are in the
order of application.

var add1 = add(1);
var mul3 = mul(3);

var add1mul3 = seq(add1, mul3);
add1mul3(2) == 9

Operators

 Source

 Link

_.add(a, b)

Add two values. Can be partially applied.

_.add(1, 2) === 3
_.add(1)(5) === 6

 Source

 Link

_.not(x)

Perform logical negation on a value. If x is truthy then returns false,
otherwise returns true.

Parameters

                  x

                   - the value to negate

_.not(true)   // => false
_.not(false)  // => true


text:
(928) 783-8911 | ympo@ympo.org
About YMPO
YMPO Mission
Executive Director's Report
YMPO Bylaws
Executive Board Agendas & Minutes
TAC Agendas & Minutes
Media and Press Releases
YMPO Newsletter
Regional Transportation Plan 2018-2041
Regional Transportation Coordination Plan
Air Quality Conformity
Disadvantaged Business Enterprise (DBE)
YMPO/ADOT Plans
Transportation Improvement Program (TIP)
YMPO Unified Planning Work Program/Budget (UPWP/B)
ADOT/Yuma Programs
ADOT/Yuma Grant Programs
Mobility Management Program
YMPO Audit Reports
YMPO/ADOT Studies
Origin and Destination Study
Yuma County Intergovernmental Public Transportation Authority
Yuma County Rail Corridor Study
San Luis Transit Circulator Study
RFP/RFQ
YRSTSP
You are here: Maps & More | Traffic Counts
DONT WORRY, IT IS NOT A TRAP
Annual Traffic Count Program
Yuma Metropolitan Planning Organization (YMPO), regularly collects traffic counts on major roads and intersections throughout the region. In addition to being a vital input to YMPO's transportation planning and travel forecasting, traffic count information is used by:
Transportation engineers and planners throughout the region to identify existing traffic problems and solutions
The Arizona State Legislature and U.S. Congress to make decisions regarding the need for and allocation of state and federal funds
Regional, state, and federal air quality experts to monitor traffic related pollutants and conformance with air quality standards
Private sector marketing specialists as measures of accessibility and exposure
To maximize the value of this data, YMPO annually compiles and distributes all of the traffic counts collected throughout Yuma County. This data is available in a number of formats:
YMPO Traffic Data Management System (Midwestern Software Solutions, Inc.)
YMPO Traffic Count Database
YMPO collects weekday traffic count data for selected regionally significant roadway segments and signalized intersections within the Yuma metropolitan area. The traffic count data is collected by YMPO Employees, typically on a Tuesday, Wednesday, or Thursday in the Winter (Peak) and Summer (Off-Peak). Typical traffic data collection methods involve the placement of two (2) pneumatic tubes connected to recording devices at selected locations along roadway segments for a period of at least 24 continuous hours.
YMPO's goal is to collect a representative traffic count for each roadway segment. However, counting devices can and sometimes do malfunction, resulting in erroneous results. Nearby roadway construction, traffic accidents, and other unknown incidents can significantly affect traffic and result in non-typical counts. Even without specific incidents, traffic counts can vary significantly at different locations within a given segment and from day-to-day, month-to-month, and throughout the year
Average Annual Daily Traffic (AADT)
The annualized average 24-hour volume of vehicles at a given point or section of highway is called a traffic count. It is normally calculated by determining the volume of vehicles during a given period and dividing that number by the number of days in that period.
YMPO's count system collects data twice a year, peak and off-peak. The numbers that are collected for the two counts total is divided by 2 for the AADT.
Highway Performance Monitoring System (HPMS)
Another responsibility of the YMPO's Data Section is collecting data for the FHWA/ADOT HPMS Program a federal highway program, which is required of each state and U.S. territory by the Federal Highway Administration (FHWA), the HPMS is the national database of highway information. Roadway extent, use, condition, and performance data are collected by and for the states and submitted to the FHWA on an annual basis. From a national perspective, the FHWA's primary intent with this program is to provide Congress with a policy tool for major highway legislation and funding decisions.
ADOT—HPMS Program
FHWA—HPMS Program
FHWA—FAQ's
FHWA Vehicle Classifications/Types
The classification scheme is separated into categories depending on whether the vehicle carries passengers or commodities. Non-passenger vehicles are further subdivided by number of axles and number of units, including both power and trailer units. Note that the addition of a light trailer to a vehicle does not change the classification of the vehicle.
Automatic vehicle classifiers need an algorithm to interpret axle spacing information to correctly classify vehicles into these categories. The algorithm most commonly used is based on the "Scheme F" developed by Maine DOT in the mid-1980s. The FHWA does not endorse "Scheme F" or any other classification algorithm. Axle spacing characteristics for specific vehicle types are known to change from State to State. As a result, no single algorithm is best for all cases. It is up to each agency to develop, test, and refine an algorithm that meets its own needs.
FHWA VEHICLE CLASSES WITH DEFINITIONS
Motorcycles(Optional) — All two or three-wheeled motorized vehicles. Typical vehicles in this category have saddle type seats and are steered by handlebars rather than steering wheels. This category includes motorcycles, motor scooters, mopeds, motor-powered bicycles, and three-wheel motorcycles. This vehicle type may be reported at the option of the State.
Passenger Cars — All sedans, coupes, and station wagons manufactured primarily for the purpose of carrying passengers and including those passenger cars pulling recreational or other light trailers.
Other Two-Axle, Four-Tire Single Unit Vehicles — All two-axle, four-tire, vehicles, other than passenger cars. Included in this classification are pickups, panels, vans, and other vehicles such as campers, motor homes, ambulances, hearses, carryalls, and minibuses. Other two-axle, four-tire single-unit vehicles pulling recreational or other light trailers are included in this classification. Because automatic vehicle classifiers have difficulty distinguishing class 3 from class 2, these two classes may be combined into class 2.
Buses— All vehicles manufactured as traditional passenger-carrying buses with two axles and six tires or three or more axles. This category includes only traditional buses (including school buses) functioning as passenger-carrying vehicles. Modified buses should be considered to be a truck and should be appropriately classified.NOTE: In reporting information on trucks the following criteria should be used:
Truck tractor units traveling without a trailer will be considered single-unit trucks.
A truck tractor unit pulling other such units in a "saddle mount" configuration will be considered one single-unit truck and will be defined only by the axles on the pulling unit.
Vehicles are defined by the number of axles in contact with the road. Therefore, "floating" axles are counted only when in the down position.
The term "trailer" includes both semi- and full trailers.
Two-Axle, Six-Tire, Single-Unit Trucks— All vehicles on a single frame including trucks, camping and recreational vehicles, motor homes, etc., with two axles and dual rear wheels.
Three-Axle Single-Unit Trucks— All vehicles on a single frame including trucks, camping and recreational vehicles, motor homes, etc., with three axles.
Four or More Axle Single-Unit Trucks— All trucks on a single frame with four or more axles.
Four or Fewer Axle Single-Trailer Trucks— All vehicles with four or fewer axles consisting of two units, one of which is a tractor or straight truck power unit.
Five-Axle Single-Trailer Trucks— All five-axle vehicles consisting of two units, one of which is a tractor or straight truck power unit.
Six or More Axle Single-Trailer Trucks— All vehicles with six or more axles consisting of two units, one of which is a tractor or straight truck power unit.
Five or fewer Axle Multi-Trailer Trucks— All vehicles with five or fewer axles consisting of three or more units, one of which is a tractor or straight truck power unit.
Six-Axle Multi-Trailer Trucks— All six-axle vehicles consisting of three or more units, one of which is a tractor or straight truck power unit.
Seven or More Axle Multi-Trailer Trucks— All vehicles with seven or more axles consisting of three or more units, one of which is a tractor or straight truck power unit.
Traffic Count Data Files
2016 Traffic Count
Traffic Count Maps
2008 Traffic Map
© Yuma Metropolitan Planning Organization
YMPO is comprised of the City of Yuma, Yuma County, the Cocopah Indian Tribe, the Town of Wellton, and the cities of Somerton and San Luis, Winterhaven, California and the Quechan Indian Tribe, and the Arizona Department of Transportation.
YMPO RTP
YMPO RTCP
YMPO PPP
Air Quality Analysis
UPWP/B

redpajama_set_name: RedPajamaCommonCrawl


LOUISVILLE, Ky. – Bourbon industry publication, The Bourbon Review, has released its annual list of the 101 Best Bourbon Bars in America and Bourbon's hometown has eight (8) Bourbon bars named, only second to Chicago's ten (10). The Bourbon Country region as a whole tops the list with 29 of the 101 mentioned.
Other Kentucky cities featured were Lexington, Versailles, Bardstown, Elizabethtown, Owensboro, Harrodsburg, Danville, Newport, Burlington and Covington.
The criteria for evaluation included seemingly endless displays of Bourbon, extensive Bourbon cocktail options and a pride for educating their patrons on the Bourbon basics.
This list was announced on the publication's blog, www.gobourbon.com, and you can see the full list by visiting http://www.gobourbon.com/best-bourbon-bars-2018.
Be the first to comment on "LouisvilleKY dominates Bourbon Review's List of America's Best Bourbon Bars"


This article briefly reviews the production methods and characteristics of plain carbon and low-alloy water-atomized iron and steel powders, high-porosity iron powder, carbonyl iron powder, and electrolytic iron powder. It emphasizes on atomized powders, because they are the most widely used materials for ferrous powder metallurgy. The article provides information on the properties and applications of these powders. It also includes an overview of diffusion alloying, basics of admixing, and bonded premixes.


text:
Adventism is a branch of Protestant Christianity that believes in the imminent Second Coming (or the "Second Advent") of Jesus Christ. It originated in the 1830s in the United States during the Second Great Awakening when Baptist preacher William Miller first publicly shared his belief that the Second Coming would occur at some point between 1843 and 1844. His followers became known as Millerites. After Miller's prophecies failed, the Millerite movement split up and was continued by a number of groups that held different doctrines from one another. These groups, stemming from a common Millerite ancestor, became known collectively as the Adventist movement.

Although the Adventist churches hold much in common with mainline Christianity, their theologies differ on whether the intermediate state of the dead is unconscious sleep or consciousness, whether the ultimate punishment of the wicked is annihilation or eternal torment, the nature of immortality, whether the wicked are resurrected after the millennium, and whether the sanctuary of Daniel 8 refers to the one in heaven or one on earth. The movement has encouraged the examination of the whole Bible, leading Seventh-day Adventists and some smaller Adventist groups to observe the seventh day Sabbath. The General Conference of Seventh-day Adventists has compiled that church's core beliefs in the 28 Fundamental Beliefs (1980 and 2005), which use biblical references as justification.

In 2010, Adventism claimed some 22 million believers scattered in various independent churches. The largest church within the movement—the Seventh-day Adventist Church—had more than 21 million members in 2020.

History

Adventism began as an inter-denominational movement. Its most vocal leader was William Miller. Between 50,000 and 100,000 people in the United States supported Miller's predictions of Christ's return. After the "Great Disappointment" of October 22, 1844, many people in the movement gave up on Adventism. Of those remaining Adventist, the majority gave up believing in any prophetic (biblical) significance for the October 22 date, yet they remained expectant of the near Advent (second coming of Jesus).

Of those who retained the October 22 date, many maintained that Jesus had come not literally but "spiritually", and consequently were known as "spiritualizers". A small minority held that something concrete had indeed happened on October 22, but that this event had been misinterpreted. This belief later emerged and crystallized with the Seventh-day Adventist Church, the largest remaining body today.

Albany Conference (1845)
The Albany Conference in 1845, attended by 61 delegates, was called to attempt to determine the future course and meaning of the Millerite movement. Following this meeting, the "Millerites" then became known as "Adventists" or "Second Adventists". However, the delegates disagreed on several theological points.  Four groups emerged from the conference: The Evangelical Adventists, The Life and Advent Union, the Advent Christian Church, and the Seventh-day Adventist Church.

The largest group was organized as the American Millennial Association, a portion of which was later known as the Evangelical Adventist Church. Unique among the Adventists, they believed in an eternal hell and consciousness in death. They declined in numbers, and by 1916 their name did not appear in the United States Census of Religious Bodies. It has diminished to almost non-existence today. Their main publication was the Advent Herald, of which Sylvester Bliss was the editor until his death in 1863. It was later called the Messiah's Herald.

The Life and Advent Union was founded by George Storrs in 1863. He had established The Bible Examiner in 1842. It merged with the Adventist Christian Church in 1964.

The Advent Christian Church officially formed in 1861 and grew rapidly at first. It declined a little during the 20th century. The Advent Christians publish the four magazines The Advent Christian Witness, Advent Christian News, Advent Christian Missions and Maranatha. They also operate a liberal arts college at Aurora, Illinois; and a one-year Bible College in Lenox, Massachusetts, called Berkshire Institute for Christian Studies. The Primitive Advent Christian Church later separated from a few congregations in West Virginia.

The Seventh-day Adventist Church officially formed in 1863. It believes in the sanctity of the seventh-day Sabbath as a holy day for worship.  It publishes the Adventist Review, which evolved from several early church publications. Youth publications include KidsView, Guide and Insight. It has grown to a large worldwide denomination and has a significant network of medical and educational institutions.

Miller did not join any of the movements, and he spent the last few years of his life working for unity, before dying in 1849.

Denominations

The Handbook of Denominations in the United States, 12th ed., describes the following churches as "Adventist and Sabbatarian (Hebraic) Churches":

Christadelphians

The Christadelphians were founded in 1844 by John Thomas and had an estimated 25,000 members in 170 ecclesias, or churches, in 2000 in America.

Advent Christian Church

The Advent Christian Church was founded in 1860 and had 25,277 members in 302 churches in 2002 in America. It is a "first-day" body of Adventist Christians founded on the teachings of William Miller. It adopted the "conditional immortality" doctrine of Charles F. Hudson and George Storrs, who formed the "Advent Christian Association" in Salem, Massachusetts, in 1860.

Primitive Advent Christian Church

The Primitive Advent Christian Church is a small group which separated from the Advent Christian Church. It differs from the parent body mainly on two points. Its members observe foot washing as a rite of the church, and they teach that reclaimed backsliders should be baptized (even though they had formerly been baptized). This is sometimes referred to as rebaptism.

Seventh-day Adventist Church

The Seventh-day Adventist Church, founded in 1863, had over 19,500,000 baptized members (not counting children of members) worldwide as of June 2016. It is best known for its teaching that Saturday, the seventh day of the week, is the Sabbath and is the appropriate day for worship. However, the second coming of Jesus Christ along with the Judgement day based on the three angels message in Revelation 14:6–13 remain core beliefs of Seventh-day Adventists.

Seventh Day Adventist Reform Movement

The Seventh Day Adventist Reform Movement is a small offshoot with an unknown number of members from the Seventh-day Adventist Church caused by disagreement over military service on the Sabbath day during World War I.

Davidian Seventh-day Adventist Association

The Davidians (originally named Shepherd's Rod) is a small offshoot with an unknown number of members made up primarily of voluntarily disfellowshipped members of the Seventh-day Adventist Church. They were originally known as the Shepherd's Rod and are still sometimes referred to as such. The group derives its name from two books on Bible doctrine written by its founder, Victor Houteff, in 1929.

Branch Davidians
The Branch Davidians were a split ("branch") from the Davidians.

A group that gathered around David Koresh (the so-called Koreshians) abandoned Davidian teachings and turned into a religious cult. Many of them were killed during the infamous Waco Siege of April 1993.

Church of God (Seventh Day)

The Church of God (Seventh-Day) was founded in 1863 and it had an estimated 11,000 members in 185 churches in 1999 in America.  Its founding members separated in 1858 from those Adventists associated with Ellen G. White who later organized themselves as Seventh-day Adventists in 1863. The Church of God (Seventh Day) split in 1933, creating two bodies: one headquartered in Salem, West Virginia, and known as the Church of God (7th day) – Salem Conference and the other one headquartered in Denver, Colorado and known as the General Conference of the Church of God (Seventh-Day).  The Worldwide Church of God splintered from this.

Church of God General Conference
Many denominations known as "Church of God" have Adventist origins.

The Church of God General Conference was founded in 1921 and had 7,634 members in 162 churches in 2004 in America. It is a first-day Adventist Christian body which is also known as the Church of God of the Abrahamic Faith and the Church of God General Conference (Morrow, GA).

Creation Seventh-Day Adventist Church

The Creation Seventh-Day Adventist Church is a small group that broke off from the Seventh-Day Adventists in 1988, and organized itself as a church in 1991.

United Seventh-Day Brethren

The United Seventh-Day Brethren is a small Sabbatarian Adventist body.
In 1947, several individuals and two independent congregations within the Church of God Adventist movement formed the United Seventh-Day Brethren, seeking to increase fellowship and to combine their efforts in evangelism, publications, and other .

Other minor Adventist groups

 True and Free Adventists, a Soviet Union offshoot
 At least two denominations and numerous individual churches with a charismatic or Pentecostal-type bent have been influenced by or were offshoots – see charismatic Adventism generally
 Church of the Blessed Hope, a first-day Adventist church
 United Sabbath-Day Adventist Church, an African-American offshoot of the Seventh-day Adventist Church in New York City
 Celestia, a Christian communal town near Laporte in Sullivan County, Pennsylvania, founded by Millerite Peter E. Armstrong. It disintegrated before the end of the 19th century

Other relationships
Early in its development, the Bible Student movement founded by Charles Taze Russell had close connections with the Millerite movement and stalwarts of the Adventist faith, including George Storrs and Joseph Seiss. Although both Jehovah's Witnesses and the Bible Students do not identify as part of the Millerite Adventist movement (or other denominations, in general), some theologians categorize these groups and related sects as Millerite Adventist because of their teachings regarding an imminent Second Coming and their use of specific dates. The various independent Bible Student groups currently have a cumulative membership of about 20,000 worldwide. According to the Watch Tower Society, there were about 8.5 million Jehovah's Witnesses worldwide as of 2022.

See also
 Advent Christian Church
 Adventist and related churches
 List of Christian denominations#Millerites and comparable groups
 Seventh-day Adventist Church
 Other movements in Adventism
 Great Disappointment
 William Miller (preacher)
 Millennialism
 Millerites
 Second Great Awakening

General:
 Christian revival
 Christianity in the 19th century

References

Bibliography
 Butler, Jonathan. "From Millerism to Seventh-Day Adventism: Boundlessness to Consolidation", Church History, Vol. 55, 1986
 Jordan, Anne Devereaux. The Seventh-Day Adventists: A History (1988)
 Land, Gary. Adventism in America: A History (1998)
 Land, Gary. Historical Dictionary of the Seventh-Day Adventists (2005)
 Morgan, Douglas. Adventism and the American Republic: The Public Involvement of a Major Apocalyptic Movement (University of Tennessee Press, 2001)

External links

 History of the Millerite Movement, a reprint from the Seventh-day Adventist Encyclopedia 10:892–898, 1976.
 Graphical timeline of major Millerite groups from the Worldwide Church of God official website

History of the Seventh-day Adventist Church
Christian eschatology
Christian terminology

redpajama_set_name: RedPajamaWikipedia


text:
Download it from App Store
Download it from Play Store
   
Features & Tools
Easy Features
Easy Invoices
Bills & Expenses
Free Upgrades
Invoice Settings
Time & Billing
Easy CRM Module
Why Easy
For your Business type
eCommerce Vendors
Techno Hubs
Business Chain
Easy Partner Program
Try Easy for free
About Easy
Try Easy for free Play Video
We at Easy believe that Accounting can be made very easy and powerful using the latest technology at a very affordable price. Whether you are a small business, an individual or an Accountant, Easy is the ideal solution for you. Don't spend a fortune buying the expensive solutions from big industry players. We provide a one-stop solution for you. From accounting to payroll to invoicing. It's all included. No extra charges for any add-ons. We are a growing and passionate team based in central London and we want to provide affordable yet powerful and intuitive accounting solution for small businesses and accountants. We connect small businesses with right numbers anytime, anywhere.
Small businesses are at the heart of the world and they run the economy. We want to equip small businesses with great tools and information to help them grow further and for that, we work closely with our clients to make Easy a single platform for all businesses.
Founded in 2008, Easy has been growing day by day, year by year keeping simplicity and user friendliness at the heart of the design. Started in the United Kingdom and now operating in USA, Dubai, Saudi Arabia, South Africa, Singapore, Malaysia, India and Bangladesh. With more than 10,000 subscribers we are helping the businesses from both the world.
"We were using Excel spreadsheet before Easy, spending days to get the simple things done right. Easy has saved us lot of time and at the same time giving us a real-time view of our finances."
Find out how Easy
can help your business
of the Team
Ready to explore Easy and see how beautiful accounting is?
Subscribe to EASY Newsletter!
Get latest news once a month.
I am an Accountant I am a Business Owner
USA (+1) India (+91) UK (+44) Algeria (+213) Andorra (+376) Angola (+244) Anguilla (+1264) Antigua & Barbuda (+1268) Argentina (+54) Armenia (+374) Aruba (+297) Australia (+61) Austria (+43) Azerbaijan (+994) Bahamas (+1242) Bahrain (+973) Bangladesh (+880) Barbados (+1246) Belarus (+375) Belgium (+32) Belize (+501) Benin (+229) Bermuda (+1441) Bhutan (+975) Bolivia (+591) Bosnia Herzegovina (+387) Botswana (+267) Brazil (+55) Brunei (+673) Bulgaria (+359) Burkina Faso (+226) Burundi (+257) Cambodia (+855) Cameroon (+237) Canada (+1) Cape Verde Islands (+238) Cayman Islands (+1345) Central African Republic (+236) Chile (+56) China (+86) Colombia (+57) Comoros (+269) Congo (+242) Cook Islands (+682) Costa Rica (+506) Croatia (+385) Cuba (+53) Cyprus North (+90392) Cyprus South (+357) Czech Republic (+42) Denmark (+45) Djibouti (+253) Dominica (+1809) Dominican Republic (+1809) Ecuador (+593) Egypt (+20) El Salvador (+503) Equatorial Guinea (+240) Eritrea (+291) Estonia (+372) Ethiopia (+251) Falkland Islands (+500) Faroe Islands (+298) Fiji (+679) Finland (+358) France (+33) French Guiana (+594) French Polynesia (+689) Gabon (+241) Gambia (+220) Georgia (+7880) Germany (+49) Ghana (+233) Gibraltar (+350) Greece (+30) Greenland (+299) Grenada (+1473) Guadeloupe (+590) Guam (+671) Guatemala (+502) Guinea (+224) Guinea - Bissau (+245) Guyana (+592) Haiti (+509) Honduras (+504) Hong Kong (+852) Hungary (+36) Iceland (+354) Indonesia (+62) Iran (+98) Iraq (+964) Ireland (+353) Israel (+972) Italy (+39) Jamaica (+1876) Japan (+81) Jordan (+962) Kazakhstan (+7) Kenya (+254) Kiribati (+686) Korea North (+850) Korea South (+82) Kuwait (+965) Kyrgyzstan (+996) Laos (+856) Latvia (+371) Lebanon (+961) Lesotho (+266) Liberia (+231) Libya (+218) Liechtenstein (+417) Lithuania (+370) Luxembourg (+352) Macao (+853) Macedonia (+389) Madagascar (+261) Malawi (+265) Malaysia (+60) Maldives (+960) Mali (+223) Malta (+356) Marshall Islands (+692) Martinique (+596) Mauritania (+222) Mayotte (+269) Mexico (+52) Micronesia (+691) Moldova (+373) Monaco (+377) Mongolia (+976) Montserrat (+1664) Morocco (+212) Mozambique (+258) Myanmar (+95) Namibia (+264) Nauru (+674) Nepal (+977) Netherlands (+31) New Caledonia (+687) New Zealand (+64) Nicaragua (+505) Niger (+227) Nigeria (+234) Niue (+683) Norfolk Islands (+672) Northern Marianas (+670) Norway (+47) Oman (+968) Pakistan (+92) Palau (+680) Panama (+507) Papua New Guinea (+675) Paraguay (+595) Peru (+51) Philippines (+63) Poland (+48) Portugal (+351) Puerto Rico (+1787) Qatar (+974) Reunion (+262) Romania (+40) Russia (+7) Rwanda (+250) San Marino (+378) Sao Tome & Principe (+239) Saudi Arabia (+966) Senegal (+221) Serbia (+381) Seychelles (+248) Sierra Leone (+232) Singapore (+65) Slovak Republic (+421) Slovenia (+386) Solomon Islands (+677) Somalia (+252) South Africa (+27) Spain (+34) Sri Lanka (+94) St. Helena (+290) St. Kitts (+1869) St. Lucia (+1758) Sudan (+249) Suriname (+597) Swaziland (+268) Sweden (+46) Switzerland (+41) Syria (+963) Taiwan (+886) Tajikstan (+7) Thailand (+66) Togo (+228) Tonga (+676) Trinidad & Tobago (+1868) Tunisia (+216) Turkey (+90) Turkmenistan (+7) Turkmenistan (+993) Turks & Caicos Islands (+1649) Tuvalu (+688) Uganda (+256) Ukraine (+380) United Arab Emirates (+971) Uruguay (+598) Uzbekistan (+7) Vanuatu (+678) Vatican City (+379) Venezuela (+58) Vietnam (+84) Virgin Islands - British (+1284) Virgin Islands - US (+1340) Wallis & Futuna (+681) Yemen (North)(+969) Yemen (South)(+967) Zambia (+260) Zimbabwe (+263)
I am currently using Zoho QuickBooks Cleartax Tally IndiaFilings ProfitBooks Others
Where did you hear about Easy Accountax? Newspaper Facebook Linkedin Google twitter Others
I have read and I agree to the Terms of Use & Privacy Policy
Owning a business
Get your business GST ready with our GST compliant accounting software. Save money on your book keeping and get the control on your business financials right now.
Get started for free 
Special Discount for new users get
180 day free subscription
EASY Solution
Easy Help Center
Easy eBrochure
A : Suite 32, Winsor & Newton Building,
Whitefriars Avenue, Harrow,
England, HA3 5RN
A : 302, Kalapuram Complex,C G Road,
Ahmedabad, Gujarat 380009, India
Copyrights © 2021 Easy Accountax. All rights are reserved.
India Pakistan Bangladesh Dubai South Africa UK USA
Buy Now @ 50% Off For Professional


Traeger Grills BBQ Rib Rack from legendary Traeger.
Product prices and availability are accurate as of 2019-04-26 03:46:16 UTC and are subject to change. Any price and availability information displayed on http://www.amazon.com/ at the time of purchase will apply to the purchase of this product.
Pellet Grills and Accesories are presently selling the acclaimed Traeger Grills BBQ Rib Rack at a reduced price. Don't pass it by - buy the Traeger Grills BBQ Rib Rack here now!


text:
Peter, Paul & Mary
Formed 1961. Disbanded 2009
https://ichef.bbci.co.uk/images/ic/960x540/p01bqprv.jpg
https://musicbrainz.org/artist/3d621c94-2356-4532-ad52-79e0ef73e20c
Peter, Paul & Mary Biography (Wikipedia)
Peter, Paul and Mary was an American folk group formed in New York City in 1961, during the American folk music revival phenomenon. The trio was composed of tenor Peter Yarrow, baritone Noel Paul Stookey and contralto Mary Travers. The group's repertoire included songs written by Yarrow and Stookey, early songs by Bob Dylan as well as covers of other folk musicians. After the death of Travers in 2009, Yarrow and Stookey continued to perform as a duo under their individual names.
Mary Travers said she was influenced by Woody Guthrie, Pete Seeger, and the Weavers. In the documentary Peter, Paul & Mary: Carry It On — A Musical Legacy members of the Weavers discuss how Peter, Paul and Mary took over the torch of the social commentary of folk music in the 1960s.
The group was inducted into the Vocal Group Hall of Fame in 1999. Peter, Paul and Mary received the Sammy Cahn Lifetime Achievement Award from Songwriters Hall of Fame in 2006.
Peter, Paul & Mary Tracks
Wayne Bavin
Puff (The Magic Dragon)
Chris Needs
Tell It on The Mountain
Billy Maher
Nick Risby
I Dig Rock & Roll Music
If I Had A Hammer
The iTimms Playlist
500 Miles (Remastered)
Tudur Owen
San Francisco Bay Blues
Don't Think Twice It's All Right
Peter, Paul & Mary Links
The Kingston Trio
The Brothers Four
Joan Baez speaks to Mary Anne Hobbs
What's it like being the subject of arguably THE greatest break-up song?!
Judy Collins: What Is Folk?


text:
Q: Can the lower bound of a "bounty" be smaller? If bounties were smaller, like 10 or 20 points, I would be much more likely to spend.
Maybe bounties should be a whole percentage of your total points (rounded up)?   This would make questions by advanced users generally chuckier as compared to newbies.

A: Bounties were created as a way to in some way reward those who have put a lot of time and effort into the site. They are able to spend some of the good karma they earned in order to get a question answered.
Creating a sliding scale percentage option does not really make sense, because each bounty is created according to how much the user is willing to give, and as they gain more and more reputation, it is more likely that they will offer more. Creating an enforcement of the percentage is just creating extra rules for no reason. The users who already did approximately that will not notice, and the users who don't will be upset. Everyone loses.
An additional bonus for creating a bounty is that it gets the question on the featured page. There are bounty hunters who troll the feature page specifically to gain the generous extra points. If the bounties were to get smaller, then the "featured" page would be come diluted and less visited. It would be covered with tiny, inconsequential bounties which no one particularly cares about.
Furthermore, because of the rules associated with the bounty. It would mean that after seven days, an "answer" would be forced upon the question, which would be unfortunate if the answer was wrong.
Ultimately, I think we should leave the bounty rules the way they are.

A: I don't think this is necessary, it is easy enough to get a few hundred reputation, and it is meant to be significant encouragement to get an answer. I could just go to some easy VB homework question for more than 30 or 40 reputation. Why would I go after your bounty instead and do more work?

A: The purpose of bounties is to stir up a response to a question that has receive little or no sufficient response. Offering 100, 200, etc bounty points will bring in the answers. Users already provide answers knowing that they'll be awarded 10 or 20 points (1 or 2 upvotes) if their answer is good. I don't think giving micro-bounties will really give any different response than no micro-bounty at all.
If you want to offer a good bounty, I would go out "grinding" for rep by answering questions in your field of experience. You can accrue 100 or 200 rep in a short amount of time rather easily if you're in your comfort-zone (subject-wise). Then return to your question, and post a hefty reward.

A: A good question will get more then enough up votes to cover the cost of the bounty.  I just got a 200% return on the investment I made in the bounty for a question as more people looked at the question and up-voted it.

redpajama_set_name: RedPajamaStackExchange