On Tuesday, 3 September 2013 at 21:52:58 UTC, Manfred Nowak wrote:
> Carl Sturtivant wrote:
>> is supposed to transform one delegate into another
>
> Then please declare the template parameters to be delegates:
>
> U muddle( T, U)( T f) {
> 	uint g( int fp){
> 		return cast(uint)( 5* f( fp));
>         }
> 	auto gP= &g;
> 	return gP;
> }
>
> unittest {
>      import std.stdio;
> 	      int x = 3;
> 	    int scale( int s) { return x * s; }
> 	  auto f= muddle!( int delegate( int), uint delegate( int))( &scale);
> 	writeln( f(7));
> }

But I want some inference. In the real code the relevant delegates will have lots of long messy signatures that have already been declared.

And in your example above, I want the arguments of the delegates in general to be a type tuple, because any delegate may be passed.

On Tuesday, 3 September 2013 at 17:25:12 UTC, Manfred Nowak wrote:
> Carl Sturtivant wrote:
>> Writing muddle!(int,int)
> [...]
>> gives the same error message.
>
> Not entirely true:
>
> template muddle( T, U...){
>   alias T delegate( U) Dptr;
>   auto muddle1( T, U...)( Dptr f) {
> 	return f; //or make another delegate in real code
>   }
>   alias muddle1!( T, U) muddle;
> }
>
> unittest {
> 	import std.stdio;
> 	int x = 3;
> 	int scale( int s) { return x * s; }
> 	auto f= muddle!( int, int)( &scale);
> 	writeln( f(7));
> }
>
> -manfred

This technique does what I want if there's a single parameter to the delegate. I'll explore from here; thanks for all the examples.

Carl.

On Tuesday, 3 September 2013 at 11:51:37 UTC, Carl Sturtivant wrote:
>>
>> I'm confused as to what you're trying to do... your example code is equivalent to
>>
>>  import std.stdio;
>>  int x = 3;
>>  int scale( int s) { return x * s; }
>>  auto f = &scale;
>>  writeln( f(7) );
>
> No it isn't according to dmd.
>
> My code is a minimal piece that produces the same error as some real code. The higher order generic function muddle in the real code is supposed to transform one delegate into another, but I still get the template problem if muddle is the identity function (given here).
>
> My example code isn't equivalent to the above according to the compiler. Why is that? And how can I make it work?

Ok, that makes more sense.

The reason why it doesn't work is that you're effectively asking the compiler to work backwards from {the type of the delegate passed to muddle} to {the type parameters that would have to be used in Dptr to generate that delegate type}.
I'm no expert on type-deduction algorithms, but I seriously doubt that's a solvable problem in the general case, especially considering that the definition of Dptr could contain string mixins etc.   In the general case, all code is forwards-only.

Anyhow, it's easy to work around:

import std.traits : ReturnType, ParameterTypeTuple;

template Dptr( T, U...) {
	alias T delegate( U args) Dptr;
}

auto muddle( DT)( DT f) {
	alias T = ReturnType!f;
	alias U = ParameterTypeTuple!f;
	//use T and U
	return f; //or make another delegate in real code
}


unittest {
	import std.stdio;
	int x = 3;
	int scale( int s) { return x * s; }
	Dptr!(int,int) f = muddle( &scale);
	writeln( f(7));
}

On Thursday, 5 September 2013 at 09:00:27 UTC, John Colvin wrote:
> On Tuesday, 3 September 2013 at 11:51:37 UTC, Carl Sturtivant wrote:
>>>
>>> I'm confused as to what you're trying to do... your example code is equivalent to
>>>
>>> import std.stdio;
>>> int x = 3;
>>> int scale( int s) { return x * s; }
>>> auto f = &scale;
>>> writeln( f(7) );
>>
>> No it isn't according to dmd.
>>
>> My code is a minimal piece that produces the same error as some real code. The higher order generic function muddle in the real code is supposed to transform one delegate into another, but I still get the template problem if muddle is the identity function (given here).
>>
>> My example code isn't equivalent to the above according to the compiler. Why is that? And how can I make it work?
>
> Ok, that makes more sense.
>
> The reason why it doesn't work is that you're effectively asking the compiler to work backwards from {the type of the delegate passed to muddle} to {the type parameters that would have to be used in Dptr to generate that delegate type}.
> I'm no expert on type-deduction algorithms, but I seriously doubt that's a solvable problem in the general case, especially considering that the definition of Dptr could contain string mixins etc.   In the general case, all code is forwards-only.
>
> Anyhow, it's easy to work around:
>
> import std.traits : ReturnType, ParameterTypeTuple;
>
> template Dptr( T, U...) {
> 	alias T delegate( U args) Dptr;
> }
>
> auto muddle( DT)( DT f) {
> 	alias T = ReturnType!f;
> 	alias U = ParameterTypeTuple!f;
> 	//use T and U
> 	return f; //or make another delegate in real code
> }
>
>
> unittest {
> 	import std.stdio;
> 	int x = 3;
> 	int scale( int s) { return x * s; }
> 	Dptr!(int,int) f = muddle( &scale);
> 	writeln( f(7));
> }

