Immer: immutable and persistent data structures for C++

immer is a library of persistent and immutable data structures written in C++.

• Persistent means that when you modify the data structure, the old value is preserved.

• Immutable means that all manipulation methods are const.

  An object is never modified in place but a new value is returned instead. Since the old value is still there and it will never change, the new value can transparently keep references to common parts of it. This property is called structural sharing.

Read the docs

https://sinusoid.es/immer

Check the code

https://github.com/arximboldi/immer

Talks

[Video (7min)][Slides]The tragedy of the value based architecture (MeetingC++ 2016)

Example

#include<immer/vector.hpp>intmain()
{constauto v0 = immer::vector<int>{}constauto v1 = v0.push_back(13);assert(v0.size() == 0&& v1.size() == 1&& v1[0] == 13);constauto v2 = v1.set(0, 42);assert(v1[0] == 13&& v2[0] == 42);
}

Why?

In the last few years, there has been a growing interest in immutable data structures, motivated by the horizontal scaling of our processing power and the ubiquity of highly interactive systems. Languages likeClojure and Scala provide them by default, and implementations for JavaScript like Mori and Immutable.js are widely used, specially in combination with modern UI frameworks like React.

Interactivity

Thanks to persistence and structural sharing, new values can be efficiently compared with old ones. This enables simpler ways ofreasoning about change that sit at the core of modern interactive systems programming paradigms like reactive programming.

Concurrency

Passing immutable data structures by value does not need to copy any data. In the absence of mutation, data can be safely read from multiple concurrent processes, and enable concurrency patterns like share by communicating efficiently.

Parallelism

Some recent immutable data structures have interesting properties like O(log(n)) concatenation, which enable new kinds ofparallelization algorithms.

Goals

Idiomatic

This library doesn't pretend that it is written in Haskell. It leverages features from recent standards to provide an API that is both efficient and natural for a C++ developer.

Performant

You use C++ because you need this. Immer implements state of the art data structures with efficient cache utilization and have been proven production ready in other languages. It also includes our own improvements over that are only possible because of the C++'s ability to abstract over memory layout. We monitor the performance impact of every change by collecting benchmark results directly from CI.

Customizable

We leverage templates and policy-based design to build data-structures that can be adapted to work efficiently for various purposes and architectures, for example, by choosing among various :doc:`memory management strategies<memory>`. This turnsimmer into a good foundation to provide immutable data structures to higher level languages with a C runtime, likePython or Guile.

Dependencies

This library is written in C++14 and a compliant compiler is necessary. It is continuously tested with Clang 3.8 and GCC 6, but it might work with other compilers and versions.

No external library is necessary and there are no other requirements.

Usage

This is a header only library. Just make sure that the project root is in your include path.

Development

One may generate a development project using CMake:

mkdir build && cd build
cmake ..

To automatically fetch and build all depedencies required to build and run the tests and benchmarks run:

make deps

From then on, one may build and run all tests by doing:

make check

In order to build and run all benchmarks when running make check, run cmake again with the option -DCHECK_BENCHMARKS=1. The results of running the benchmarks will be saved to a folderreports/ in the project root.

License

This software is licensed under the GPLv3 license.