Fri Mar 23 21:33:44 CET 2012
On 3/23/2012 17:33, Nathan Rice wrote:
>> I will use "<=>" to mean "is equivalent to". That's not part of the DSL.
>> A flow has one or more streams:
>> 1 stream:
>> 2 streams:
>> [1,3,5] | [2,4,6]
>> Two flows can be concatenated:
>> [1,2,3] + [4,5,6]<=> [1,2,3,4,5,6]
>>  + ([1,2] | [3,4]) + <=> [0,1,2,10] | [0,3,4,10]
>> ([1,2] | [10,20]) + ([3,4] | [30,40])<=> [1,2,3,4] | [10,20,30,40]
> Algebraically, your concatenation rules don't really make sense - your
> flows are both distributive and non distributive.
> You also make the
> implicit assumption of an order over streams in a flow, but disregard
> the implications of that assumption in some cases.
> I understand what
> you're trying to communicate, so I think you need to be a little more
> strict and explicit in your definitions.
No, I don't think you understand what I meant.
>> A flow can be transformed:
>> [1,2] - f<=> [f(1),f(2)]
>> ([1,2] | [3,4]) - f<=> [f(1,3),f(2,4)]
>> ([1,2] | [3,4]) - [f]<=> [f(1),f(2)] | [f(3),f(4)]
>> ([1,2] | [3,4]) - [f,g]<=> [f(1),f(2)] | [g(3),g(4)]
>> [1,2] - [f,g]<=> [f(1),f(2)] | [g(1),g(2)]
> Given the examples you pose here, it is clear that you are assuming
> that the streams are synchronized in discrete time. Since you do not
> provide any mechanism for temporal alignment of streams you are also
> assuming every stream will have an element at every time point, the
> streams start at the same time and are of the same length. Is this
> what you want?
Yes. I thought that streams as an alternative to functional programming
were widely known.
>> Some functions are special and almost any function can be made special:
>> [1,2,3,4,5] - filter(isprime)<=> [2,3,5]
>> [,(1,2),[3,4,5]] - flatten<=> [1,2,3,4,5]
>> Note that 'filter' is not really necessary, thanks to 'flatten'.
> This implies that your transformations again produce flows. You
> should explicitly state this.
Isn't that obvious? BTW, those are not rigorous definitions. I thought I
was talking to people who regularly works with streams.
>> Flows can be named, remembered and used
>> as a value:
>> [1,2,3,4,5] - 'flow' + val('flow')<=> [1,2,3,4,5]*2
> Is this a flow with two identical streams, or a flow with one long
> stream formed by concatenation?
mean in Python?
Those are Python's lists/arrays.
>> as a transformation chain:
>> [1,2,3] - skipfirst - 'again' | [4,5,6] - func('again')
>> <=> [2,3] | [5,6]
>> Recursion is also possible and stops when a function is applied to an empty
>> Flows can be saved (push) and restored (pop) :
>> [1,2,3,4] - push - by(2) - 'double' - pop | val('double')
>> <=> [1,2,3,4] | [2,4,6,8]
>> There are easier ways to achieve the same result, of course:
>> [1,2,3,4] - [id, by(2)]
> You are grasping at an algebra here, a sort of calculus of temporal
> observations. You need to step back and make it rigorous before you
> worry about issues such as a readable syntax.
I don't agree. Sorry.
More information about the Python-list