Home » Blog » Tags » experimental

experimental

CppCon 2015 Haskell Design Patterns for Genericity & Asynchronous Behavior--Sherri Shulman

By Adrien Hamelin | Jun 15, 2016 01:50 PM | Tags: experimental community

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Haskell Design Patterns for Genericity & Asynchronous Behavior

by Sherri Shulman

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

The paper explores some of Haskell's support for genericity through type classes, Functors, Monads, and Continuations and their impact on lanugages such as C++, Scala, and Rust. We explore these language features and consider alternatives that have been proposed to existing language features, including Object Algebras, GADTs, Open data types, open pattern matching, and extensions to Haskell's type system that impact the type inference algorithm and decidability. We use a number of case studies to demonstrate what proposed solutions look like in the target languages, considering how easy they are to use and how well the solutions integrate with existing linguistic features.

Building And Packaging C++ Modules In Vs2015--Conan's blog

By Adrien Hamelin | Jun 14, 2016 12:44 PM | Tags: intermediate experimental

Modules in Conan explained:

Building And Packaging C++ Modules In Vs2015

by Conan's blog

From the article:

This post makes a brief introduction to the C++ modules (we wished C++17, but we will have to wait). Modules have already been experimentally available in an early implementation in CLang, and now Microsoft is also providing them in Visual Studio 2015. We will see their syntax and how to build them, as introduced in the Visual Studio Blog, and at the same time, we will show how to create and consumes packages with C++ modules with conan C/C++ package manager.

C++ Today--Bjarne Stroustrup

By Adrien Hamelin | May 30, 2016 01:59 PM | Tags: experimental c++14

An interesting video to watch!

C++ Today

by Bjarne Stroustrup

Summary of the video:

During a short visit to College on 13 May 2016, Bjarne gave a talk describing what C++ is today (May 2016, C++14) and how it can be used well. He will focus on ISO standard C++ and the way it is developing.

 

C++ Modules - Spring Update--Gabriel Dos Reis

By Adrien Hamelin | May 27, 2016 02:35 PM | Tags: experimental efficiency

Let's talk about modules!

C++ Modules - Spring Update

by Gabriel Dos Reis

Abstract

“Modules” are a frequently requested and long-awaited feature by C++ programmers. The basic idea is a direct language support for (a) expressing the boundaries and dependencies of program components; (b) isolating source codes from macro vagaries; (c) scaling compile time, especially for large projects, given the ubiquity of “headers-only” template libraries; (d) spur innovation and deployment of semantics-aware developer tools. I will give an overview of the design points, goals, with emphasis on how modules address the four major problems mentioned above. I will also address standardization process and implementation issues

Jacksonville C++ Core Language Meeting Report--Jason Merrill

By Adrien Hamelin | May 19, 2016 01:30 PM | Tags: experimental

Here are the latest news about the future of C++:

Jacksonville C++ Core Language Meeting Report

by Jason Merrill

From the article:

There were three of us from Red Hat at the C++ meeting in Jacksonville, FL back in February, and it seems I never posted my trip report. So here it is now.

This was a fairly eventful meeting, as we’re rapidly approaching C++17 and so the big question on everyone’s minds was “What’s going to make it in?” In the end, many things did, but not Concepts, which some had been hoping for as a headline item.

We started and finished the week looking at the list of Technical Specifications that we were considering incorporating into C++17...

 

CppCon 2015 Ranges for the Standard Library--Eric Niebler

By Adrien Hamelin | May 11, 2016 01:03 PM | Tags: intermediate experimental

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Ranges for the Standard Library

by Eric Niebler

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Range-based interfaces are functional and composable, and lead to code that is correct by construction. With concepts and ranges coming to the STL, big changes are in store for the Standard Library and for the style of idiomatic C++. The effort to redefine the Standard Library is picking up pace. Come hear about one potential future of the STL from one of the key people driving the change.

juCi++

By Adrien Hamelin | Apr 28, 2016 01:06 PM | Tags: experimental c++14 c++11

juCi++ is a lightweight, platform independent C++-IDE with support for C++11, C++14, and experimental C++17 features depending on libclang version.

juCi++

About:

Current IDEs struggle with C++ support due to the complexity of the programming language. juCI++, however, is designed especially towards libclang with speed and ease of use in mind...

Quick Q:Is it possible in C++ to iterate over a std::map with unpacked key and value?

By Adrien Hamelin | Apr 8, 2016 01:05 PM | Tags: intermediate experimental

Quick A: An easy solution is not supported by the standard, it may come later.

Recently on SO:

Is it possible in C++ to do std::map<> “for element : container” iteration with named variables (eg, key and value) instead of .first and .second?

You could write a class template:

template <class K, class T>
struct MapElem {
    K const& key;
    T& value;

    MapElem(std::pair<K const, T>& pair)
        : key(pair.first)
        , value(pair.second)
    { }
};

with the advantage of being able to write key and value but with the disadvantage of having to specify the types:

for ( MapElem<int, std::string> kv : my_map ){
    std::cout << kv.key << " --> " << kv.value;
}

And that won't work if my_map were const either. You'd have to do something like:

template <class K, class T>
struct MapElem {
    K const& key;
    T& value;

    MapElem(std::pair<K const, T>& pair)
        : key(pair.first)
        , value(pair.second)
    { }

    MapElem(const std::pair<K const, std::remove_const_t<T>>& pair)
        : key(pair.first)
        , value(pair.second)
    { }
};

for ( MapElem<int, const std::string> kv : my_map ){
    std::cout << kv.key << " --> " << kv.value;
}

It's a mess. Best thing for now is to just get used to writing .first and .second and hope that the structured bindings proposal passes, which would allow for what you really want:

for (auto&& [key, value] : my_map) {
    std::cout << key << " --> " << value;
}

Using C++ Coroutines to simplify async UWP code--Eric Mittelette

By Marco Arena | Apr 5, 2016 05:28 AM | Tags: visual studio intermediate experimental

The async pattern needed to write UWP apps (or simply "Universal apps") is not so easy to grasp, especially in C++. Eric from the Visual C++ team explains how the experimental Coroutines feature available in Visual Studio 2015 helps simplify async UWP code:

Using C++ Coroutines to simplify async UWP code

From the article:

C++ Coroutines can simplify your async code, and make the code easy to understand, write, and maintain...