On Sun, 05 Oct 2008 17:45:21 +0400, Andrei Alexandrescu <SeeWebsiteForEmail@erdani.org> wrote:

> Michel Fortin wrote:
>> On 2008-10-05 01:14:17 -0400, Andrei Alexandrescu <SeeWebsiteForEmail@erdani.org> said:
>>
>>> I don't favor "." any more than the next guy, but I am glad there is awareness of how unfit a choice "!" is. If you have any ideas, please post them! Ah! I! Exclaimed! Again!
>>  Hum, I don't think we have much choice, it'll have to be something in this lot:
>>      Positive!(real)(joke);
>>     Positive.(real)(joke);
>>     Positive#(real)(joke);
>>     Positive@(real)(joke);
>>     Positive&(real)(joke);
>>     Positive`(real)(joke);
>>     Positive´(real)(joke);
>>     Positive^(real)(joke);
>>     Positive¨(real)(joke);
>>     Positive\(real)(joke);
>>  Anything else I forgot?
>>  Or we could use special delimiter characters:
>>      Positive<real>(joke);
>>     Positive“real”(joke);
>>     Positive«real»(joke);
>>     Positive#real@(joke);
>>  Each having its own problem though.
>>  My preference still goes to "!(".
>
> There was also Positive{real}(joke), with which I couldn't find an ambiguity.
>
>> - - -
>>  The ".(" syntax makes me think more of something like this:
>>      void func(T, alias methodOfT, A...)(T obj, A args)
>>     {
>>         obj.(methodOfT)(args);
>>     }
>>  which I which I could do. If methodOfT was a string, I suppose I could use string mixins, but it pushes diagnostics about misnamed methods further in the template and requires adding quotes to the template parameter when instanciating.
>
> Given that methodOfT is an alias, there is no need for the parens.
>
>
> Andrei

Hmm... Is this syntax supported, for mixins in particular? I thought it is not implemented (it wasn't a few versions ago, because I run into the problem) and was about to propose it...

Added: no, it isn't as this code shows

template IntrusiveSNode(T) 	// intrusive single-linked node
{
	alias T ItemType;
	ItemType next;
}

class Item
{
	mixin IntrusiveSNode!(Item) ListOneStorable;
	mixin IntrusiveSNode!(Item) ListTwoStorable;
}

class IntrusiveSList(alias NodeType)		// intrusive single-linked list
{
	alias NodeType.ItemType ItemType;

	void add(ItemType item)	// no allocation is needed to put element to the list
	{
		if (tail is null) {
			head = item;
		}

		tail.NodeType.next = item; // fails
		tail = item;
		tail.NodeType.next = null; // fails	
	}

	ItemType head = null;
	ItemType tail = null;
}

void main()
{
	auto listOne = new IntrusiveSList!(Item.ListOneStorable);
	auto listTwo = new IntrusiveSList!(Item.ListTwoStorable);

	Item item = new Item();
	listOne.add(item);
	listTwo.add(item);
}

So, here is the proposal: allow this (for mixins as well)! :)

It just occured to me ..

if we're rethinking template syntax anyway, we could redefine the comma operator in 2.0 to create tuples.

Then the "of" keyword could be used for templates:

"(Vector of 2, int)[] veclist; "

I don't think it gets more understandable than that :D

 --downs

downs, el  5 de octubre a las 23:49 me escribiste:
> It just occured to me ..
> 
> if we're rethinking template syntax anyway, we could redefine the comma operator in 2.0 to create tuples.
> 
> Then the "of" keyword could be used for templates:
> 
> "(Vector of 2, int)[] veclist; "
> 
> I don't think it gets more understandable than that :D

Now we are talking!

PS: Nice way to finally introduce tuple syntax to the language ;)

-- 
Leandro Lucarella (luca) | Blog colectivo: http://www.mazziblog.com.ar/blog/
----------------------------------------------------------------------------
GPG Key: 5F5A8D05 (F8CD F9A7 BF00 5431 4145  104C 949E BFB6 5F5A 8D05)
----------------------------------------------------------------------------
I can't watch TV for four minutes without thinking
I have five serious diseases.
Like: "Do you ever wake up tired in the mornings?"
Oh my god I have this, write this down. Whatever it is, I have this.

downs wrote:
> It just occured to me ..
> 
> if we're rethinking template syntax anyway, we could redefine the comma operator in 2.0 to create tuples.
> 
> Then the "of" keyword could be used for templates:
> 
> "(Vector of 2, int)[] veclist; "
> 
> I don't think it gets more understandable than that :D

+1!!!  Pure genius!  Hey, looks like something I saw in Python...  oh well, Python is a good language, why not try and learn a few things from it?

Personally I don't think that we should just change the symbol ! to . because it will break a load of libraries for purely an ascetic change.  Its difficult to argue that . is better then ! as it depends on the person reading the code.  However if a template change allows for more functionality then it might be worth considering.

Anyway extending a previous suggestion.  What about using ;?

Foo(int T, alias X; T val, X val2);


One clash I can think of is that it might get mixup with a for loop, however I imagine that's easily detectable.  Also its slightly harder to make a distinction between the template args and the value however on the positive side its less typing.

-Joel

Janderson wrote:
> 
> Personally I don't think that we should just change the symbol ! to . because it will break a load of libraries for purely an ascetic change.  Its difficult to argue that . is better then ! as it depends on the person reading the code.  However if a template change allows for more functionality then it might be worth considering.
> 
> Anyway extending a previous suggestion.  What about using ;?
> 
> Foo(int T, alias X; T val, X val2);
> 
> 
> One clash I can think of is that it might get mixup with a for loop, however I imagine that's easily detectable.  Also its slightly harder to make a distinction between the template args and the value however on the positive side its less typing.
> 
> -Joel

This is the first suggestion which really interests me. It's really short, and there is some precedent for the use of ; as a separator from for/foreach.

But what do you do for non-function templates, which is really the problem case? I think you end up with a bunch of ;);), which maybe looks a bit odd.

auto v = new Vector!(Stack!(Tuple!(Positive!(real), Matrix!(real))))(3, 3));

becomes:
auto v = new Vector(Stack(Tuple(Positive(real), Matrix(real;););); 3, 3);

Don wrote:
> Janderson wrote:
>>
>> Personally I don't think that we should just change the symbol ! to . because it will break a load of libraries for purely an ascetic change.  Its difficult to argue that . is better then ! as it depends on the person reading the code.  However if a template change allows for more functionality then it might be worth considering.
>>
>> Anyway extending a previous suggestion.  What about using ;?
>>
>> Foo(int T, alias X; T val, X val2);
>>
>>
>> One clash I can think of is that it might get mixup with a for loop, however I imagine that's easily detectable.  Also its slightly harder to make a distinction between the template args and the value however on the positive side its less typing.
>>
>> -Joel
> 
> This is the first suggestion which really interests me. It's really short, and there is some precedent for the use of ; as a separator from for/foreach.
> 
> But what do you do for non-function templates, which is really the problem case? I think you end up with a bunch of ;);), which maybe looks a bit odd.
> 
> auto v = new Vector!(Stack!(Tuple!(Positive!(real), Matrix!(real))))(3, 3));
> 
> becomes:
> auto v = new Vector(Stack(Tuple(Positive(real), Matrix(real;););); 3, 3);

It does look winky though :o).

Andrei

Andrei Alexandrescu wrote:
> Don wrote:
>> Janderson wrote:
>>>
>>> Personally I don't think that we should just change the symbol ! to . because it will break a load of libraries for purely an ascetic change.  Its difficult to argue that . is better then ! as it depends on the person reading the code.  However if a template change allows for more functionality then it might be worth considering.
>>>
>>> Anyway extending a previous suggestion.  What about using ;?
>>>
>>> Foo(int T, alias X; T val, X val2);
>>>
>>>
>>> One clash I can think of is that it might get mixup with a for loop, however I imagine that's easily detectable.  Also its slightly harder to make a distinction between the template args and the value however on the positive side its less typing.
>>>
>>> -Joel
>>
>> This is the first suggestion which really interests me. It's really short, and there is some precedent for the use of ; as a separator from for/foreach.
>>
>> But what do you do for non-function templates, which is really the problem case? I think you end up with a bunch of ;);), which maybe looks a bit odd.
>>
>> auto v = new Vector!(Stack!(Tuple!(Positive!(real), Matrix!(real))))(3, 3));
>>
>> becomes:
>> auto v = new Vector(Stack(Tuple(Positive(real), Matrix(real;););); 3, 3);

That's a good point.  I think the ; should be optional for cases when there's no parameters (would that still work?).

auto v = new Vector(Stack(Tuple(Positive(real), Matrix(real))); 3, 3);

Also I think that any nested template syntax will be hard to read, that's why I prefer to use typedef/alias.

> 
> It does look winky though :o).
> 
> Andrei

When I write code I want it to smile back at me :)

-joel