This document discusses using protocols and lazy sequences in Node. It introduces JavaScript concepts like lists and collections. It describes how lazy sequences only evaluate data when needed. Protocols provide an interface for checking sequence types and implementing methods like first, rest, and cons. Async sequences in Node can be represented with streams and promises to handle asynchronous code. Overall protocols allow mixing synchronous and asynchronous sequences and could enable new abstractions.

1. To Infinity & Beyond!
Protocols & Lazy Sequences in Node
Part 1
Bahul Neel Upadhyaya (@bahulneel)
BraveNewTalent
http://github.com/bahulneel
http://www.bravenewtalent.com

2. JavaScript
● Imperative
● Dynamic
● OOP
– Prototypes
– Constructors
● Functional
– First Class Functions Brendan Eich
– Closures

3. List Comprehension
● Loops
– for (init; while; step)
● Stack & Queue
– push/pop/shift/unshift
● Iterators
– forEach, etc
● Map/Reduce
No standard way of doing these

4. Collections
How do I know if collection x works with my function?
● Extends Array?
● Implements Array?
● Impements some iterator?
● Do I need to monkey patch?

5. Collections

6. Lisp
John McCarthy Structure and
Interpretation of Computer
Programs

7. Lists
first rest first rest first rest

8. Using Lists
map = function(list, fn) { reduce = function(list, fn) {
var head = first(list), tail = rest(list); var head = first(list), tail = rest(list);
if (!head) return []; if (!head) return null;
result = map(tail, fn); result = reduce(tail, fn);
return [fn(head)].append(result); return fn(head, result);
}; };
filter = function(list, fn) { forEach = function(list, fn) {
var head = first(list), tail = rest(list); var head = first(list), tail = rest(list);
if (!head) return []; if (!head) return null;
result = map(tail, fn); fn(head);
if (fn(head)) return [head].append(result); forEach(tail, fn);
else return result;
};
};

9. Sequences
● collection.first()
– Returns the first item
● collection.rest()
– Returns a sequence of the the tail of the
collection
● collection.cons(item)
– Returns a new collection with item at the head
and the collection at the tail

10. Lazy Sequences
● Only really care about the data in
the list when we call first()
● rest() can be lazily evaluated

11. Using Lazy Seqences
map = function(coll, fn) {
return lazySeq(function() {
var head = coll.first(list), tail = coll.rest(list);
return lazySeq.cons(map(tail, fn), fn(head));
});
};

12. The Interface Problem
● How do we check for the sequence
interface?
● How do we apply the interface
implementation if it's missing?
● What do we do if some object already
has a first, rest or cons which are
different from the ones we expect?

13. Monkey Patching
MyColl.protoype.first = function(coll) {}
MyColl.protoype.rest = function(coll) {}
MyColl.protoype.cons = function(coll, item) {}

14. The Adapter Pattern
mySeq =mySeqAdapter(myColl);
head = mySeq.first();
tail = mySeq.rest();
newSeq = myColl.cons(item);

15. Switching
function first(coll) {
if (coll === null)
return null;
else if (isArray(coll))
return coll[0];
else if ('function' === typeof coll.first)
return coll.first();
else
throw new Error('not a sequence');
}

16. Protocols
var Sequence = protocol.define(
'Sequence',
[ 'first', [ 'coll' ] ],
[ 'rest', [ 'coll' ] ],
[ 'cons', [ 'coll' ] ]
);
protocol.extend(
Sequence
MyCollection,
[ 'first', function (coll) { return coll.head(); } ],
[ 'rest', function (coll) { return coll.tail(); } ],
[ 'cons', function (coll, item) { return coll.cons(item); }
);

17. Protocols vs. Interfaces
Protocol Interface
Object Interface
Calls
Implements
Implementation
Calls
Object
Protocol
Calls
Calls
someFunction someFunction

18. Using Protocols
var first = Sequence.first, rest = Sequence.rest,
cons = Sequence.cons;
map = function(coll, fn) {
return lazySeq(function() {
var head = first(coll, list), tail = rest(coll, list);
return cons(map(tail, fn), fn(head));
});
};

19. What about Node?
● Sequences are synchronous
● Node is aynchronous
Pull vs. Push

20. Async in Node
Streams Promises
● Evented ● Single shot
● Callbacks ● Callbacks
● Buffered ● Unbuffered
● Composable ● Composable

21. Async Map
map = function(stream, fn) {
var result = stream.Stream();
result.writable = true;
stream.on(“data”, function(data) {
result.write(fn(data));
});
return result;
};

22. Async Sequences
● first(stream)
– A promise to the first item in the first buffer in the
stream.
● rest(stream)
– A sequence of the rest of the items in the first buffer
with the original stream at the tail.
● cons(stream, item)
– A sequence with a promise to the item at the head and
the stream as the tail.

23. Observations
● Lazy Sequences are like promises
● Syncronous values can be
reresented as promises that
resolve immediately
● With protocols we can conjoin
sequences.

24. Potential Uses
● Higher level abstractions
● Mix and match sync & async
● Write once run anywhere
● Leverage new technologies e.g.
WebCL

25. Get cosy
● cosy.lang
– Protocols
– Lazy Sequences
– Tail Recursion
http://bnt.getcosy.org (v0)
http://getcosy.org (v1+)

26. To be continued...
Part 2
● Async Sequences
● Tail Recursion
● Live Demos

27. Questions