Code Explainers

Code explainers tagged #recursion

javascript 
function evaluate(expression) {
  const tokens = tokenize(expression);
  let pos = 0;
 

Building a recursive descent calculator

parsing recursion operator-precedence
Intermediate 8 steps
python 
import functools
import inspect
from typing import get_type_hints, get_origin, get_args, Union
 

A runtime type checker from annotations

decorators runtime-validation type-hints
Advanced 8 steps
java 
public final class MapFlattener {
 
    private MapFlattener() {
    }

Flattening nested maps into dotted keys

recursion tree-traversal data-transformation
Intermediate 7 steps
go 
package flatten
 
import (
	"encoding/json"

Flattening nested JSON into dotted keys

recursion json type-switch
Intermediate 7 steps
rust 
use serde_json::{Map, Value};
 
pub fn merge_config(base: &mut Value, override_with: Value) {
    match (base, override_with) {

Deep-merging JSON config layers in Rust

recursion json pattern-matching
Intermediate 9 steps
ruby 
class Category < ApplicationRecord
  belongs_to :parent, class_name: "Category", optional: true
  has_many :children,
           -> { order(:position) },

Modeling a self-referential category tree in Rails

self-referential-association recursion tree-structure
Intermediate 9 steps
python 
class TrieNode:
    __slots__ = ("children", "is_word")
 
    def __init__(self):

Building a prefix trie in Python

trie tree-traversal recursion
Intermediate 7 steps
javascript 
function flatten(obj, prefix = '', result = {}) {
  for (const [key, value] of Object.entries(obj)) {
    const path = prefix ? `${prefix}.${key}` : key;
 

Flattening nested objects into dotted paths

recursion object-traversal accumulator
Intermediate 6 steps
go 
package trie
 
import "sort"
 

Building a frequency-ranked autocomplete trie in Go

trie autocomplete recursion
Intermediate 9 steps
javascript 
import { useState } from 'react';
 
function TreeNode({ node, depth = 0 }) {
  const [expanded, setExpanded] = useState(depth === 0);

How a recursive file tree renders in React

recursion component-composition local-state
Intermediate 8 steps
ruby 
class WeightedMovingAverageForecaster
  DEFAULT_WINDOW = 5
 
  def initialize(window: DEFAULT_WINDOW, weights: nil)

A weighted moving average forecaster in Ruby

forecasting weighted-average normalization
Intermediate 8 steps
python 
from xml.etree import ElementTree as ET
from xml.dom import minidom
 
 

Converting nested dicts to XML in Python

recursion serialization xml
Intermediate 9 steps
typescript 
type QueryValue = string | number | boolean | null | undefined;
type QueryInput = QueryValue | QueryValue[] | { [key: string]: QueryInput };
 
function buildQueryString(params: Record<string, QueryInput>): string {

Building nested query strings recursively

recursion url-encoding serialization
Intermediate 8 steps
python 
class Parser:
    def __init__(self, text):
        self.tokens = self._tokenize(text)
        self.pos = 0

A recursive descent arithmetic parser

recursive-descent tokenizer operator-precedence
Intermediate 9 steps
rust 
use std::collections::HashMap;
 
#[derive(Clone, Copy, PartialEq)]
enum Color {

Detecting cycles with three-color DFS in Rust

graph-algorithms cycle-detection depth-first-search
Intermediate 9 steps
go 
package logging
 
import (
	"fmt"

Redacting secrets with Go reflection

reflection recursion struct-tags
Advanced 10 steps
typescript 
type Flatten = Record<string, unknown>;
 
function isPlainObject(value: unknown): value is Record<string, unknown> {
  return (

Flattening nested objects into dotted keys

recursion reduce type-guards
Intermediate 7 steps
typescript 
type Masker = (value: string) => string;
 
const maskEmail: Masker = (value) => {
  const [local, domain] = value.split("@");

Recursively masking sensitive data for logs

recursion regex data-masking
Intermediate 9 steps