Bjarne Stroustrup: C++ Concepts - Constraints on Template Parameters

And then there's this idea of concepts. Yes, that puts some. Now I've never even. I don't know if it was ever available in any form, but it puts some constraints on the stuff you can parameterize, essentially.

Let me try and explain. Yes. So yes, it wasn't there 10 years ago. We have had versions of it that actually work for the last four or five years. It was a design by Gaby Dos Reyes, Drew Sodden and me. We were professors and postdocs in Texas at the time. And the implementation by Andrew Soton has been available for that time. And it is part of C20 and there's a standard library that uses it. So this is becoming really very real. It's available in Clang and GCC GCC for a couple of years and I believe Microsoft is soon going to do it. We expect all of C20 to be available in all the major compilers 20 but this kind of stuff is available now. I'm just saying that because otherwise people might think I was talking about science fiction. And so what I'm going to say is concrete. You can run it today and there's production uses of it. So the basic idea is that when you have a generic component like a sort function, the sort function will require at least two parameters. One, a data structure with a given type and comparison criteria. And these things are related. But obviously you can't compare things if you don't know what the type of things you compare. And so you want to be able to say I'm going to sort something and it is to be sortable. What does it mean to be sortable? You look it up in the standard. It has to be a sequence with a beginning and an end. There has to be random access to that sequence and there has to be the element types has to be comparable by default.

Operator can operate on yes, lost. Some logical operator can operate.

Basically what concepts are. They're compile time predicates. They're predicates. You can ask, are you a sequence? Yes, I have begin and end. Are you a random exit sequence? Yes, I have subscripting and plus, is your element type something that has a less than? Yes, I have a less than. It's. And so basically that's the system. And so instead of saying I will take a parameter of any type, it'll say I'll take something that's sortable and it's well defined. And so you say, okay, you can sort with less than, I don't want less than, I want greater than or something I invent so you have two parameters, the sortable thing and the comparison criteria. And the comparison criteria will say, well, you can write it saying it should operate on the element type and it has the comparison operations. So that's simply the fundamental thing. It's compile time predicates, do you have the properties I need? So it specifies the requirements of the code on the parameters that it gets. It's very similar to types actually, but.

Operating in the space of concepts.

Concepts. The word concept was used by Alex Stefanov, who is sort of the father of generic programming in the context of C. There's other places that use that word. But the way we call generic programming is Alex's and he called them concepts because he said they are the sort of the fundamental concepts of an area. So they should be called concepts. And we've had concepts all the time. If you look at the KNR book about C, C has arithmetic types and it has integral types. It says so in the book. And then it lists what they are and they have certain properties. The difference to nay is that we can actually write a concept that will ask a type, are you an integral type? Do you have the properties necessary to be an integral type? Do you have plus, minus, divide and such?

So maybe the story of concepts, because I thought it might be part of C11, C, O, X, whatever it was at the time, what was the. Why didn't it. We'll talk a little bit about this fascinating process of standards because I think it's really interesting for people, it's interesting for me, but why did it take so long? What shapes did the idea of concepts take?

What were the challenges back in 87 or thereabouts?

1987, wow.

1987 or thereabouts, when I was designing templates, obviously I wanted to express the notion of what is required by a template, of its arguments. And so I looked at this and basically for templates, I wanted three properties. I wanted to be very flexible. It had to be able to express things I couldn't imagine because I know I can't imagine everything. And I've been suffering from languages that try to constrain you to only do what the designer thought. Good, didn't want to do that. Secondly, it had to run faster, as fast or faster than handwritten code. So basically, if I have a vector of T and I take a vector of char, it should run as fast as you build a vector of char yourself, without parameterization. And thirdly, I wanted to be able to express the constraints of the arguments, have proper type checking of the interfaces. Neither I nor anybody else at the time knew how to get all three. I thought for C, I must have the two first, otherwise it's not C. It bothered me for another couple of decades that I couldn't solve the third one. I mean, I was the one that put function argument type checking into C. I know the value of good interfaces. I didn't invent that idea, it's very common. But I did it and I wanted to do the same for templates, of course, and I couldn't. So it bothered me. Then we tried again. 2002, 2003, Gaby Das Reis and I started analyzing the problem, explained possible solutions. It was not a complete design. A group in University of Indiana, an old friend of mine, they started a project at Indiana and we thought we could get a good system of concepts in another two or three years that would have made C11 to C06 or 07. Well, it turned out that I think we got a lot of the fundamental ideas wrong. They were too conventional, they didn't quite fit. C, in my opinion, didn't serve implicit conversions very well. It didn't serve mixed type arithmetic, mixed type computations very well. A lot of stuff came out of the functional community, and that community didn't deal with multiple types in the same way as C does, had more constraints on what you could express, and didn't have the draconian performance requirements. And basically we tried, we tried very hard, we had some successes, but it just, in the end wasn't, didn't compile fast enough, was too hard to use, and didn't run fast enough unless you had optimizers. That was beyond the state of the art. They still are. So we had to do something else. Basically it was the idea that a set of parameters defines a set of operations and you go through an indirection table, just like for virtual functions, and then you try to optimize the indirection away to get performance, and we just couldn't do all of that.