Hi Stef,
I have some experiments I did last year in here
http://www.smalltalkhub.com/#!/~Guille/ReactiveExtensions
They allow you to do something like you want.
It is based on the ideas in
https://gist.github.com/staltz/868e7e9bc2a7b8c1f754
http://www.introtorx.com/
These guys model a stream with different transformations (such as
select:, collect: flatCollect: and so on...) as a chain of observers
where each transformation observes the one before, transforms the result
and notifies its observers with the modified value.
- The funny side is that with these they can manage polymorphically
both collections as streams, and normal streams (that may never end).
Also they do nice things with concurrency and retry operations fairly
easily.
- The odd part is DEBUGGING this.
* You may have tons of elements into your collection => Then you may
block all incoming events as soon as you debug one.
* You have to debug chains of observer/observed pairs, with the
boilerplate code that comes to it. Maybe a domain specific debugger
would be need for this...
Guille
Guille
-------- Original Message --------
Hi
I was looking at how we can turn a collection into a stream.
I played with
g := Generator on: [ :gen |
| current |
current := 0.
[ gen yield: (current := current + 1) ] repeat ].
g next.
and now imagine that we have
(1 to: 1000) collect: [:each | {each -1 . each . each + 1}].
I was wondering how we could turn it into a stream
(1 to: 1000) asStream collect: [:each | {each -1 . each . each + 1}].
and what would be the asStream method.
for index based I can see that next
next is something like
next
^ self at: (current := current + 1)
and collect: could be rewritten to use a generator.
Now does anybody play with this already?
Does xtream provide a way to do something in the same vein?
We can have a stream of blocks.
Stef
