Want to read Slashdot from your mobile device? Point it at m.slashdot.org and keep reading!


Forgot your password?

C++ Creator Wants To Solve 35-Year-Old Generic Programming Issues With Concepts (cio.com) 339

C++ creator Bjarne Stroustrup is arguing that we can improve code by grounding generic programming in concepts -- what's required by a template's arguments. An anonymous reader quotes Paul Krill's report on a new paper by Stroustrup: In concepts, Stroustrup sees the solution to the interface specification problem that has long dogged C++, the language he founded more than 35 years ago. "The way we write generic code today is simply too different from the way we write other code," Stroustrup says... Currently an ISO technical specification, concepts provide well-specified interfaces to templates without runtime overhead. Concepts, Stroustrup writes, are intended to complete C++'s support for generic programming as initially envisioned. "The purpose of concepts is to fundamentally simplify and improve design. This leads to fewer bugs and clearer -- often shorter -- code"...

Concepts, Stroustrup believes, will greatly ease engineers' ability to write efficient, reliable C++ code... The most obvious effect will be a massive improvement in the quality of error messages, but the most important long-term effect will be found in the flexibility and clarity of code, Stroustrup says. "In particular, having well-specified interfaces allows for simple, general and zero-overhead overloading of templates. That simplifies much generic code"

Concepts are already available in GNU C Compiler 6.2, and Stroustrup wants them to be included in C++ 20. "In my opinion, concepts should have been part of C++ 17, but the committee couldn't reach consensus on that."
This discussion has been archived. No new comments can be posted.

C++ Creator Wants To Solve 35-Year-Old Generic Programming Issues With Concepts

