{"id":1878,"date":"2012-10-24T20:00:01","date_gmt":"2012-10-24T19:00:01","guid":{"rendered":"https:\/\/www.reenigne.org\/blog\/?p=1878"},"modified":"2016-01-31T17:44:33","modified_gmt":"2016-01-31T17:44:33","slug":"variadic-templates-in-alfe","status":"publish","type":"post","link":"https:\/\/www.reenigne.org\/blog\/variadic-templates-in-alfe\/","title":{"rendered":"Variadic templates in ALFE"},"content":{"rendered":"

Some of<\/a> the<\/a> types<\/a> in ALFE are templates which can accept different numbers of parameters – in other words, variadic templates. How does this fit in with the Kind system I wrote about before<\/a>?<\/p>\n

As well as the Kind constructors “<><\/strong>” (template) and “” (type), we need a third Kind constructor which represents zero or more Kinds in a sequence suitable for template arguments. Let’s call this Kind constructor “…<\/strong>“. As with C++ templates, we should allow the members of the sequence to have arbitrary kind. So <…><\/strong> is the kind of a template that takes zero or more arguments whose kinds are type, while <<>…><\/strong> is the kind of a template that takes zero or more arguments whose kinds are <><\/strong> (a single argument template whose argument is of kind type). The kind of Function<\/strong> is <, …><\/strong> (the comma is required because Function<\/strong> has one or more arguments rather than zero or more). More complicated kinds like <<…>, …><\/strong> are also possible.<\/p>\n

To actually create a variadic template, we need to implement “recursive case” and “base case” templates and have the compiler choose between them by pattern matching, just as in C++. So the definition of Tuple<\/strong> might look something like:<\/p>\n

\r\nTuple<@T, ...> = Structure { T first; Tuple<...> rest; };\r\nTuple<> = Structure { };\r\n<\/pre>\n
Is that enough? Well, I believe this gives ALFE’s kind system parity with C++’s. However, there is one more possible Kind constructor that I can imagine – the Kind constructor which can represent any Kind at all – let’s call it $<\/strong>. A template with an argument of this kind (i.e. has kind <$><\/strong>) can be instantiated with an argument of any kind. So you could have:<\/del><\/p>\n
\r\nFoo<@T> = { ... };\r\nFoo<@T<>> = { ... };\r\nFoo<@T<@R<$>>> = { ... };\r\n<\/pre>\n
The first template is used when Foo<\/strong> is instantiated with a type, the second is used when it’s instantiated with a template of kind <><\/strong> and the third is used when it’s instantiated with any other single-argument template, no matter what the kind of the argument is. The third template could then pass R<\/strong> as an argument to another instantiation of Foo<\/strong> and thereby “peel apart” the kind of the argument (as long as none of the kinds involved have multiple arguments).<\/del><\/p>\n
By combining $<\/strong> with …<\/strong> I think we could potentially peel apart completely arbitrary kinds. However, I’m not sure if this is worth implementing since I can’t think of any use for such a thing. Still, it’s good to have some idea about how to proceed if I do eventually come across such a use!<\/del><\/p>\n
Edited 31st January 2016: Since writing the above, I have realized that the concept of the $<\/strong> Kind specifier has a fatal flaw. Just because our Foo<\/strong> template has been instantiated with a template of a particular kind, does not mean that we have any way of obtaining type constructors of suitable kinds for instantiating that template. We can’t pass R<\/strong> as an argument to another instantiation of Foo<\/strong> because we have no way to find such a thing to pass – all we have is a template that we know takes such a thing. There might be no suitable type constructors in the entire program! So there is really nothing we can do with our T<\/strong> here at all – we can’t instantiate it (even partially) since we don’t know the kind of its first argument. We could pass it to another template, but that just moves the problem around without making any progress on it. <\/p>\n","protected":false},"excerpt":{"rendered":"
Some of the types in ALFE are templates which can accept different numbers of parameters – in other words, variadic templates. How does this fit in with the Kind system I wrote about before? As well as the Kind constructors “<>” (template) and “” (type), we need a third Kind constructor which represents zero or […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4,27],"tags":[],"class_list":["post-1878","post","type-post","status-publish","format-standard","hentry","category-computer","category-language"],"_links":{"self":[{"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/posts\/1878","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/comments?post=1878"}],"version-history":[{"count":4,"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/posts\/1878\/revisions"}],"predecessor-version":[{"id":1990,"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/posts\/1878\/revisions\/1990"}],"wp:attachment":[{"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/media?parent=1878"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/categories?post=1878"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.reenigne.org\/blog\/wp-json\/wp\/v2\/tags?post=1878"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}