rust 38 lines · 9 steps

Deep-merging JSON config layers in Rust

A recursive merge that combines nested JSON objects, replaces scalars, and deletes keys set to null.

Explained by highlit
Intermediate recursion json pattern-matching configuration mutation
1use serde_json::{Map, Value};
2 
3pub fn merge_config(base: &mut Value, override_with: Value) {
4 match (base, override_with) {
5 (Value::Object(base_map), Value::Object(override_map)) => {
6 merge_objects(base_map, override_map);
7 }
8 (base_slot, other) => {
9 *base_slot = other;
10 }
11 }
12}
13 
14fn merge_objects(base: &mut Map<String, Value>, override_map: Map<String, Value>) {
15 for (key, override_value) in override_map {
16 if override_value.is_null() {
17 base.remove(&key);
18 continue;
19 }
20 
21 match base.get_mut(&key) {
22 Some(existing) if existing.is_object() && override_value.is_object() => {
23 merge_config(existing, override_value);
24 }
25 _ => {
26 base.insert(key, override_value);
27 }
28 }
29 }
30}
31 
32pub fn merge_all(layers: impl IntoIterator<Item = Value>) -> Value {
33 let mut merged = Value::Object(Map::new());
34 for layer in layers {
35 merge_config(&mut merged, layer);
36 }
37 merged
38}
01 / 01
STEP 01

Walkthrough

Space play ←→ step click any line
Three takeaways
  1. 1Recursion plus pattern matching lets you handle nested structures with very little branching code.
  2. 2Using null as a deletion signal makes overrides expressive without a separate remove API.
  3. 3Folding layers over a mutable accumulator gives clean last-wins precedence for stacked config.

Related explainers

rust 
use serde::Deserialize;
 
#[derive(Debug, Deserialize)]
#[serde(untagged)]

Parsing flexible JSON shapes with serde

deserialization enums json
Intermediate 6 steps
typescript 
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import * as Joi from 'joi';
 

Validating env config at boot in NestJS

configuration schema-validation environment-variables
Intermediate 8 steps
rust 
use std::cmp::{Ordering, Reverse};
use std::collections::BinaryHeap;
use std::fs::File;
use std::io::{self, BufRead, BufReader, BufWriter, Lines, Write};

K-way merge of sorted logs in Rust

binary-heap k-way-merge streaming-io
Intermediate 8 steps
ruby 
class UserAgentParser
  BROWSERS = [
    [/Edg\/([\d.]+)/, "Edge"],
    [/OPR\/([\d.]+)/, "Opera"],

Parsing user-agent strings in Ruby

regex pattern-matching lookup-tables
Intermediate 8 steps
javascript 
function evaluate(expression) {
  const tokens = tokenize(expression);
  let pos = 0;
 

Building a recursive descent calculator

parsing recursion operator-precedence
Intermediate 8 steps
rust 
use axum::{
    extract::{Path, State},
    response::sse::{Event, KeepAlive, Sse},
};

Streaming import progress with SSE in Axum

server-sent-events streams watch-channel
Advanced 7 steps

Share this explainer

Here's the card — post it anywhere.

Deep-merging JSON config layers in Rust — share card
Made with highlit — turn any snippet into a walkthrough like this in about a minute.
Explain your code