Comments Filter:
    • by jhoger ( 519683 )

      he said generic, not genetic.

    • Re:A new fad? (Score:5, Informative)

      by serviscope_minor ( 664417 ) on Monday January 23, 2017 @04:29AM (#53719345) Journal

      No, not a new fad.

      Concepts have been coming in C++ since the 90s.

      There are two parts of concepts. On the ideas side, Stapanov came up with the idea with the STL. A concept of X is anything X-like. So loosely speaking if you have an array concept, then anything giving [] and having indexable pointers/iterators matches. So, builtin arrays match, as does std::array and vectors from Eigen would match too.

      This makes sense: they're semantically the same and if you wrote an algorithm (eg. sort) using any of them, it would look identical. In this way, it's like a specification. If your class matches the specified "array" concept, then any algorithm written against that spec (the array concept) will work correctly on your class.

      It's a great idea.

      The other bit is language support. So, much C++ code is written using the idea of concepts, but the language does not assist in any way. Templating is completely generic, you say essentially "accept any class", but if you've written against the array concept, and the class doesn't match, you'll get a compile error right in the guts of the algorithm where you try to use [] on an array.

      It would be nice, instead of saying "this function accepts any class" to say "this function accepts any class matching the Array concept", or in short "this function accepts any Array". The compiler knows the types and can tell in advance if the class matches. That way if you try to sort a set with that function, for example, it would simply tell you that the set is not an Array.

      You can kind of finesse and finagle something better by utterly abusing a different language feature. The language has a mechanism called SFINAE (substitution failure is not an error), which is designed to make function overloading in the presence of templates sane. When the compiler does overload resolution, it substitutes the current type into any templated functions which match the name in question. If that substitution yields a compiler error, the compiler ignores it and removes that option from the list of overloads. This prevents unrelated templated overloads from breaking builds in irrelevant places. It's supposed to be a hidden detail which makes templating "just work". Except you can abuse it to enable/disable functions based on compile time tests for features of a class. IOW you can use it to implement concepts. Accordding to Stroustrup this means "you know too much :(".

      He's right: just because you can do it like that doesn't mean it makes life easy.

      Putting concepts into the language gives explicit support, with clean, clear, consistent syntax, not using brittle SFINAE hacks. People have been working out how since the 90s, and there have been several major proposals. It's not actually that trivial. You have to avoid breaking any old code, no matter how perverse. It has to work and work cleanly with old, non concept aware code (otherwise it would get slow/no adoption) and it needs to make life simpler for language users and not be an expert only feature, etc etc.

      It looks like the concepts TS is finally hitting enough of the targets to actually work.

      So basically, no, concepts is not a fad. It's been a major part of the C++ world for 2 decades.

      • Re: A new fad? (Score:2, Interesting)

        by Anonymous Coward

        So, a concept is just a fancy name for an interface or an abstract class?

        • Yes, AFAICT, it's an interface, but implicit - like a Go interface - not the explicit one you'd have to "implement" like in Java.
        • Close, but they're purely compile-time, and apply to the question of what types should be accepted by code templates?

        • Re: A new fad? (Score:5, Informative)

          by TheRaven64 ( 641858 ) on Monday January 23, 2017 @06:37AM (#53719597) Journal

          Yes, except with compile-time specialisation instead of run-time specialisation. One of the big problems that I have with C++ is that it has entirely separate mechanisms and syntax for implementing the same thing with compile-time and run-time specialisation and they don't always compose well. Languages such as Java sidestep this by providing only run-time specialisation and expecting the JIT compiler to generate the equivalent of compile-time specialisation.

          With an abstract class in C++, you'd require that every method be called via a vtable, which makes inlining hard (though modern compiler can do devirtualisation to some extent). This often doesn't matter, but when it's something like an array access, which is 1-2 instructions, the cost of the method call adds up. In contrast, if you use a template then the compiler knows exactly which method implementation is called and will inline any trivial methods (at the cost of now having one version of each templated function for every data type, which can blow away your instruction cache if you're not careful). The down side of the template approach is that you have no (simple) way of saying 'this template argument must be a thing on which these operations are defined' and the error message when you get it wrong is often dozens of layers of template instantiation later and totally incomprehensible without a tool such as Templight.

        • Re: A new fad? (Score:4, Informative)

          by vyvepe ( 809573 ) on Monday January 23, 2017 @07:25AM (#53719713)

          The man difference between a concept and an interface is in the time when the dispatching to some specific called code is resolved.

          Concepts resolve the call during compile time. This can lead to binary code bloat since the calling code needs to be "cloned" for each called code.

          Interfaces resolve the call during run time. It can reuse the caller code but imposes some call overhead (the run time dispatch).

          And sometimes you just need the resolving in the run time. If it would not be available then one would be forced to simulate it ... e.g. using dispatch (switch) on e.g. an alternative type (discriminated union). Well, or you could implement vtable manually if the language gives you enough power (pointer arithmetic) to do it.

        • It's similar, but not entirely the same. It's mostly implicit interfaces at compile time. Implicit in that you never need to declare that you meet an interface, your class is tested to see if it matches. However, it's much more parametric. Underneath it all, those tests are arbitrary code, not simply a list of methods and signatures.

  • More features. (Score:2, Insightful)

    by Anonymous Coward

    That's what C++ needs: More features! They had better introduce sidgils like in Perl so they can have room for more keywords.

    Templates produce very bloated code. Most embedded programmers working in C++ use a very small subset of the language for a reason. But C++ has lots of other problems. It was nice when it saved you from having to hand-build vtables doing OOP in C. Now after the meta-programming fads have gotten into it the language seems all over the map.

    • Re:More features. (Score:4, Insightful)

      by HornWumpus ( 783565 ) on Sunday January 22, 2017 @08:29PM (#53717781)

      Templates are like 600+ hp engines. At least you know your limitations.

      Embedded programmers mostly write C, Forth or assembler. If they are using a C++ compiler, they are likely using it to code in C (or FORTRAN).

      • Re: (Score:3, Insightful)

        by fozzy1015 ( 264592 )
        I used to write code for an enterprise network switch platform and our C code base started being built with g++. The toolbox analogy is apt. Forget the object orientated fluff, just use C with the STL container library. You have an optimized, standard interface library into commonly used data structures.
      • Embedded programmers mostly write C, Forth or assembler.

        All the same I'd be willing to bet there are more C++ programmers in embedded than Forth programmers........I've never seen a job posting with Forth, although I assume they exist. If I could find a job writing Forth, I would seriously consider it.

      • If they are using a C++ compiler, they are likely using it to code in C (or FORTRAN).

        So how much are they saving by rolling their own vtables instead of the ones the compiler will generate for them? How much smaller are their executables because they used #defines everywhere instead of templates? Does the fact that they use functions instead of overloaded operators really give them an edge, in terms of size or performance? Does ending every function call in "if (err) goto endx" really save space and time over having a single try-catch block somewhere?

        • Re:More features. (Score:5, Informative)

          by TheRaven64 ( 641858 ) on Monday January 23, 2017 @06:59AM (#53719643) Journal
          For embedded systems, you really don't want exceptions. The runtime for RTTI and exceptions is bigger than the flash on most systems (I wrote the one that ships on FreeBSD, the PS4, and a few other places - it's not a huge amount of code in the context of a desktop OS, but it's 100KB of object code for the C++ bits, plus the generic stack unwinder - you don't want to burn 150-200KB of space on an embedded system for this) and stack unwinding performance is very hard to reason about in anything realtime. The reason that the Embedded C++ subset excluded templates was that they make it very hard to reason about code size. A small amount of source code can easily become 10-100KB of object code if you instantiate templates with too many different types. Writing foo<Bar>() is now not a simple case of set up the call stack and jump, it's either that simple if someone else has instantiated the same template function, or it's creating an entirely new copy of foo and all other templates that it refers to using the template parameters. This makes it very difficult to work out what changes were responsible for pushing the size above the available space. Actually, it's even worse, because the specialised function might now be simple enough to inline everywhere and give an overall space saving, but reasoning about exactly where that balance is becomes very hard. It's not that C++ generates bigger code than C, it's that object code size in C++ has far less of a direct correspondence with source code size than C.
    • by dyfet ( 154716 )

      Indeed, in important ways, templates are both somewhat orthogonal to and do break some kinds of efficient object oriented design practices. Just think about templates and virtuals and why they do not really work together at all... It also has turned C++ into a modern version of IBM macro assemblers, where deeply obscured code regurgitation rules apply to what was actually compiled, hence also the bloat. However, the main benefit it still retains is that even if it may suck, for the things it is most ofte

      • There are no "efficient object oriented design practices". Templates are more efficient than shoving everything into a class hierarchy.
    • https://www.youtube.com/watch?... [youtube.com] Most templates and other code compile away. Learn to use the compiler.
    • by lucm ( 889690 )

      That's what C++ needs: More features!

      True. The guy should go and write more Seinfeld episodes instead.

    • I especially like it when those new features have incredibly generic names, implying how simple and fundamental they are regardless of usage, and not to mention how difficult it will be to search for information about them on the web.

    • That's what C++ needs: More features! They had better introduce sidgils like in Perl so they can have room for more keywords.

      Templates produce very bloated code. Most embedded programmers working in C++ use a very small subset of the language for a reason. But C++ has lots of other problems. It was nice when it saved you from having to hand-build vtables doing OOP in C. Now after the meta-programming fads have gotten into it the language seems all over the map.

      1. Templates (and most other OOP features) are not necessarily meant for tackling problems in embedded programming, which is why people do embedded programming in C (or a stripped down version of C++). In fact, they just don't use C, but they use some formal strict subset of it (MISRA-C or something like that.)

      2. Templates produce very bloated code... if you don't know how to use them or how you use them recklessly.

      3. They (and other features) are meant to create richer application level functionality (

  • Epicycles (Score:5, Insightful)

    by helixcode123 ( 514493 ) on Sunday January 22, 2017 @08:24PM (#53717751) Homepage Journal
    The vagaries and complexities of C++ as it progresses in it's specification is reminiscent of efforts to get epicycles to explain motions of heavenly bodies. Geez, people are snide about Perl syntax. Now we have &ref, &&global_ref, [](args){my_lambda_code();}, copy constructors, move constructors, 'override' to fix virtual function breakage. This is just a mess of a language.
    • Yeah, I know. &&global_ref => &&universal_ref.
    • https://www-users.cs.york.ac.u... [york.ac.uk]

      "Well, one day, when I was sitting in my office, I thought of this little scheme, which would redress the balance a little. I thought 'I wonder what would happen, if there were a language so complicated, so difficult to learn, that nobody would ever be able to swamp the market with programmers? "

    • Re: (Score:2, Funny)

      I learnt it and found it easy. I think the problem is with you.
      • I don't think so. Even folks that love C++ will say "well, you don't really need to know foo-obscure-feature, but it's there if you need it. I was reading through Scott Meyers' "Effective Modern C++", an excellent book, but probably half of it was showing how to make sure you "move" your data instead of "copying" it. I'm no Java fan, but at least everything is a reference, so you don't have copy-by-accident ooga booga. If copying is so bad (which apparently it is because you'll definitely get reamed du
        • The features he listed were not obscure. The expanded types of reference, move, and lambda functions are easy to grasp after one day of using it. In fact, most of the time you don't need to explicitly use it because the standard library constructs use it automatically.
        • by Jamu ( 852752 )

          The pain in C++ is on account of the "keep it compatible with C" mantra. C++ could be great if they'd just jettison that idiocy.

          Which would be nice, but it would also break existing code.

        • I'm no Java fan, but at least everything is a reference, so you don't have copy-by-accident ooga booga.

          That's true, but Java doesn't really have an equivalent of the C++11 move idiom. If you want Java-like semantics from C++, just alias your pointers (ideally wrapping them in something like std::shared_ptr first). The term move is actually a little bit misleading: you're copying the object, but you're transferring ownership of the expensive contents of the object. For example, when you move a string you're creating a new string object, but you're not copying all of the string data, you're just transferrin

        • by AmiMoJo ( 196126 )

          The problem with just having so many features is that if code you need to maintain is using them, you need to understand them. Not just have a vague idea of how they work or the syntax, but understand them well enough to write new classes or change existing behaviour without breaking everything.

          A lot of bad code started out as good code, then someone who wasn't familiar with what used to be the latest and greatest new paradigm back in 2003 had to maintain it.

          The great thing about C is that you can quite eas

      • Re: (Score:3, Interesting)

        by Anonymous Coward

        I found it easy when I learnt it too. Then I studied it a bit more, used it a whole lot more, and realised I was wrong and it was in fact a rather complex and obscure beast.

    • like Windows? (Score:2, Interesting)

      by Anonymous Coward

      Well, when I was thinking about programming languages a long time ago, I have come to a grudging respect for Windows, and backwards compatibility. Really good compilers, IDEs and debuggers will take many man years before production code can be made. In order to get that fancy stuff, you need a really big market to justify all that expensive development. That god scripting languages don't require such complicated tooling, and one has choices. I'm looking at you Javascript!

  • by tphb ( 181551 ) on Sunday January 22, 2017 @08:25PM (#53717759)

    I was just saying, "You know, C++ is too straightforward, and there are too few ways to get things done. It needs a few more keywords and paradigms to make it make it work."

    What a freakin' mess.

    • by Dutch Gun ( 899105 ) on Sunday January 22, 2017 @09:16PM (#53718011)

      Do you know what I never hear a carpenter saying? "Geez, look at all these tools. I wish I had fewer tools in my toolbox."

      C++ is a language toolbox. You can use the parts of it useful to you, and largely ignore the rest if you don't happen to need it at the moment.

      • by cfalcon ( 779563 ) on Sunday January 22, 2017 @09:47PM (#53718143)

        > "Geez, look at all these tools. I wish I had fewer tools in my toolbox."

        No, but I do here people who go in to modify something say "Gosh, I wish there weren't so many different types of connectors, why does this screw have a starburst and this one a rhombus on it?"

        Remember that for every Clever Lad who writes this code, an army of dudes has to come through and read and modify it over time.

        That's not to speak against it- merely that as the language gets broader, supporting it becomes slower and more expensive.

        • by Dutch Gun ( 899105 ) on Sunday January 22, 2017 @10:04PM (#53718211)

          Well, part of being a professional programmer, at least IMO, is not going batshit-insane with fancy language features when they're not needed. C++ is a language in which you can write some really, really horrible code if you're determined to do so. And I don't think I've ever heard anyone describe it as a language that's easy to master. But for highly experienced C++ programmers like myself, it's an incredibly powerful language, and that's what's important, at least when I use it professionally.

          It's pretty easy to list off a litany of problems with C++. It's bloated, it's ugly, it's hard to learn, full of strange idioms and tricky rules. But it has three characteristics that make it indespensible for certain industries and applications:

          * It's ubiquitous. Nearly every platform has a C++ compiler, and there's a lot of sample C or C++ code available to use. It also makes hiring and training easier.
          * It's efficient. You don't pay for features you don't use, and it compiles down to fast, efficient, native code.
          * It's got reasonably good abstraction features that don't require paying a heavy price for that safety, enabling large, complex programs to be written more easily.

          There are a lot of great new languages coming out, but nearly all of those fail on the first point. Unfortunately, that's a deal breaker for many projects.

        • by Jeremi ( 14640 ) on Sunday January 22, 2017 @10:56PM (#53718407) Homepage

          As a C++ programmer, I don't know if I'll ever use "concepts" in my own code.

          That said, I'm nevertheless very much looking forward to them becoming part of the language, if only so that when I do something wrong when using an STL class, the compiler can come back with an error that tells me what I did wrong, rather then five pages of incomprehensible gibberish.

          Many C++ features are like this, aimed not primarily at the average C++ user, but rather at the STL developers.

          • by Dutch Gun ( 899105 ) on Monday January 23, 2017 @03:18AM (#53719225)

            That's actually a really good point. I've watched some conference talks in recent years that explained how C++ is actually two languages... one designed for library writers (where a lot of the most hard-core features are aimed, such as move-semantics or template-related features), and a simpler subset for library-users, who often just call the code that the library writers write. The real world is not quite as clean-cut as that exactly, but I think it's true to some degree, certainly.

            All this makes for libraries which are incredibly easy-to-use while at the same time are both safe and efficient. In many cases, the user doesn't even have to know about all the optimizations that have been made. They can simply take advantage of the new language features like shared_ptr without having to worry about all the language features and work that went into making sure it works as naturally as though it were a built in language feature and not a library class. It's hard to describe how transformative the C++ 11/14 standard was for C++ as a language to people who still view it through the lens of what it was a like a decade or two ago. I often remark that C++ actually feels a lot like a managed language like C# now, only with much uglier syntax.

            What's remarkable to me is that this was done without breaking existing code out in the wild. I joke about the ugly syntax, but a lot of that comes from the reluctance to introduce new operators and keywords, which would invariably break existing code. Many of the complaints about C++'s "bloated" nature also comes from features left in place for backwards compatibility. If I had to offer a fourth quality to C++, it would be "stability", for which we can thank the C++ design community, who (along with various working groups) have been doing an amazing job this past decade. You can see modern examples of how traumatic it is for a language-using community when backwards compatibility breaks, something that many more modern language designers don't seem to feel as reluctant to do as I think they should.

            Hell, C++ 17 is only now removing support for trigraphs, for goodness' sake, an artifact of ancient keyboards that didn't support all the characters required to program C/C++. Hilariously, IBM is opposing its removal (it's already been delayed since C++ 11, largely thanks to them), which tells you that there's some rather ancient C/C++ actually living out there in the wild, as well as indicating how conservative the C++ community is in this regard.

          • by dargaud ( 518470 )
            OK, I started reading the comments hoping to be enlightened about what "Concepts" are (Gee, another common word reused to mean something else, it's going to be great searching for that on Google), but you are the only one who even mentioned it. Everybody else is too busy fighting about the bloating of C++.
            So I'll ask: what are Concepts ?!? And please talk to me like I'm a stupid C programmer...
            • A concept is pretty similar to what you might think of as a concepts. However there are two parts, the idea and the language support.

              So, for example numbers are concepts. They have +,-,*,/ and, well, work like numbers. This works for ints, unsigned ints, (of all widths), floats and (now) in C complex numbers. In C++ it works for ints, floats, std::complex and some random bigint or arbitrary precision float library you might use. Basically, it's a duck-test. If it looks like a duck and quacks like a duck, th

        • No, but I do here people who go in to modify something say "Gosh, I wish there weren't so many different types of connectors, why does this screw have a starburst and this one a rhombus on it?"

          But the engineers that make things, never go and say "oh I wish there weren't those 2000 different thread forms and sizes which all have different tradeoffs". The complexity of screws and threads is *astonishingly* huge once you start looking into it.

          Even with the simple head, even ignoring the stupid security heads,

      • by arth1 ( 260657 )

        Do you know what I never hear a carpenter saying? "Geez, look at all these tools. I wish I had fewer tools in my toolbox."

        Bad analogy. When the carpenter needs to repair something, he doesn't need to line up all the tools used to create it. And someone taking over the work doesn't need to learn the tools the previous carpenter used.

        The only fitting part of the analogy is that if the dovetails or tenons have gaps or cause the wood to split, it's probably because the carpenter used power tools and templates instead of more precise hand tools and reading the grain. Too much abstraction and little understanding of the fundament

  • by jd ( 1658 ) <[imipak] [at] [yahoo.com]> on Sunday January 22, 2017 @09:10PM (#53717955) Homepage Journal

    I want him to roll in the additions from Cilk++, Aspect-Oriented C++ and FeatureC++, the mobility and personalisation capabilities of Occam Pi, the networking extensions provided by rtnet and GridRPC, full encryption and error correction code facilities, everything in Boost, and a pointless subset of features from PL/1.

    If you're going to do it all, might as well do it in style.

    Seriously, though, Aspects would be nice.

    • The fact that the C++ committee still rejected Concepts shows they're not willing to add in any old feature because reasons.

      Funny how other languages don't get shit for actually including parallelism, networking, GUI, XML, JSON, etc into their standard library.

      At least in C++ if you don't need those libraries, you don't have to still download/install a huge runtime environment, or rely on online package managers that have to be up all the time.
  • by ooloorie ( 4394035 ) on Sunday January 22, 2017 @09:16PM (#53718009)

    How about first fixing something much more basic, like modules [meetingcpp.com]?

    • by Anonymous Coward on Sunday January 22, 2017 @10:05PM (#53718229)

      Really. After doing a little Ada programming, or even java with interfaces, not having a hard separation between interface and implementation is infuriating.

      • by Chris Katko ( 2923353 ) on Monday January 23, 2017 @02:48AM (#53719141)

        I've been playing around with D for a year or so and it features 99% of the stuff you wish C++ had. Modules are one of them.

        Plenty of the features in D end up in C++... except (literally) more than ten years later.

        The same thing everyone always bitches about D (as a reason for not trying it), is the garbage collector. But GC isn't actually required and can be disabled entirely or for critical sections. The standard lib uses GC but there's no reason someone couldn't bother to write an identical GC-free one... there's just no incentive for the existing community. You can also use data types that are not seen at all by the garbage collector and go RAII till the sun goes down. The power is yours to decide.

        Don't get me wrong, it's not a perfect language. But the language itself is .1% of the problems you'll encounter. The other 99.9% of the problem is the relatively small (but very helpful!) community, lack of tutorials and references, relative lack of D-specific libraries. When Javascript, C#, C++ and whatnot, you can literally google "C" + [any topic], and get pages of tutorials with great ones at the top. With D, there are much fewer and you'll end up with questions that don't have easy Google answers like "What does double colons mean here?"

        But as for the language? Man, I love it. INTEGRATED UNIT TESTING. Compile-time evaluation of complex functions. Built-in 2-D/3-D arrays. Built-in dynamic and static arrays. Static if statements. Contract programming. Ranges beat iterators. Immutable types (which are NOT the same as const, which can be cast away.) Pure functions. Array slicing. constructors named this() instead of classname() so you can rename them simply. No stupid .h/.cpp file. No extern. NO CIRCULAR OR FORWARD DEPENDENCY PROBLEMS. Parsing is TWO PASS. So you don't have to forward declare a class that uses another class... ten lines lower in the damn file. I mean what is this, 1978? Support for directly calling C code, (and direct C++ is supported in a fork called Calypso.)

        I could spend PAGES going on about each feature I learned and when I had a eureka moment for each one going, "MY GOD. THAT'S SO MUCH EASIER/MORE POWERFUL."

        I'm currently building up a framework basis for a moderate-sized game and I'm honestly having _fun_ writing this D code. I don't spend time writing boilerplate. I spend my time writing code that does stuff.

        I honestly hope, and can't wait, for the day that D becomes more popular.

  • by Kjella ( 173770 ) on Sunday January 22, 2017 @09:54PM (#53718175) Homepage

    The key difference between this and interfaces in Java seems to be push vs pull, does a class explicitly declare that it is say sortable or do you just check if it has functions that match something that's sortable. If you look at the example he does on page 8 with Shape.draw() and Cowboy.draw() sure you could be more explicit in the template requirements or you could demand that the cowboy explicitly has to say he's "drawable". To me Stroustrup's idea sounds a bit too much like the story about the blind man and the elephant [wikipedia.org], if you only touch it in enough places you can be sure it's an elephant. The obviously problem is that once you have a birth defect or amputee with only three legs, it all fails.

    For example I might like to define a class "SequenceNumber" that has functions like setInitialValue(), getNextValue() etc. but lacks typical characteristics of a number like being able to add and subtract them, but I can still sort sequence numbers. If it's explicit I only have to declare it sortable and implement the necessary functions. If it looks at the "concept" number it'll say nope, you're not a real number because we can't add two of you together.

    This could be trivially avoided by having the possibility to supplement class definitions as implementing additional interfaces, like here's a library with the Circle shape header and I say it's a drawable even though it doesn't say so itself. It'll still have to actually fulfill the interface, but that way you're not bound by the ones supplied by the library. Since that's purely a synthetic check on whether your code should be able to call that code I don't see how that should be a problem.

    • by Pseudonym ( 62607 ) on Sunday January 22, 2017 @10:23PM (#53718295)

      The key difference between this and interfaces in Java [...]

      ...is that algebras in Java are single-sorted, whereas in C++ they are trying to be more multi-sorted.

      The primary purpose of an algorithm (or a program, for that matter) is to transform data from one form to another form. Simula-style object orientation, as you find in Java (and in the OO part of C++), associates operations with a single type. This is the least-common and least-useful case, because the interesting parts of programs almost always involve more than one type.

      One key thing about the C++ concepts proposal that a lot of people miss is that it many templates have more than one argument. So it's not just a single type we're talking about here, but also associating related types.

      So it's not just "adding an interface after the fact". (Although that's a useful feature in itself; how many times have you needed to "decorate" a type from a library whose source code you don't own?) It's bringing the concept of a "class" closer to what that word actually means [wikipedia.org].

      Of course, Haskell's typeclasses are even better.

  • by roca ( 43122 ) on Sunday January 22, 2017 @10:04PM (#53718217) Homepage

    Concepts lets you check that the parameters of a template instantiation satisfy the template's requirements. However, it doesn't let you check that the *definition* of a template is valid whenever the parameters satisfy the template's requirements. So it's really only solving half of the problem.

    • That's true, but Boost already has facilities for that.

      • by roca ( 43122 )

        You mean the archetype stuff?

        > The validity of the archetype class test is completely dependent on it being an exact match with the concept, which must be verified by careful (manual) inspection.


        • Yes. That's the nature of STL concepts. Unlike Haskell typeclasses, it's not enough just to see that there are operations with the right types, because STL concepts are often defined in terms like "this is a valid expression, which returns a value convertible to bool".

  • The concepts thing sounds interesting. But when will C++ run on Node.js and MongoDB? That's the real question.
  • The problems appear when people with no technical background make the decision of which language to use for a particular project. They base their decision on what they heard from friends or on the latest buzzwords. For example Scala is now imposed on some projects simply because of the word going around that it is the latest and greatest thing.

    Experienced developers have already agreed that C++ is great for writing libraries. Personally I use it because I can do everything I need with one language. Handling

"Life sucks, but death doesn't put out at all...." -- Thomas J. Kopp