To name the unnamed

Label: ♦english ♦feature request

[578] To name the unnamed

Nightwalker created at Tuesday, 2011-02-01, 23:07:12

Nightwalker modified at Tuesday, 2011-02-01, 23:18:42

6 Replies, 1411 Hits

I have a proposal related to the newly introduced algebraic types (disjoint union types).

Let's start with the issue first. Suppose I want to write a binary search routine for lists; the strict declaration should then look like this:

routine find(source: list<@T>, element: @T) => int;

Now let's suppose I want to use algebraic type for the list parameter to restrict the type of its elements, say, "list<int|long|float|double>". But what to do with the element parameter then? Apparently, there will be no way to match it's type to those of source ! The most natural solution seems to be in using aliasing, something like this:

routine find(source: list<int|long|float|double as @T>, element: @T) => int;

There is another case where such thing could be useful -- template classes. What if I want to set up restrictions on the template parameter? Again, the solution may come in form of aliasing:

class Item<int|string as @T>
{
var x: @T;
...
}

Not sure we need this feature so badly, but I still would like to hear your opinions and proposals :)

Source URL: http://www.daovm.net/space/dao/thread/578

Comments

[580⇒578] ...

Comment

fu commented at Wednesday, 2011-02-02, 03:13:20

I have been thinking about this issue. But you are so quick to bring it up:)

The type form that I have been thinking for this looks like the following:

@T<int|long|float|double>

which means the type holder @T will hold one of the listed types.

[581⇒578] ...

Comment

Pompei2 commented at Wednesday, 2011-02-02, 08:42:47

Seems like an interesting idea. Just to add my 0.50$, I prefer TheTrueNightWalker's syntax, as in general I do prefer more words and less symbols, because they are easier to read and remember.
The middle in between both of you would be the following :-)

routine find(source: list<@T as int|long|float|double>, element: @T) => int;

[583⇒581] ...

Comment

fu commented at Friday, 2011-02-04, 05:43:34

Well, there is a minor problem with using as in type names, that is, your have to add blank spaces in type names, which is not very nice.

[585⇒583] ...

Comment

Pompei2 commented at Friday, 2011-02-04, 08:02:47

Do you mean "not nice" from a parser's viewpoint or from a user's viewpoint? If the latter, it is just a matter of taste, and it seems our tastes differ with regards to that point :-)

[588⇒585] ...

Comment

fu commented at Saturday, 2011-02-05, 19:16:46

I meant from users' viewpoint. There is no problem for the parser. Now I am considering support both "@T<int||float||...>" and "@T as int||float||..." , and use "@T<int||float||...>" as the internal type name. The reason to put "@T" before the variant, it's because "@T as int or float or ..." would look more natural.

[589⇒588] ...

Comment

Nightwalker commented at Saturday, 2011-02-05, 19:36:57

Nightwalker modified at Saturday, 2011-02-05, 19:37:35

I'd prefer the syntax with "as" ; without angle brackets, it looks much better when used within templates or container types :) And it seems more readable too.

Change picture: