www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Template currying

reply Yuxuan Shui <yshuiv7 gmail.com> writes:
So I was working on a parser combinator library, where the 
combinators take parsers as template argument. It works well 
until recently I decided to change the parsers so they would take 
Ranges instead of just strings.

The combinator used to look like:

     template Comb(alias parser1, alias parser2)

Now it looks like

     template Comb(alias parser1, alias parser2, Range)

And I want to have the compile deduce the Range template 
arguments, so I don't need to change the code that uses them. But 
I found out it's hard to partially instantiate templates.

It's OK to do that at the call site, e.g. Comb!(a, b)(range) 
works without specifying the Range. But sometimes I want to alias 
the result parser so I can use it at multiple places, but

     alias new_parser = Comb!(a, b);

doesn't work.

I need either to define Comb differently:

     template Comb(alias p1, alias p2) {
       template Comb(Range) {

or not use alias:

     template new_parser(alias p1, alias p2){
       alias new_parser(Range) = Comb!(p1, p2, Range); //Something 
like this, not tested
     }

I think it would be really nice if alias can be automatically 
translated to the latter one. Or maybe we can have something like

     template Curry(alias tmpl, Args1...) {
       alias Curry(Args2...) = tmpl!(Args1~Args2); //Pseudocode
     }

in the phobos.
May 05 2016
next sibling parent reply Ed <Ed ed.de> writes:
On Thursday, 5 May 2016 at 20:17:08 UTC, Yuxuan Shui wrote:
 So I was working on a parser combinator library, where the 
 combinators take parsers as template argument. It works well 
 until recently I decided to change the parsers so they would 
 take Ranges instead of just strings.

 The combinator used to look like:

     template Comb(alias parser1, alias parser2)

 Now it looks like

     template Comb(alias parser1, alias parser2, Range)

 And I want to have the compile deduce the Range template 
 arguments, so I don't need to change the code that uses them. 
 But I found out it's hard to partially instantiate templates.

 It's OK to do that at the call site, e.g. Comb!(a, b)(range) 
 works without specifying the Range. But sometimes I want to 
 alias the result parser so I can use it at multiple places, but

     alias new_parser = Comb!(a, b);

 doesn't work.

 I need either to define Comb differently:

     template Comb(alias p1, alias p2) {
       template Comb(Range) {

 or not use alias:

     template new_parser(alias p1, alias p2){
       alias new_parser(Range) = Comb!(p1, p2, Range); 
 //Something like this, not tested
     }

 I think it would be really nice if alias can be automatically 
 translated to the latter one. Or maybe we can have something 
 like

     template Curry(alias tmpl, Args1...) {
       alias Curry(Args2...) = tmpl!(Args1~Args2); //Pseudocode
     }

 in the phobos.
It's hard to help without a minimal working example (maybe something with just the body). If you mean that "alias new_parser = Comb!(a, b);" generates an error maybe that's because the correct syntax is "alias new_parser(Range) = Comb!(a, b);" ? One issue you may encounter is that template parameter deduction (that's called IFTI I think) can fail with an alias (so partially specialized template/templatized function, etc).
May 05 2016
parent reply Yuxuan Shui <yshuiv7 gmail.com> writes:
On Thursday, 5 May 2016 at 21:54:29 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 20:17:08 UTC, Yuxuan Shui wrote:
 [...]
It's hard to help without a minimal working example (maybe something with just the body). If you mean that "alias new_parser = Comb!(a, b);" generates an error maybe that's because the correct syntax is "alias new_parser(Range) = Comb!(a, b);" ? One issue you may encounter is that template parameter deduction (that's called IFTI I think) can fail with an alias (so partially specialized template/templatized function, etc).
Simple example: int a(int b, T)(T c){return 0;} It's fine to: a!1(2); But: alias A = a!1; Would fail.
May 05 2016
parent reply Ed <Ed ed.de> writes:
On Thursday, 5 May 2016 at 22:53:01 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 21:54:29 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 20:17:08 UTC, Yuxuan Shui wrote:
 [...]
It's hard to help without a minimal working example (maybe something with just the body). If you mean that "alias new_parser = Comb!(a, b);" generates an error maybe that's because the correct syntax is "alias new_parser(Range) = Comb!(a, b);" ? One issue you may encounter is that template parameter deduction (that's called IFTI I think) can fail with an alias (so partially specialized template/templatized function, etc).
Simple example: int a(int b, T)(T c){return 0;} It's fine to: a!1(2); But: alias A = a!1; Would fail.
alias aa(T) = a!(1,T); aa!ubyte(2); Your alias declaration is not correct.
May 05 2016
parent reply Yuxuan Shui <yshuiv7 gmail.com> writes:
On Thursday, 5 May 2016 at 23:12:40 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 22:53:01 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 21:54:29 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 20:17:08 UTC, Yuxuan Shui wrote:
 [...]
It's hard to help without a minimal working example (maybe something with just the body). If you mean that "alias new_parser = Comb!(a, b);" generates an error maybe that's because the correct syntax is "alias new_parser(Range) = Comb!(a, b);" ? One issue you may encounter is that template parameter deduction (that's called IFTI I think) can fail with an alias (so partially specialized template/templatized function, etc).
Simple example: int a(int b, T)(T c){return 0;} It's fine to: a!1(2); But: alias A = a!1; Would fail.
alias aa(T) = a!(1,T); aa!ubyte(2); Your alias declaration is not correct.
As you can see in my first post, I know how to make this work. I just think it'd be nice if compiler can do this automatically. Anothor point is that, what if I want to use partially instantiated templates as template arguments?
May 05 2016
next sibling parent reply Yuxuan Shui <yshuiv7 gmail.com> writes:
On Thursday, 5 May 2016 at 23:19:59 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:12:40 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 22:53:01 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 21:54:29 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 20:17:08 UTC, Yuxuan Shui wrote:
 [...]
It's hard to help without a minimal working example (maybe something with just the body). If you mean that "alias new_parser = Comb!(a, b);" generates an error maybe that's because the correct syntax is "alias new_parser(Range) = Comb!(a, b);" ? One issue you may encounter is that template parameter deduction (that's called IFTI I think) can fail with an alias (so partially specialized template/templatized function, etc).
Simple example: int a(int b, T)(T c){return 0;} It's fine to: a!1(2); But: alias A = a!1; Would fail.
alias aa(T) = a!(1,T); aa!ubyte(2); Your alias declaration is not correct.
As you can see in my first post, I know how to make this work. I just think it'd be nice if compiler can do this automatically. Anothor point is that, what if I want to use partially instantiated templates as template arguments?
See this example: int a(alias f)(){return f(3);} int b(int z, T)(T c){return c;} void main() { a!(b!1)(); } It'd really nice if this just works, or if there's something called Curry which I can use like this: a!(Curry!(b, 1))
May 05 2016
next sibling parent reply Ed <Ed ed.de> writes:
On Thursday, 5 May 2016 at 23:33:07 UTC, Yuxuan Shui wrote:
 It'd really nice if this just works,
That's clear that you've never been stuck in the fat mud of imperative and OO programming styles. You don't realize (anymore ?) how lucky we are with D templates, compared to other languages! Maybe you come from C++, so that's not so obvious for you but with my background I'm still amused when I see people complaining about such details. ^^ Anyway, you can open a enhancement request and pray...
May 05 2016
parent reply Yuxuan Shui <yshuiv7 gmail.com> writes:
On Thursday, 5 May 2016 at 23:46:59 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 23:33:07 UTC, Yuxuan Shui wrote:
 It'd really nice if this just works,
That's clear that you've never been stuck in the fat mud of imperative and OO programming styles. You don't realize (anymore ?) how lucky we are with D templates, compared to other languages! Maybe you come from C++, so that's not so obvious for you but with my background I'm still amused when I see people complaining about such details. ^^
Yes, I do appreciate the power of D, I just want it to be BETTER.
 Anyway, you can open a enhancement request and pray...
I'll do that, but I just want to see some feedback on this idea....
May 05 2016
parent Ed <Ed ed.de> writes:
On Friday, 6 May 2016 at 00:08:01 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:46:59 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 23:33:07 UTC, Yuxuan Shui wrote:
 It'd really nice if this just works,
That's clear that you've never been stuck in the fat mud of imperative and OO programming styles. You don't realize (anymore ?) how lucky we are with D templates, compared to other languages! Maybe you come from C++, so that's not so obvious for you but with my background I'm still amused when I see people complaining about such details. ^^
Yes, I do appreciate the power of D, I just want it to be BETTER.
 Anyway, you can open a enhancement request and pray...
I'll do that, but I just want to see some feedback on this idea....
Sorry, I don't know why I thought this thread was on d.learn, I didn't get this was a general discussion.
May 05 2016
prev sibling parent reply Yuxuan Shui <yshuiv7 gmail.com> writes:
On Thursday, 5 May 2016 at 23:33:07 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:19:59 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:12:40 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 22:53:01 UTC, Yuxuan Shui wrote:
 [...]
alias aa(T) = a!(1,T); aa!ubyte(2); Your alias declaration is not correct.
As you can see in my first post, I know how to make this work. I just think it'd be nice if compiler can do this automatically. Anothor point is that, what if I want to use partially instantiated templates as template arguments?
See this example: int a(alias f)(){return f(3);} int b(int z, T)(T c){return c;} void main() { a!(b!1)(); } It'd really nice if this just works, or if there's something called Curry which I can use like this: a!(Curry!(b, 1))
Wait, I just realized that this example works in 2.071, but not in 2.068.2. What has changed?
May 05 2016
parent reply Yuxuan Shui <yshuiv7 gmail.com> writes:
On Friday, 6 May 2016 at 06:18:22 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:33:07 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:19:59 UTC, Yuxuan Shui wrote:
 [...]
See this example: int a(alias f)(){return f(3);} int b(int z, T)(T c){return c;} void main() { a!(b!1)(); } It'd really nice if this just works, or if there's something called Curry which I can use like this: a!(Curry!(b, 1))
Wait, I just realized that this example works in 2.071, but not in 2.068.2. What has changed?
Apply{Left, Right} is add in 2.071 as well, and I didn't see them mentioned in the ChangLog...
May 05 2016
parent reply Yuxuan Shui <yshuiv7 gmail.com> writes:
On Friday, 6 May 2016 at 06:26:14 UTC, Yuxuan Shui wrote:
 On Friday, 6 May 2016 at 06:18:22 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:33:07 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:19:59 UTC, Yuxuan Shui wrote:
 [...]
See this example: int a(alias f)(){return f(3);} int b(int z, T)(T c){return c;} void main() { a!(b!1)(); } It'd really nice if this just works, or if there's something called Curry which I can use like this: a!(Curry!(b, 1))
Wait, I just realized that this example works in 2.071, but not in 2.068.2. What has changed?
Apply{Left, Right} is add in 2.071 as well, and I didn't see them mentioned in the ChangLog...
Oh, sorry, that doesn't work. My mistake. And ApplyLeft doesn't work for that example either (I thought it would). Looks like it's a bit more difficult to implement Curry!() than I thought.
May 05 2016
parent Yuxuan Shui <yshuiv7 gmail.com> writes:
On Friday, 6 May 2016 at 06:30:27 UTC, Yuxuan Shui wrote:
 On Friday, 6 May 2016 at 06:26:14 UTC, Yuxuan Shui wrote:
 On Friday, 6 May 2016 at 06:18:22 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:33:07 UTC, Yuxuan Shui wrote:
     [...]
Wait, I just realized that this example works in 2.071, but not in 2.068.2. What has changed?
Apply{Left, Right} is add in 2.071 as well, and I didn't see them mentioned in the ChangLog...
Oh, sorry, that doesn't work. My mistake. And ApplyLeft doesn't work for that example either (I thought it would). Looks like it's a bit more difficult to implement Curry!() than I thought.
I figured it out, here is a prototype of Curry: template Curry(alias tmpl, Left...) { auto Curry(Right...)(Right r) { return tmpl!Left(r); } }
May 05 2016
prev sibling parent reply Ed <Ed ed.de> writes:
On Thursday, 5 May 2016 at 23:19:59 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:12:40 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 22:53:01 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 21:54:29 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 20:17:08 UTC, Yuxuan Shui wrote:
 [...]
It's hard to help without a minimal working example (maybe something with just the body). If you mean that "alias new_parser = Comb!(a, b);" generates an error maybe that's because the correct syntax is "alias new_parser(Range) = Comb!(a, b);" ? One issue you may encounter is that template parameter deduction (that's called IFTI I think) can fail with an alias (so partially specialized template/templatized function, etc).
Simple example: int a(int b, T)(T c){return 0;} It's fine to: a!1(2); But: alias A = a!1; Would fail.
alias aa(T) = a!(1,T); aa!ubyte(2); Your alias declaration is not correct.
As you can see in my first post, I know how to make this work. I just think it'd be nice if compiler can do this automatically. Anothor point is that, what if I want to use partially instantiated templates as template arguments?
My bad, I didn't read carefully "or not use alias:". With alias template parameter you can pass template: ------ import std.stdio; template Foo(T,U){ T pop(){return T.max;}} alias Partial(U) = Foo!(U, string); auto bar(alias Whatever)() { alias instance = Whatever!int; return instance.pop; } void main(string[] args) { writeln(bar!(Partial)()); } ------ for example.
May 05 2016
parent Yuxuan Shui <yshuiv7 gmail.com> writes:
On Thursday, 5 May 2016 at 23:38:38 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 23:19:59 UTC, Yuxuan Shui wrote:
 On Thursday, 5 May 2016 at 23:12:40 UTC, Ed wrote:
 On Thursday, 5 May 2016 at 22:53:01 UTC, Yuxuan Shui wrote:
 [...]
alias aa(T) = a!(1,T); aa!ubyte(2); Your alias declaration is not correct.
As you can see in my first post, I know how to make this work. I just think it'd be nice if compiler can do this automatically. Anothor point is that, what if I want to use partially instantiated templates as template arguments?
My bad, I didn't read carefully "or not use alias:". With alias template parameter you can pass template: ------ import std.stdio; template Foo(T,U){ T pop(){return T.max;}} alias Partial(U) = Foo!(U, string); auto bar(alias Whatever)() { alias instance = Whatever!int; return instance.pop; } void main(string[] args) { writeln(bar!(Partial)()); } ------
Right, Partial!() works. I just want something more generic, like the Curry I proposed. And I still think let the compiler do it is a good idea, because this could removes special cases in template arguments deduction
May 05 2016
prev sibling parent ZombineDev <petar.p.kirov gmail.com> writes:
On Thursday, 5 May 2016 at 20:17:08 UTC, Yuxuan Shui wrote:
 So I was working on a parser combinator library, where the 
 combinators take parsers as template argument. It works well 
 until recently I decided to change the parsers so they would 
 take Ranges instead of just strings.

 The combinator used to look like:

     template Comb(alias parser1, alias parser2)

 Now it looks like

     template Comb(alias parser1, alias parser2, Range)

 And I want to have the compile deduce the Range template 
 arguments, so I don't need to change the code that uses them. 
 But I found out it's hard to partially instantiate templates.

 It's OK to do that at the call site, e.g. Comb!(a, b)(range) 
 works without specifying the Range. But sometimes I want to 
 alias the result parser so I can use it at multiple places, but

     alias new_parser = Comb!(a, b);

 doesn't work.

 I need either to define Comb differently:

     template Comb(alias p1, alias p2) {
       template Comb(Range) {

 or not use alias:

     template new_parser(alias p1, alias p2){
       alias new_parser(Range) = Comb!(p1, p2, Range); 
 //Something like this, not tested
     }

 I think it would be really nice if alias can be automatically 
 translated to the latter one. Or maybe we can have something 
 like

     template Curry(alias tmpl, Args1...) {
       alias Curry(Args2...) = tmpl!(Args1~Args2); //Pseudocode
     }

 in the phobos.
alias can automatically introduce template arguments only for function literals: alias add = (a, b) => a + b; add has two implicit template arguments: auto sum = add(4, 3.17); deduced to int and double in the case above. Actually the alias add refers to the symbol of an automatically generated template: alias add = _add_generated; template _add_generated(T1, T2) { auto _add_generated(T1 a, T2 b) { return a + b; } } The closest thing to getting the compiler to generate something like the above template is ApplyLeft/ApplyRight from std.meta: http://dlang.org/phobos/std_meta#.ApplyLeft
May 05 2016