4 ms·
I was struggling with the way the operators are written: clickStream.map(f).scan(g); Then I realised that map() and scan() are not doing much when that line
by gulpahum 12y ago
I was struggling with the way the operators are written:
clickStream.map(f).scan(g);
Then I realised that map() and scan() are not doing much when that line of code is executed. They only add a new operation step to a list of operations for clickStream. Only when an event is received, the saved list of operations gets executed. So, I think a better naming would have been addMap() and addScan(), because they only add operators. They don't map/scan anything when they are called.
I think the best tutorial for me would have been an article explaining what is going on under the hood. This tutorial does mention this implementation detail but only very briefly.
Anyway, without the tutorial, I wouldn't have realized this, so it was actually helpful. :)
- mattpodwysocki 12y agoYou can try our Learn RxJS tutorial here as well: http://reactive-extensions.github.io/learnrx/ http://reactive-extensions.github.io/learnrx/
- 6cxs2hd6 12y ago> So, I think a better naming would have been... Often I like to use past participles as names for stream or signal combinators. So instead of `map`, `filter`, `fold` -- the names are `mapped`, `filter`, `folded`. For example, given a stream, `(mapped stream f)` returns a new stream with f mapped over it. It returns a mapped stream.
- Sharlin 12y agoStreams are lazy. They work in the same manner as lazy collections in languages such as Scala and Haskell - if you have an infinite collection, say, the set of all prime numbers, and do a map operation on it, it does not try to eagerly execute an infinite loop. Instead, the mapping is only done when when you actually request any of the elements of the set.
- prawks 12y ago"add___" might imply mutation of the stream, which it seems to me (just reading this tut for the first time) isn't the mindset the framework wants you to be in.
- jowiar 12y agoWhen working with functional programming, thinking about "doing" is often the wrong approach, because "doing" is often tied to "change of state". Instead, think about translations/transformations from "what I have" to "what I want". clickStream.map(f) doesn't "do" anything - it takes a stream, and returns another stream that's the result of f applied to each element of clickStream. So if I do something like: astream = clickStream.map(a) bstream = clickStream.map(b) cstream = clickStream.map(c) I've created three streams that are each the result of a particular function applied to the elements of an original stream.