Having said that, in the case where you explicitly set the template parameters to muddle I think it *should* work and is probably a bug (or at least a simple enhancement) that it doesn't.

On Thursday, 5 September 2013 at 09:11:06 UTC, John Colvin wrote:
> On Thursday, 5 September 2013 at 09:00:27 UTC, John Colvin wrote:
>> On Tuesday, 3 September 2013 at 11:51:37 UTC, Carl Sturtivant wrote:
>>>>
>>>> I'm confused as to what you're trying to do... your example code is equivalent to
>>>>
>>>> import std.stdio;
>>>> int x = 3;
>>>> int scale( int s) { return x * s; }
>>>> auto f = &scale;
>>>> writeln( f(7) );
>>>
>>> No it isn't according to dmd.
>>>
>>> My code is a minimal piece that produces the same error as some real code. The higher order generic function muddle in the real code is supposed to transform one delegate into another, but I still get the template problem if muddle is the identity function (given here).
>>>
>>> My example code isn't equivalent to the above according to the compiler. Why is that? And how can I make it work?
>>
>> Ok, that makes more sense.
>>
>> The reason why it doesn't work is that you're effectively asking the compiler to work backwards from {the type of the delegate passed to muddle} to {the type parameters that would have to be used in Dptr to generate that delegate type}.
>> I'm no expert on type-deduction algorithms, but I seriously doubt that's a solvable problem in the general case, especially considering that the definition of Dptr could contain string mixins etc.   In the general case, all code is forwards-only.
>>
>> Anyhow, it's easy to work around:
>>
>> import std.traits : ReturnType, ParameterTypeTuple;
>>
>> template Dptr( T, U...) {
>> 	alias T delegate( U args) Dptr;
>> }
>>
>> auto muddle( DT)( DT f) {
>> 	alias T = ReturnType!f;
>> 	alias U = ParameterTypeTuple!f;
>> 	//use T and U
>> 	return f; //or make another delegate in real code
>> }
>>
>>
>> unittest {
>> 	import std.stdio;
>> 	int x = 3;
>> 	int scale( int s) { return x * s; }
>> 	Dptr!(int,int) f = muddle( &scale);
>> 	writeln( f(7));
>> }
>
> Having said that, in the case where you explicitly set the template parameters to muddle I think it *should* work and is probably a bug (or at least a simple enhancement) that it doesn't.

I filed a bug report for it
http://d.puremagic.com/issues/show_bug.cgi?id=10969

On Thursday, 5 September 2013 at 09:33:00 UTC, John Colvin wrote:
> On Thursday, 5 September 2013 at 09:11:06 UTC, John Colvin wrote:
>> On Thursday, 5 September 2013 at 09:00:27 UTC, John Colvin wrote:
>>> On Tuesday, 3 September 2013 at 11:51:37 UTC, Carl Sturtivant wrote:
>>>>>
>>>>> I'm confused as to what you're trying to do... your example code is equivalent to
>>>>>
>>>>> import std.stdio;
>>>>> int x = 3;
>>>>> int scale( int s) { return x * s; }
>>>>> auto f = &scale;
>>>>> writeln( f(7) );
>>>>
>>>> No it isn't according to dmd.
>>>>
>>>> My code is a minimal piece that produces the same error as some real code. The higher order generic function muddle in the real code is supposed to transform one delegate into another, but I still get the template problem if muddle is the identity function (given here).
>>>>
>>>> My example code isn't equivalent to the above according to the compiler. Why is that? And how can I make it work?
>>>
>>> Ok, that makes more sense.
>>>
>>> The reason why it doesn't work is that you're effectively asking the compiler to work backwards from {the type of the delegate passed to muddle} to {the type parameters that would have to be used in Dptr to generate that delegate type}.
>>> I'm no expert on type-deduction algorithms, but I seriously doubt that's a solvable problem in the general case, especially considering that the definition of Dptr could contain string mixins etc.   In the general case, all code is forwards-only.
>>>
>>> Anyhow, it's easy to work around:
>>>
>>> import std.traits : ReturnType, ParameterTypeTuple;
>>>
>>> template Dptr( T, U...) {
>>> 	alias T delegate( U args) Dptr;
>>> }
>>>
>>> auto muddle( DT)( DT f) {
>>> 	alias T = ReturnType!f;
>>> 	alias U = ParameterTypeTuple!f;
>>> 	//use T and U
>>> 	return f; //or make another delegate in real code
>>> }
>>>
>>>
>>> unittest {
>>> 	import std.stdio;
>>> 	int x = 3;
>>> 	int scale( int s) { return x * s; }
>>> 	Dptr!(int,int) f = muddle( &scale);
>>> 	writeln( f(7));
>>> }
>>
>> Having said that, in the case where you explicitly set the template parameters to muddle I think it *should* work and is probably a bug (or at least a simple enhancement) that it doesn't.
>
> I filed a bug report for it
> http://d.puremagic.com/issues/show_bug.cgi?id=10969

and only 26.5 mins after posting the bug, there's a pull request to fix it: https://github.com/D-Programming-Language/dmd/pull/2526

That's what I call service :p