Creates a closed ProAct.Stream.

Creates a ProAct.Stream, which emits the result of an action that uses a callback to notify that it is finished.

This can be used to create streams from http requests for example.

Example:

 var stream = ProAct.fromCallback(action);
 stream.on(function (v) {
   console.log(v);
 });

Creates a ProAct.Stream with source an evet emitter or dispatcher, it can be used with jQuery for example for example.

Example:

 var stream = ProAct.fromEventDispatcher($('.some-input'), 'keydown');
 stream.on(function (e) {
   console.log(e.which);
 });

The fromInvoke creates a ProAct.Stream, which emits the result of the passed func argument on every interval milliseconds.

If func returns closed the stream is closed.

Example:

   var stream = ProAct.fromInvoke(1000, function () {
     return 5;
   });
   stream.on(function (v) {
     console.log(v);
   });

   // After 1s we'll see '5' in the log, after 2s we'll see a second '5' in the log and so on...

Creates a ProAct.Stream, which emits the passed "value" over and over again at given time interval.

Example:

   var stream = ProAct.interval(1000, 7);
   stream.on(function (v) {
     console.log(v);
   });

  // This will print one number on every 1s and the numbers will be 7,7,7,7,7....

Creates a ProAct.Stream, which emits values of the passed vals array on the passed interval.

When every value is emitted through the stream they are emitted again and again and so on...

Example:

   var stream = ProAct.repeat(1000, [4, 5]);
   stream.on(function (v) {
     console.log(v);
   });

  // This will print one number on every 1s and the numbers will be 4 5 4 5 4 5 4 5 4 5 .. and so on

Checks if the passed value is a valid ProAct.js object or not. ProAct.js object have a special __pro__ object that is hidden in them, which should be instance of ProAct.Core.

No-action or emtpy function. Represent an action that does nothing.

The ProAct.prob method is the entry point for creating reactive values in ProAct.js

TODO More docs

The ProAct.proxy creates proxies or decorators to ProAct.js objects.

The decorators extend the target and can add new properties which depend on the extended ones.

Creates a ProAct.Stream, which emits values of the passed vals array on the passed interval milliseconds.

When every value is emitted through the stream it is closed.

Example:

   var stream = ProAct.seq(1000, [4, 5]);
   stream.on(function (v) {
     console.log(v);
   });

  // This will print one number on every 1s and the numbers will be 4 5 and the stream will be closed.

Creates a ProAct.Stream instance.

This method is capable of creating various source streams.

For example if the method is called like that:

 var stream = ProAct.stream();

A sourceless stream will be created, but it will be possible to invoke trigger* on it:

 stream.trigger(val);
 stream.triggerErr(new Error());
 stream.triggerClose();

The method can be called with a subscribe function too:

 var stream = ProAct.stream(function (source) {
   // ... logic using the source - the source is a stream, that has trigger/triggerErr/triggerClose
   $('.sel').on('click.myClick', function (e) {
     source.trigger(e);
   });

   return function () {
     // unsubscribing logic
     $('.sel').off('click.myClick');
   };
 });

So subscribe/unsubscribe to an even source can be programmed using this method.

The first argument can be a string too and if that's the case, ProAct.Stream's fromString method will be used for the stream construction.

Creates a ProAct.Stream, which emits the passed "value" once and then closes.

Example:

   var stream = ProAct.timeout(1000, 7);
   stream.on(function (v) {
     console.log(v);
   });

  // This will print '7' after 1s and will close.