::iterator>::iterator it;
##
## it = radix.prefix_match("tur");
##
## if(it == vec.end()){
## printf("No match was found :(");
## } else {
## for (it = vec.begin(); it != vec.end(); ++it) {
## std::string result = "Key of a prefix match: " + it->first + " , value of a prefix match: " + it->second;
## }
## }
triebeard/inst/doc/r_radix.R 0000644 0001762 0000144 00000005522 14400735316 015517 0 ustar ligges users ## ---- eval=FALSE--------------------------------------------------------------
# labels <- c("AO-1002", "AEO-1004", "AAI-1009", "AFT-1403", "QZ-9065", "QZ-1021", "RF-0901",
# "AO-1099", "AFT-1101", "QZ-4933")
## ---- eval=FALSE--------------------------------------------------------------
# library(triebeard)
# trie <- trie(keys = c("AO", "AEO", "AAI", "AFT", "QZ", "RF"),
# values = c("Audobon", "Atlanta", "Ann Arbor", "Austin", "Queensland", "Raleigh"))
#
# longest_match(trie = trie, to_match = labels)
#
# [1] "Audobon" "Atlanta" "Ann Arbor" "Austin" "Queensland" "Queensland" "Raleigh" "Audobon" "Austin"
# [10] "Queensland"
## ---- eval=FALSE--------------------------------------------------------------
# prefix_match(trie = trie, to_match = "A")
#
# [[1]]
# [1] "Ann Arbor" "Atlanta" "Austin" "Audobon"
## ---- eval=FALSE--------------------------------------------------------------
# greedy_match(trie = trie, to_match = "AO")
#
# [[1]]
# [1] "Ann Arbor" "Atlanta" "Austin" "Audobon"
## ---- eval=FALSE--------------------------------------------------------------
# library(triebeard)
# library(microbenchmark)
#
# trie <- trie(keys = c("AO", "AEO", "AAI", "AFT", "QZ", "RF"),
# values = c("Audobon", "Atlanta", "Ann Arbor", "Austin", "Queensland", "Raleigh"))
#
# labels <- rep(c("AO-1002", "AEO-1004", "AAI-1009", "AFT-1403", "QZ-9065", "QZ-1021", "RF-0901",
# "AO-1099", "AFT-1101", "QZ-4933"), 100000)
#
# microbenchmark({longest_match(trie = trie, to_match = labels)})
#
# Unit: milliseconds
# expr min lq mean median uq max neval
# { longest_match(trie = trie, to_match = labels) } 284.6457 285.5902 289.5342 286.8775 288.4564 327.3878 100
## ---- eval=FALSE--------------------------------------------------------------
# to_match = "198.0.0.1"
# trie_inst <- trie(keys = "197", values = "fake range")
#
# longest_match(trie_inst, to_match)
# [1] NA
#
# trie_add(trie_inst, keys = "198", values = "home range")
# longest_match(trie_inst, to_match)
# [1] "home range"
#
# trie_remove(trie_inst, keys = "198")
# longest_match(trie_inst, to_match)
# [1] NA
## ---- eval=FALSE--------------------------------------------------------------
# trie <- trie(keys = c("AO", "AEO", "AAI", "AFT", "QZ", "RF"),
# values = c("Audobon", "Atlanta", "Ann Arbor", "Austin", "Queensland", "Raleigh"))
#
# str(as.data.frame(trie))
# 'data.frame': 6 obs. of 2 variables:
# $ keys : chr "AAI" "AEO" "AFT" "AO" ...
# $ values: chr "Ann Arbor" "Atlanta" "Austin" "Audobon" ...
#
# str(as.list(trie))
#
# List of 2
# $ keys : chr [1:6] "AAI" "AEO" "AFT" "AO" ...
# $ values: chr [1:6] "Ann Arbor" "Atlanta" "Austin" "Audobon" ...
triebeard/inst/doc/rcpp_radix.html 0000644 0001762 0000144 00000043507 14400735317 016773 0 ustar ligges users
Radix trees in Rcpp
Radix trees in Rcpp
Oliver Keyes
2023-03-04
A radix tree is a data structure optimised for
storing key-value pairs in a way optimised for searching. This makes
them very, very good for efficiently matching data against keys, and
retrieving the values associated with those keys.
triebeard provides an implementation of radix trees for
Rcpp (and also for use directly in R). To start using radix trees in
your Rcpp development, simply modify your C++ file to include at the
top:
//[[Rcpp::depends(triebeard)]]
#include <radix.h>
Constructing trees
Trees are constructed using the syntax:
radix_tree<type1, type2> radix;
Where type represents the type of the keys (for example,
std::string) and type2 the type of the
values.
Radix trees can have any scalar type as keys, although strings are
most typical; they can also have any scalar type for values. Once you’ve
constructed a tree, new entries can be added in a very R-like way:
radix[new_key] = new_value;. Entries can also be removed,
with radix.erase(key).
Matching against trees
We then move on to the fun bit: matching! As mentioned, radix trees
are really good for matching arbitrary values against keys (well, keys
of the same type) and retrieving the associated values.
There are three types of supported matching; longest, prefix, and
greedy. Longest does exactly what it says on the tin: it finds the
key-value pair where the longest initial part of the key matches the
arbitrary value:
radix_tree<std::string, std::string> radix;
radix["turnin"] = "entry the first";
radix["turin"] = "entry the second";
radix_tree<std::string, std::string>::iterator it;
it = radix.longest_match("turing");
if(it = radix.end()){
printf("No match was found :(");
} else {
std::string result = "Key of longest match: " + it->first + " , value of longest match: " + it->second;
}
Prefix matching provides all trie entries where the value-to-match is
a prefix of the key:
radix_tree<std::string, std::string> radix;
radix["turnin"] = "entry the first";
radix["turin"] = "entry the second";
std::vector<radix_tree<std::string, std::string>::iterator> vec;
std::vector<radix_tree<std::string, std::string>::iterator>::iterator it;
it = radix.prefix_match("tur");
if(it == vec.end()){
printf("No match was found :(");
} else {
for (it = vec.begin(); it != vec.end(); ++it) {
std::string result = "Key of a prefix match: " + it->first + " , value of a prefix match: " + it->second;
}
}
Greedy matching matches very, very fuzzily (a value of ‘bring’, for
example, will match ‘blind’, ‘bind’ and ‘binary’) and, syntactically,
looks exactly the same as prefix-matching, albeit with
radix.greedy_match() instead of
radix.prefix_match().
Other trie things
If you have ideas for other trie-like structures, or functions that
would be useful with these tries, the best approach is to
either request
it or add
it!
triebeard/inst/doc/r_radix.html 0000644 0001762 0000144 00000060206 14400735316 016262 0 ustar ligges users
Radix trees in R
Radix trees in R
Oliver Keyes
2023-03-04
A radix tree, or trie, is a data
structure optimised for storing key-value pairs in a way optimised for
searching. This makes them very, very good for efficiently matching data
against keys, and retrieving the values associated with those
keys.
triebeard provides an implementation of tries for R (and
one that can be used in Rcpp development, too, if that’s your thing) so
that useRs can take advantage of the fast, efficient and user-friendly
matching that they allow.
Radix usage
Suppose we have observations in a dataset that are labelled, with a
2-3 letter code that identifies the facility the sample came from:
labels <- c("AO-1002", "AEO-1004", "AAI-1009", "AFT-1403", "QZ-9065", "QZ-1021", "RF-0901",
"AO-1099", "AFT-1101", "QZ-4933")
We know the facility each code maps to, and we want to be able to map
the labels to that - not over 10 entries but over hundreds, or
thousands, or hundreds of thousands. Tries are a great way of
doing that: we treat the codes as keys and the full facility
names as values. So let’s make a trie to do this matching, and
then, well, match:
library(triebeard)
trie <- trie(keys = c("AO", "AEO", "AAI", "AFT", "QZ", "RF"),
values = c("Audobon", "Atlanta", "Ann Arbor", "Austin", "Queensland", "Raleigh"))
longest_match(trie = trie, to_match = labels)
[1] "Audobon" "Atlanta" "Ann Arbor" "Austin" "Queensland" "Queensland" "Raleigh" "Audobon" "Austin"
[10] "Queensland"
This pulls out, for each label, the trie value where the associated
key has the longest prefix-match to the label. We can also just grab all
the values where the key starts with, say, A:
prefix_match(trie = trie, to_match = "A")
[[1]]
[1] "Ann Arbor" "Atlanta" "Austin" "Audobon"
And finally if we want we can match very, very fuzzily using “greedy”
matching:
greedy_match(trie = trie, to_match = "AO")
[[1]]
[1] "Ann Arbor" "Atlanta" "Austin" "Audobon"
These operations are very, very efficient. If we use longest-match as
an example, since that’s the most useful thing, with a one-million
element vector of things to match against:
library(triebeard)
library(microbenchmark)
trie <- trie(keys = c("AO", "AEO", "AAI", "AFT", "QZ", "RF"),
values = c("Audobon", "Atlanta", "Ann Arbor", "Austin", "Queensland", "Raleigh"))
labels <- rep(c("AO-1002", "AEO-1004", "AAI-1009", "AFT-1403", "QZ-9065", "QZ-1021", "RF-0901",
"AO-1099", "AFT-1101", "QZ-4933"), 100000)
microbenchmark({longest_match(trie = trie, to_match = labels)})
Unit: milliseconds
expr min lq mean median uq max neval
{ longest_match(trie = trie, to_match = labels) } 284.6457 285.5902 289.5342 286.8775 288.4564 327.3878 100
I think we can call <300 milliseconds for a million matches
against an entire set of possible values pretty fast.
Radix modification
There’s always the possibility that (horror of horrors) you’ll have
to add or remove entries from the trie. Fear not; you can do just that
with trie_add and trie_remove respectively,
both of which silently modify the trie they’re provided with to add or
remove whatever key-value pairs you provide:
to_match = "198.0.0.1"
trie_inst <- trie(keys = "197", values = "fake range")
longest_match(trie_inst, to_match)
[1] NA
trie_add(trie_inst, keys = "198", values = "home range")
longest_match(trie_inst, to_match)
[1] "home range"
trie_remove(trie_inst, keys = "198")
longest_match(trie_inst, to_match)
[1] NA
triebeard/inst/doc/r_radix.Rmd 0000644 0001762 0000144 00000011737 14377436506 016061 0 ustar ligges users ---
title: "Radix trees in R"
author: "Oliver Keyes"
date: "`r Sys.Date()`"
output: rmarkdown::html_vignette
vignette: >
%\VignetteIndexEntry{Radix trees in R}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
A **radix tree**, or **trie**, is a data structure optimised for storing key-value pairs in a way optimised for searching. This makes them very, very good for efficiently matching data against keys, and retrieving the values *associated* with those keys.
`triebeard` provides an implementation of tries for R (and one that can be used in Rcpp development, too, if that's your thing) so that useRs can take advantage of the fast, efficient and user-friendly matching that they allow.
## Radix usage
Suppose we have observations in a dataset that are labelled, with a 2-3 letter code that identifies the facility the sample came from:
```{r, eval=FALSE}
labels <- c("AO-1002", "AEO-1004", "AAI-1009", "AFT-1403", "QZ-9065", "QZ-1021", "RF-0901",
"AO-1099", "AFT-1101", "QZ-4933")
```
We know the facility each code maps to, and we want to be able to map the labels to that - not over 10 entries but over hundreds, or thousands, or hundreds *of* thousands. Tries are a great way of doing that: we treat the codes as *keys* and the full facility names as *values*. So let's make a trie to do this matching, and then, well, match:
```{r, eval=FALSE}
library(triebeard)
trie <- trie(keys = c("AO", "AEO", "AAI", "AFT", "QZ", "RF"),
values = c("Audobon", "Atlanta", "Ann Arbor", "Austin", "Queensland", "Raleigh"))
longest_match(trie = trie, to_match = labels)
[1] "Audobon" "Atlanta" "Ann Arbor" "Austin" "Queensland" "Queensland" "Raleigh" "Audobon" "Austin"
[10] "Queensland"
```
This pulls out, for each label, the trie value where the associated key has the longest prefix-match to the label. We can also just grab all the values where the key starts with, say, A:
```{r, eval=FALSE}
prefix_match(trie = trie, to_match = "A")
[[1]]
[1] "Ann Arbor" "Atlanta" "Austin" "Audobon"
```
And finally if we want we can match very, very fuzzily using "greedy" matching:
```{r, eval=FALSE}
greedy_match(trie = trie, to_match = "AO")
[[1]]
[1] "Ann Arbor" "Atlanta" "Austin" "Audobon"
```
These operations are very, very efficient. If we use longest-match as an example, since that's the most useful thing, with a one-million element vector of things to match against:
```{r, eval=FALSE}
library(triebeard)
library(microbenchmark)
trie <- trie(keys = c("AO", "AEO", "AAI", "AFT", "QZ", "RF"),
values = c("Audobon", "Atlanta", "Ann Arbor", "Austin", "Queensland", "Raleigh"))
labels <- rep(c("AO-1002", "AEO-1004", "AAI-1009", "AFT-1403", "QZ-9065", "QZ-1021", "RF-0901",
"AO-1099", "AFT-1101", "QZ-4933"), 100000)
microbenchmark({longest_match(trie = trie, to_match = labels)})
Unit: milliseconds
expr min lq mean median uq max neval
{ longest_match(trie = trie, to_match = labels) } 284.6457 285.5902 289.5342 286.8775 288.4564 327.3878 100
```
I think we can call <300 milliseconds for a million matches against an entire set of possible values pretty fast.
## Radix modification
There's always the possibility that (horror of horrors) you'll have to add or remove entries from the trie. Fear not; you can do just that with `trie_add` and `trie_remove` respectively, both of which silently modify the trie they're provided with to add or remove whatever key-value pairs you provide:
```{r, eval=FALSE}
to_match = "198.0.0.1"
trie_inst <- trie(keys = "197", values = "fake range")
longest_match(trie_inst, to_match)
[1] NA
trie_add(trie_inst, keys = "198", values = "home range")
longest_match(trie_inst, to_match)
[1] "home range"
trie_remove(trie_inst, keys = "198")
longest_match(trie_inst, to_match)
[1] NA
```
## Metadata and coercion
You can also extract information from tries without using them. `dim`, `str`, `print` and `length` all work for tries, and you can use `get_keys(trie)` and `get_values(trie)` to extract, respectively, the keys and values from a trie object.
In addition, you can also coerce tries into other R data structures, specifically lists and data.frames:
```{r, eval=FALSE}
trie <- trie(keys = c("AO", "AEO", "AAI", "AFT", "QZ", "RF"),
values = c("Audobon", "Atlanta", "Ann Arbor", "Austin", "Queensland", "Raleigh"))
str(as.data.frame(trie))
'data.frame': 6 obs. of 2 variables:
$ keys : chr "AAI" "AEO" "AFT" "AO" ...
$ values: chr "Ann Arbor" "Atlanta" "Austin" "Audobon" ...
str(as.list(trie))
List of 2
$ keys : chr [1:6] "AAI" "AEO" "AFT" "AO" ...
$ values: chr [1:6] "Ann Arbor" "Atlanta" "Austin" "Audobon" ...
```
### Other trie operations
If you have ideas for other trie-like structures, or functions that would be useful with *these* tries, the best approach
is to either [request it](https://github.com/Ironholds/triebeard/issues) or [add it](https://github.com/Ironholds/triebeard/pulls)!
triebeard/inst/include/ 0000755 0001762 0000144 00000000000 14377436506 014632 5 ustar ligges users triebeard/inst/include/radix/ 0000755 0001762 0000144 00000000000 14400752177 015731 5 ustar ligges users triebeard/inst/include/radix/radix_tree.hpp 0000644 0001762 0000144 00000030174 14377436506 020605 0 ustar ligges users #ifndef RADIX_TREE_HPP
#define RADIX_TREE_HPP
#include
#include
#include
#include
#include "radix_tree_it.hpp"
#include "radix_tree_node.hpp"
template
K radix_substr(const K &key, int begin, int num);
template<>
inline std::string radix_substr(const std::string &key, int begin, int num)
{
return key.substr(begin, num);
}
template
K radix_join(const K &key1, const K &key2);
template<>
inline std::string radix_join(const std::string &key1, const std::string &key2)
{
return key1 + key2;
}
template
int radix_length(const K &key);
template<>
inline int radix_length(const std::string &key)
{
return key.size();
}
template
class radix_tree {
public:
typedef K key_type;
typedef T mapped_type;
typedef std::pair value_type;
typedef radix_tree_it iterator;
typedef std::size_t size_type;
radix_tree() : m_size(0), m_root(NULL) { }
~radix_tree() {
delete m_root;
}
size_type size() const {
return m_size;
}
bool empty() const {
return m_size == 0;
}
void clear() {
delete m_root;
m_root = NULL;
m_size = 0;
}
iterator find(const K &key);
iterator begin();
iterator end();
std::pair insert(const value_type &val);
bool erase(const K &key);
void erase(iterator it);
void prefix_match(const K &key, std::vector &vec);
void greedy_match(const K &key, std::vector &vec);
iterator longest_match(const K &key);
T& operator[] (const K &lhs);
private:
size_type m_size;
radix_tree_node* m_root;
radix_tree_node* begin(radix_tree_node *node);
radix_tree_node* find_node(const K &key, radix_tree_node *node, int depth);
radix_tree_node* append(radix_tree_node *parent, const value_type &val);
radix_tree_node* prepend(radix_tree_node *node, const value_type &val);
void greedy_match(radix_tree_node *node, std::vector &vec);
radix_tree(const radix_tree& other); // delete
radix_tree& operator =(const radix_tree other); // delete
};
template
void radix_tree::prefix_match(const K &key, std::vector &vec)
{
vec.clear();
if (m_root == NULL)
return;
radix_tree_node *node;
K key_sub1, key_sub2;
node = find_node(key, m_root, 0);
if (node->m_is_leaf)
node = node->m_parent;
int len = radix_length(key) - node->m_depth;
key_sub1 = radix_substr(key, node->m_depth, len);
key_sub2 = radix_substr(node->m_key, 0, len);
if (key_sub1 != key_sub2)
return;
greedy_match(node, vec);
}
template
typename radix_tree::iterator radix_tree::longest_match(const K &key)
{
if (m_root == NULL)
return iterator(NULL);
radix_tree_node *node;
K key_sub;
node = find_node(key, m_root, 0);
if (node->m_is_leaf)
return iterator(node);
key_sub = radix_substr(key, node->m_depth, radix_length(node->m_key));
if (! (key_sub == node->m_key))
node = node->m_parent;
K nul = radix_substr(key, 0, 0);
while (node != NULL) {
typename radix_tree_node::it_child it;
it = node->m_children.find(nul);
if (it != node->m_children.end() && it->second->m_is_leaf)
return iterator(it->second);
node = node->m_parent;
}
return iterator(NULL);
}
template
typename radix_tree::iterator radix_tree::end()
{
return iterator(NULL);
}
template
typename radix_tree::iterator radix_tree::begin()
{
radix_tree_node *node;
if (m_root == NULL)
node = NULL;
else
node = begin(m_root);
return iterator(node);
}
template
radix_tree_node* radix_tree::begin(radix_tree_node *node)
{
if (node->m_is_leaf)
return node;
assert(!node->m_children.empty());
return begin(node->m_children.begin()->second);
}
template
T& radix_tree::operator[] (const K &lhs)
{
iterator it = find(lhs);
if (it == end()) {
std::pair val;
val.first = lhs;
std::pair ret;
ret = insert(val);
assert(ret.second == true);
it = ret.first;
}
return it->second;
}
template
void radix_tree::greedy_match(const K &key, std::vector &vec)
{
radix_tree_node *node;
vec.clear();
if (m_root == NULL)
return;
node = find_node(key, m_root, 0);
if (node->m_is_leaf)
node = node->m_parent;
greedy_match(node, vec);
}
template
void radix_tree::greedy_match(radix_tree_node *node, std::vector &vec)
{
if (node->m_is_leaf) {
vec.push_back(iterator(node));
return;
}
typename std::map*>::iterator it;
for (it = node->m_children.begin(); it != node->m_children.end(); ++it) {
greedy_match(it->second, vec);
}
}
template
void radix_tree::erase(iterator it)
{
erase(it->first);
}
template
bool radix_tree::erase(const K &key)
{
if (m_root == NULL)
return 0;
radix_tree_node *child;
radix_tree_node *parent;
radix_tree_node *grandparent;
K nul = radix_substr(key, 0, 0);
child = find_node(key, m_root, 0);
if (! child->m_is_leaf)
return 0;
parent = child->m_parent;
parent->m_children.erase(nul);
delete child;
m_size--;
if (parent == m_root)
return 1;
if (parent->m_children.size() > 1)
return 1;
if (parent->m_children.empty()) {
grandparent = parent->m_parent;
grandparent->m_children.erase(parent->m_key);
delete parent;
} else {
grandparent = parent;
}
if (grandparent == m_root) {
return 1;
}
if (grandparent->m_children.size() == 1) {
// merge grandparent with the uncle
typename std::map*>::iterator it;
it = grandparent->m_children.begin();
radix_tree_node *uncle = it->second;
if (uncle->m_is_leaf)
return 1;
uncle->m_depth = grandparent->m_depth;
uncle->m_key = radix_join(grandparent->m_key, uncle->m_key);
uncle->m_parent = grandparent->m_parent;
grandparent->m_children.erase(it);
grandparent->m_parent->m_children.erase(grandparent->m_key);
grandparent->m_parent->m_children[uncle->m_key] = uncle;
delete grandparent;
}
return 1;
}
template
radix_tree_node* radix_tree::append(radix_tree_node *parent, const value_type &val)
{
int depth;
int len;
K nul = radix_substr(val.first, 0, 0);
radix_tree_node *node_c, *node_cc;
depth = parent->m_depth + radix_length(parent->m_key);
len = radix_length(val.first) - depth;
if (len == 0) {
node_c = new radix_tree_node(val);
node_c->m_depth = depth;
node_c->m_parent = parent;
node_c->m_key = nul;
node_c->m_is_leaf = true;
parent->m_children[nul] = node_c;
return node_c;
} else {
node_c = new radix_tree_node(val);
K key_sub = radix_substr(val.first, depth, len);
parent->m_children[key_sub] = node_c;
node_c->m_depth = depth;
node_c->m_parent = parent;
node_c->m_key = key_sub;
node_cc = new radix_tree_node(val);
node_c->m_children[nul] = node_cc;
node_cc->m_depth = depth + len;
node_cc->m_parent = node_c;
node_cc->m_key = nul;
node_cc->m_is_leaf = true;
return node_cc;
}
}
template
radix_tree_node* radix_tree::prepend(radix_tree_node *node, const value_type &val)
{
int count;
int len1, len2;
len1 = radix_length(node->m_key);
len2 = radix_length(val.first) - node->m_depth;
for (count = 0; count < len1 && count < len2; count++) {
if (! (node->m_key[count] == val.first[count + node->m_depth]) )
break;
}
assert(count != 0);
node->m_parent->m_children.erase(node->m_key);
radix_tree_node *node_a = new radix_tree_node;
node_a->m_parent = node->m_parent;
node_a->m_key = radix_substr(node->m_key, 0, count);
node_a->m_depth = node->m_depth;
node_a->m_parent->m_children[node_a->m_key] = node_a;
node->m_depth += count;
node->m_parent = node_a;
node->m_key = radix_substr(node->m_key, count, len1 - count);
node->m_parent->m_children[node->m_key] = node;
K nul = radix_substr(val.first, 0, 0);
if (count == len2) {
radix_tree_node *node_b;
node_b = new radix_tree_node(val);
node_b->m_parent = node_a;
node_b->m_key = nul;
node_b->m_depth = node_a->m_depth + count;
node_b->m_is_leaf = true;
node_b->m_parent->m_children[nul] = node_b;
return node_b;
} else {
radix_tree_node *node_b, *node_c;
node_b = new radix_tree_node;
node_b->m_parent = node_a;
node_b->m_depth = node->m_depth;
node_b->m_key = radix_substr(val.first, node_b->m_depth, len2 - count);
node_b->m_parent->m_children[node_b->m_key] = node_b;
node_c = new radix_tree_node(val);
node_c->m_parent = node_b;
node_c->m_depth = radix_length(val.first);
node_c->m_key = nul;
node_c->m_is_leaf = true;
node_c->m_parent->m_children[nul] = node_c;
return node_c;
}
}
template
std::pair::iterator, bool> radix_tree::insert(const value_type &val)
{
if (m_root == NULL) {
K nul = radix_substr(val.first, 0, 0);
m_root = new radix_tree_node;
m_root->m_key = nul;
}
radix_tree_node *node = find_node(val.first, m_root, 0);
if (node->m_is_leaf) {
return std::pair(node, false);
} else if (node == m_root) {
m_size++;
return std::pair(append(m_root, val), true);
} else {
m_size++;
int len = radix_length(node->m_key);
K key_sub = radix_substr(val.first, node->m_depth, len);
if (key_sub == node->m_key) {
return std::pair(append(node, val), true);
} else {
return std::pair