haskell — Эквивалент экзистенциального количественного определения в C ++?

Чтобы помочь себе в изучении C ++, я работаю над реализацией красно-черного дерева. Приходящий из
Хаскелл, я подумал, что было бы интересно посмотреть, смогу ли я свойства
красно-черное дерево
статически в системе типов C ++:

1. Узел красный или черный.
2. Корень черный […]
3. Все листья (ноль) черные.
4. Если узел красный, то оба его потомка черные.
5. Каждый путь от данного узла к любому из его дочерних узлов NIL содержит
   такое же количество черных узлов. […]

Я выяснил, как создать типы для узлов дерева, чтобы удовлетворить ограничения 1,
3, 4 и 5 с использованием шаблонов:

template <typename Key, typename Value>
class RedBlackTree {
private:
enum class color { Black, Red };

// [1. A node is either red or black]
template <color Color, size_t Height>
struct Node {};

// [3. All leaves are black]
struct Leaf : public Node<color::Black, 0> {};

template <color Left, color Right, size_t ChildHeight>
struct Branch {
public:
template <color ChildColor>
using Child = unique_ptr<Node<ChildColor, ChildHeight>>;

Key key;
Value value;
Child<Left> left;
Child<Right> right;

Branch(Key&& key, Value&& value, Child<Left> left, Child<Right> right) :
key { key }, value { value }, left { left }, right { right } {}
};

// [4. If a node is red, then both its children are black.]
// [5. Every path from a given node to any of its descendant NIL nodes contains
//     the same number of black nodes.]
template <size_t Height>
struct RedBranch: public Node<color::Red, Height>
, public Branch<color::Black, color::Black, Height> {
public:
using RedBlackTree::Branch;
};

// [5. Every path from a given node to any of its descendant NIL nodes contains
//     the same number of black nodes.]
template <size_t Height, color Left, color Right>
struct BlackBranch: public Node<color::Black, Height>
, public Branch<Left, Right, Height-1> {
public:
using RedBlackTree::Branch;
};

// ...
};

Где я в тупике дает root указатель, который будет храниться в RedBlackTree
экземпляр типа, который удовлетворяет свойству 2, но все еще полезен.

Что я хочу, это что-то вроде:

template <typename Key, typename Value>
class RedBlackTree {
//...
unique_ptr<Node<color::Black,?>> root = std::make_unique<Leaf>();
//...
}

(заимствовать синтаксис из Java), так что я могу подстановочный знак по высоте дерева. Это из
Конечно, не работает.

Я мог бы получить свой код для компиляции, если бы я сделал

template <typename Key, typename Value, size_t TreeHeight>
class RedBlackTree {
//...
unique_ptr<Node<color::Black,TreeHeight>> root = std::make_unique<Leaf>();
//...
}

Но это не тот тип дерева, который мне нужен — мне не нужен тип самого дерева.
отражать его высоту, в противном случае тип моего дерева может измениться, когда я вставлю
пара ключ-значение. Я хочу иметь возможность обновить мой root содержать указатель на черный
Node из любой рост.

Вернувшись в Хаскель-Лэнд, я бы решил эту проблему, используя экзистенциальный
квантование:

data Color = Black | Red

data Node (color :: Color) (height :: Nat) key value where
Leaf :: Node 'Black 0 key value
BlackBranch :: Branch left right height key value -> Node 'Black (height+1) key value
RedBranch :: Branch 'Black 'Black height key value -> Node 'Red height key value

data Branch (left :: Color) (right :: Color) (childHeight :: Nat) key value = Branch
{ left  :: Node left childHeight key value
, right :: Node right childHeight key value
, key   :: key
, value :: value
}

data RedBlackTree key value where
RedBlackTree :: { root :: Node 'Black height key value } -> RedBlackTree key value

Есть ли эквивалентная концепция в C ++ 14 (или, может быть, C ++ 17), или альтернативный способ, которым я мог бы написать свой struct определения, чтобы быть в состоянии дать root полезный и правильный тип?