Page 1 of 1


PostPosted: Fri Nov 28, 2008 1:36 pm
by Charles
I have added streams to the language. Instead of saying IEnumerable<of T> you can say T* as in int*, String*, etc. This feature comes from the Comega language.

-- Streams are portable between backends, whereas .NET's IEnumerable<of> and JVM's Iterable<of> are not.

-- Streams are two-way compatible with IEnumerable/Iterable:
---- Streams can be used whereever a compatible IEnumerable/Iterable is expected.
---- An IEnumerable/Iterable can be used whereever a compatible stream type is expected.
---- The term "compatible" means the same inner type: int* is compatible with IEnumerable<of int>/Iterable<of int>, but not IEnumerable<of String>/Iterable<of String>

-- However, compatibility does not mean that you can use the methods of IEnumerable or Iterable, since these vary between platforms.

-- Streams are an abstract type, so you cannot create them directly with a call on the type such as `int*()`. Instead, use a concrete class such as `List<of>`, or `yield` results out of a method.

-- Streams are defaulted to be empty rather than nil.

-- You can look at the test cases online or via your workspace (which will be nice with syntax highlighting):



If you have any questions or find any problems, let me know.

Re: Streams

PostPosted: Fri Nov 28, 2008 5:22 pm
by Charles
Two of the more common things you do with streams are:
-- loop through them with "for"
-- make a list out of them so you can do list stuff like sort, reverse, etc.

class Example

def main is shared

def foo(ints as int*)
t = List<of int>(t)
print t

def bar(ints as int*)
t = for i in ints where i > 0
print t

def bill(customers as Customer*)
for c in customers

Note that you can pass a stream, list, array or IEnumerable/Iterable wherever a compatible stream is expected (one with the same inner type). Methods that use the stream type for arguments can therefore be used in a wider range of situations as compared to expecting a more specific type such as array. Of course, sometimes you want something more specific and in those cases you should feel free to use List<of T>, IList<of T>, T[], etc.


Re: Streams

PostPosted: Sun Nov 30, 2008 8:40 am
by relez
It seems that this feature might be useful in order to obtain a better portability of language. Is this the main reason? But i think that programs this way will be also more readable....

Re: Streams

PostPosted: Sun Nov 30, 2008 9:09 am
by Charles
Portability and readability were both motivations. Yes, portability was the main motivation that caused me to prioritize this item now. Recall the post on cues as well:
cue enumerate as T*