wcfs: xbtree: blib += RangedMap, RangedKeySet

RangedMap is Key->VALUE map with adjacent keys mapped to the same value coalesced into Ranges.
RangedKeySet is set of Keys with adjacent keys coalesced into Ranges.

This data structures will be needed for ΔBtail.

For now the implementation is simple since it keeps whole map in a
linear slice because both RangedMap and RangedKeySet will be used in
ΔBtail to keep something proportional to δ of a change, which is assumed
to be small or medium most of the time.

Some preliminary history:

kirr/wendelin.core@6ea5920a    X xbtree: Less copy/garbage in RangedKeySet ops
kirr/wendelin.core@3ecacd99    X need to keep Value first so that sizeof(set-entry) = sizeof(KeyRange)
kirr/wendelin.core@a5b9b19b    X SetRange draftly works
kirr/wendelin.core@ed2de0de    X Tests for Get
kirr/wendelin.core@3b7b69e6    X fixes for empty set/range
kirr/wendelin.core@6972f999    X xbtree/blib: RangedMap, RangedSet += IntersectsRange, Intersection
kirr/wendelin.core@57be0126    X RangedMap - like RangedSet but for dict

wcfs/internal/xbtree/blib/gen-rangemap

+#!/bin/bash -e
+# rangemap.go.in -> specialized with concrete types
+# gen-rangemap TYPE VALUE out
+
+# Copyright (C) 2018-2021  Nexedi SA and Contributors.
+#                          Kirill Smelkov <kirr@nexedi.com>
+#
+# This program is free software: you can Use, Study, Modify and Redistribute
+# it under the terms of the GNU General Public License version 3, or (at your
+# option) any later version, as published by the Free Software Foundation.
+#
+# You can also Link and Combine this program with other software covered by
+# the terms of any of the Free Software licenses or any of the Open Source
+# Initiative approved licenses and Convey the resulting work. Corresponding
+# source of such a combination shall include the source code for all other
+# software used.
+#
+# This program is distributed WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See COPYING file for full licensing terms.
+# See https://www.nexedi.com/licensing for rationale and options.
+
+TYPE=$1
+VALUE=$2
+out=$3
+
+input=$(dirname $0)/rangemap.go.in
+blib=$(cd $(dirname $0) && go list) # fullpath for blib package
+curr=$(go list)                     # ----//----   current package
+pkgname=$(go list -f {{.Name}})     # name of current package
+
+echo "// Code generated by gen-rangemap $TYPE $VALUE; DO NOT EDIT." >$out
+echo >>$out
+
+# fiximports adjusts rangemap.go code to work outside of blib packages.
+fiximports() {
+	if [ "$curr" == "$blib" ]; then
+		cat
+		return
+	fi
+
+	sed	\
+		-e "/package blib/a \\\\nimport \"$blib\"\\n"	\
+		-e "s/package blib/package $pkgname/g"	\
+		-e 's/\([^\w.]\)KeyRange\b/\1blib.KeyRange/g'	\
+		-e 's/\bKStr\b/blib.KStr/g'
+}
+
+sed	\
+	-e "s/VALUE/$VALUE/g"		\
+	-e "s/\bRangedMap\b/${TYPE}/g"			\
+	-e "s/\bRangedMapEntry\b/${TYPE}Entry/g"		\
+	-e "s/\bvInsert\b/vInsert_${TYPE}/g"		\
+	-e "s/\bvDeleteSlice\b/vDeleteSlice_${TYPE}/g"	\
+	-e "s/\bvReplaceSlice\b/vReplaceSlice_${TYPE}/g"\
+	-e "s/\btraceRangeMap\b/trace${TYPE}/g"		\
+	-e "s/\bdebugRangeMap\b/debug${TYPE}/g"		\
+	-e "s/\bdebugfRMap\b/debugf${TYPE}/g"		\
+	$input |fiximports >>$out

wcfs/internal/xbtree/blib/rangemap.go.in

+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+// map [lo,hi) Key ranges to values.
+
+import (
+	"fmt"
+	"sort"
+)
+
+const traceRangeMap = false
+const debugRangeMap = false
+
+// RangedMap is Key->VALUE map with adjacent keys mapped to the same value coalesced into Ranges.
+//
+// Zero value represents empty map.
+type RangedMap struct {
+	// TODO rework to use BTree lo->hi_ instead if in practice in treediff,
+	// and other usage places, N(ranges) turns out to be not small
+	// (i.e. performance turns out to be not acceptable)
+	entryv []RangedMapEntry // lo↑
+}
+
+// RangedMapEntry represents one entry in RangedMap.
+type RangedMapEntry struct {
+	Value    VALUE
+	KeyRange
+}
+
+
+// Get returns value associated with key k.
+//
+// KeyRange indicates all keys adjacent to k, that are too mapped to the same value.
+func (M *RangedMap) Get(k Key) (VALUE, KeyRange) {
+	v, r, _ := M.Get_(k)
+	return v, r
+}
+
+// Set changes M to map key k to value v.
+func (M *RangedMap) Set(k Key, v VALUE) {
+	M.SetRange(KeyRange{Lo: k, Hi_: k}, v)
+}
+
+// Del removes key k.
+func (M *RangedMap) Del(k Key) {
+	M.DelRange(KeyRange{Lo: k, Hi_: k})
+}
+
+// Has returns whether key k is present in the map.
+func (M *RangedMap) Has(k Key) bool {
+	_, _, ok := M.Get_(k)
+	return ok
+}
+
+
+
+// Get_ is comma-ok version of Get.
+func (M *RangedMap) Get_(k Key) (v VALUE, r KeyRange, ok bool) {
+	r = KeyRange{0,-1} // zero value represents non-empty [0,1)
+	if traceRangeMap {
+		fmt.Printf("\n\nGet_:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  k: %s\n", KStr(k))
+		defer func() {
+			fmt.Printf("->·: %v%s, %t\n", v, r, ok)
+		}()
+	}
+
+	M.verify()
+
+	// find first ilo: k < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		return k <= M.entryv[i].Hi_
+	})
+	debugfRMap("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return
+	}
+
+	e := M.entryv[ilo]
+	if !(e.Lo <= k) { // not found
+		return
+	}
+
+	// found
+	return e.Value, e.KeyRange, true
+}
+
+// SetRange changes M to map key range r to value v.
+func (M *RangedMap) SetRange(r KeyRange, v VALUE) {
+	e := RangedMapEntry{v,r}
+	if traceRangeMap {
+		fmt.Printf("\n\nSetRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  e: %s\n", e)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	// clear range for r and insert new entry
+	// TODO optimize for same-value/set case (just merge all covered
+	// entries into one - see commented AddRange from set vvv)
+	i := M.delRange(r)
+	vInsert(&M.entryv, i, e)
+	debugfRMap("\tinsert %s\t-> %s\n", e, M)
+
+	// check if we should merge inserted entry with right/left neighbours
+	if i+1 < len(M.entryv) { // right
+		x     := M.entryv[i]
+		right := M.entryv[i+1]
+		if (x.Hi_+1 == right.Lo) && (v == right.Value) {
+			vReplaceSlice(&M.entryv, i,i+2,
+				RangedMapEntry{v, KeyRange{x.Lo, right.Hi_}})
+			debugfRMap("\tmerge right\t-> %s\n", M)
+		}
+	}
+
+	if i > 0 { // left
+		left := M.entryv[i-1]
+		x    := M.entryv[i]
+		if (left.Hi_+1 == x.Lo) && (left.Value == v) {
+			vReplaceSlice(&M.entryv, i-1,i+1,
+				RangedMapEntry{v, KeyRange{left.Lo, x.Hi_}})
+			debugfRMap("\tmerge left\t-> %s\n", M)
+		}
+	}
+
+	// done
+
+/* how it was for just set:
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(S.rangev)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= S.rangev[i].Hi_
+	})
+	debugfRSet("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		S.rangev = append(S.rangev, r)
+		l++
+		debugfRSet("\tappend %s\t-> %s\n", r, S)
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if S.rangev[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugfRSet("\tjhi: %d\n", jhi)
+
+	// entries in [ilo:jhi) ∈ [r.Lo,r.hi) and should be merged into one
+	if (jhi - ilo) > 1 {
+		lo  := S.rangev[ilo].Lo
+		hi_ := S.rangev[jhi-1].Hi_
+		vReplaceSlice(&S.rangev, ilo,jhi, KeyRange{lo,hi_})
+		debugfRSet("\tmerge S[%d:%d]\t-> %s\n", ilo, jhi, S)
+	}
+	jhi = -1 // no longer valid
+
+	// if [r.lo,r.hi) was outside of any entry - create new entry
+	if r.Hi_ < S.rangev[ilo].Lo {
+		vInsert(&S.rangev, ilo, r)
+		debugfRSet("\tinsert %s\t-> %s\n", r, S)
+	}
+
+	// now we have covered entries merged as needed into [ilo]
+	// extend this entry if r coverage is wider
+	if r.Lo < S.rangev[ilo].Lo {
+		S.rangev[ilo].Lo = r.Lo
+		debugfRSet("\textend left\t-> %s\n", S)
+	}
+	if r.Hi_ > S.rangev[ilo].Hi_ {
+		S.rangev[ilo].Hi_ = r.Hi_
+		debugfRSet("\textend right\t-> %s\n", S)
+	}
+
+	// and check if we should merge it with right/left neighbours
+	if ilo+1 < len(S.rangev) { // right
+		if S.rangev[ilo].Hi_+1 == S.rangev[ilo+1].Lo {
+			vReplaceSlice(&S.rangev, ilo,ilo+2,
+				KeyRange{S.rangev[ilo].Lo, S.rangev[ilo+1].Hi_})
+			debugfRSet("\tmerge right\t-> %s\n", S)
+		}
+	}
+
+	if ilo > 0 { // left
+		if S.rangev[ilo-1].Hi_+1 == S.rangev[ilo].Lo {
+			vReplaceSlice(&S.rangev, ilo-1,ilo+1,
+				KeyRange{S.rangev[ilo-1].Lo, S.rangev[ilo].Hi_})
+			debugfRSet("\tmerge left\t-> %s\n", S)
+		}
+	}
+
+	// done
+*/
+}
+
+// DelRange removes range r from the map.
+func (M *RangedMap) DelRange(r KeyRange) {
+	if traceRangeMap {
+		fmt.Printf("\n\nDelRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	M.delRange(r)
+}
+
+// delRange deletes range r from the map and returns .entryv index where r
+// should be inserted/appended if needed.
+//
+// r must be !empty.
+func (M *RangedMap) delRange(r KeyRange) (i int) {
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugfRMap("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		debugfRMap("\tnon-overlap right\n")
+		return l
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if M.entryv[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugfRMap("\tjhi: %d\n", jhi)
+
+	if jhi == 0 {
+		debugfRMap("\tnon-overlap left\n")
+		return 0
+	}
+
+	// [ilo+1:jhi-1] should be deleted
+	// [ilo] and [jhi-1] overlap with [r.lo,r.hi) - they should be deleted, or shrinked,
+	// or split+shrinked if ilo==jhi-1 and r is inside [ilo]
+	if jhi-ilo == 1 && M.entryv[ilo].Lo < r.Lo && r.Hi_ < M.entryv[ilo].Hi_ {
+		x := M.entryv[ilo]
+		vInsert(&M.entryv, ilo, x)
+		jhi++
+		debugfRMap("\tpresplit copy %s\t-> %s\n", x, M)
+	}
+	if M.entryv[ilo].Lo < r.Lo { // shrink left
+		M.entryv[ilo].Hi_ = r.Lo-1
+		debugfRMap("\tshrink [%d] left \t-> %s\n", ilo, M)
+		ilo++
+	}
+	if r.Hi_ < M.entryv[jhi-1].Hi_ { // shrink right
+		M.entryv[jhi-1].Lo = r.Hi_+1
+		debugfRMap("\tshrink [%d] right\t-> %s\n", jhi-1, M)
+		jhi--
+	}
+
+	if (jhi - ilo) > 0 {
+		vDeleteSlice(&M.entryv, ilo,jhi)
+		debugfRMap("\tdelete M[%d:%d]\t-> %s\n", ilo, jhi, M)
+	}
+
+	// done
+	return ilo
+}
+
+// HasRange returns whether all keys from range r belong to the map.
+func (M *RangedMap) HasRange(r KeyRange) (yes bool) {
+	if traceRangeMap {
+		fmt.Printf("\n\nHasRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer func() {
+			fmt.Printf("->·: %v\n", yes)
+		}()
+	}
+
+	M.verify()
+
+	if r.Empty() {
+		return true
+	}
+
+	// find first ilo: r.lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugfRMap("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return false
+	}
+
+	// scan right and verify that whole r is covered
+	lo := r.Lo
+	for {
+		e := M.entryv[ilo]
+		debugfRMap("\te: %s\ttocheck: %s\n", e, KeyRange{lo, r.Hi_})
+
+		if lo < e.Lo {
+			return false // hole in coverage
+		}
+		if r.Hi_ <= e.Hi_ {
+			return true  // reached full coverage
+		}
+
+		lo = e.Hi_
+		if lo < KeyMax {
+			lo++
+		}
+
+		ilo++
+		if ilo == l {
+			return false // r's right not fully covered
+		}
+	}
+}
+
+// IntersectsRange returns whether some keys from range r belong to the map.
+func (M *RangedMap) IntersectsRange(r KeyRange) (yes bool) {
+	if traceRangeMap {
+		fmt.Printf("\n\nIntersectsRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer func() {
+			fmt.Printf("->·: %v\n", yes)
+		}()
+	}
+
+	M.verify()
+
+	if r.Empty() {
+		return false
+	}
+
+	// find first ilo: r.lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugfRMap("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return false
+	}
+
+	// [ilo].hi may be either inside r (≤ r.hi), or > r.hi
+	// - if it is inside  -> overlap is there,
+	// - if it is > r.hi  -> overlap is there if [ilo].lo < r.hi
+	// => in any case overlap is there if [ilo].lo < r.hi
+	return M.entryv[ilo].Lo <= r.Hi_
+}
+
+
+// --------
+
+// verify checks RangedMap for internal consistency:
+// - ranges must be not overlapping and ↑
+// - adjacent ranges must map to different values
+func (M *RangedMap) verify() {
+	// TODO !debug -> return
+
+	var badv []string
+	badf := func(format string, argv ...interface{}) {
+		badv = append(badv, fmt.Sprintf(format, argv...))
+	}
+	defer func() {
+		if badv != nil {
+			emsg := "M.verify: fail:\n\n"
+			for _, bad := range badv {
+				emsg += fmt.Sprintf("- %s\n", bad)
+			}
+			emsg += fmt.Sprintf("\nM: %s\n", M)
+			panic(emsg)
+		}
+	}()
+
+	hi_Prev := KeyMin
+	var v_Prev VALUE
+	for i, e := range M.entryv {
+		hiPrev := hi_Prev + 1
+		if i > 0 {
+			if (e.Value == v_Prev) {
+				if !(hiPrev < e.Lo) { // NOTE not ≤ - adjacent ranges must be merged
+					badf("[%d]: same value: !(hiPrev < e.lo)", i)
+				}
+			} else {
+				if !(hi_Prev <= e.Lo) {
+					badf("[%d]: different value: !(hiPrev ≤ e.lo)", i)
+				}
+			}
+		}
+		if !(e.Lo <= e.Hi_) {
+			badf("[%d]: !(e.lo ≤ e.hi_)", i)
+		}
+		hi_Prev = e.Hi_
+		v_Prev  = e.Value
+	}
+}
+
+// Clone returns copy of the map.
+//
+// NOTE values are _not_ cloned.
+func (orig *RangedMap) Clone() *RangedMap {
+	klon := &RangedMap{}
+	klon.entryv = append(klon.entryv, orig.entryv...)
+	return klon
+}
+
+// Empty returns whether the map is empty.
+func (M *RangedMap) Empty() bool {
+	return len(M.entryv) == 0
+}
+
+// Equal returns whether A == B.
+func (A *RangedMap) Equal(B *RangedMap) bool {
+	if len(A.entryv) != len(B.entryv) {
+		return false
+	}
+	for i, ea := range A.entryv {
+		eb := B.entryv[i]
+		if ea != eb {
+			return false
+		}
+	}
+	return true
+}
+
+// Clear removes all elements from the map.
+func (M *RangedMap) Clear() {
+	M.entryv = nil
+}
+
+// AllRanges returns slice of all key ranges in the set.
+//
+// TODO -> iter?
+func (M *RangedMap) AllRanges() /*readonly*/[]RangedMapEntry {
+	return M.entryv
+}
+
+func (M RangedMap) String() string {
+	s := "{"
+	for i, e := range M.entryv {
+		if i > 0 {
+			s += " "
+		}
+		s += e.String()
+	}
+	s += "}"
+	return s
+}
+
+func (e RangedMapEntry) String() string {
+	s := e.KeyRange.String()
+	v := fmt.Sprintf("%v", e.Value)
+	if v != "" { // omit ":<v>" in the case of set
+		s += ":" + v
+	}
+	return s
+}
+
+
+func debugfRMap(format string, argv ...interface{}) {
+	if !debugRangeMap {
+		return
+	}
+	fmt.Printf(format, argv...)
+}
+
+
+// ---- slice ops ----
+
+// vInsert inserts e into *pv[i].
+func vInsert(pv *[]RangedMapEntry, i int, e RangedMapEntry) {
+	v := *pv
+	v = append(v, RangedMapEntry{})
+	copy(v[i+1:], v[i:])
+	v[i] = e
+	*pv = v
+}
+
+// vDeleteSlice deletes *pv[lo:hi].
+func vDeleteSlice(pv *[]RangedMapEntry, lo,hi int) {
+	v := *pv
+	n := copy(v[lo:], v[hi:])
+	v = v[:lo+n]
+	*pv = v
+}
+
+// vReplaceSlice replaces *pv[lo:hi] with e.
+func vReplaceSlice(pv *[]RangedMapEntry, lo,hi int, e RangedMapEntry) {
+	v := *pv
+	n := copy(v[lo+1:], v[hi:])
+	v[lo] = e
+	v = v[:lo+1+n]
+	*pv = v
+}

wcfs/internal/xbtree/blib/rangemap_test.go

+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+
+//go:generate ./gen-rangemap _RangedMap_str string zrangemap_str.go
+
+import (
+	"reflect"
+	"testing"
+)
+
+type (
+	RangedMap      = _RangedMap_str
+	RangedMapEntry = _RangedMap_strEntry
+)
+
+const (
+	oo  = KeyMax
+	noo = KeyMin
+)
+
+func TestRangedMap(t *testing.T) {
+	type testEntry struct {
+		M          *RangedMap
+		X          RangedMapEntry
+		Set        *RangedMap // M.SetRange(X.keycov, X.value)
+		Del        *RangedMap // M.DelRange(X.keycov)
+		Has        bool       // M.HasRange(X.keycov)
+		Intersects bool       // M.IntersectsRange(X.Keycov)
+	}
+	E := func(M *RangedMap, X RangedMapEntry, S, D *RangedMap, H, I bool) testEntry {
+		return testEntry{M, X, S, D, H, I}
+	}
+
+	// M is shorthand to create RangedMap, e.g. M(1,2,a, 3,4,b) will return {[1,2):a [3,4):b}.
+	M := func(argv ...interface{}) *RangedMap {
+		l := len(argv)
+		if l % 3 != 0 {
+			panic("non 3x number of arguments")
+		}
+		// asKey converts arg to Key
+		asKey := func(arg interface{}) Key {
+			// go through reflect to accept all int, int64, Key, ...
+			return Key(reflect.ValueOf(arg).Int())
+		}
+		M := &RangedMap{}
+		for i := 0; i < l/3; i++ {
+			// construct .entryv directly, not via SetRange
+			lo := asKey(argv[3*i])
+			hi := asKey(argv[3*i+1])
+			v  := argv[3*i+2].(string)
+			hi_ := hi
+			if hi_ != oo {
+				hi_--
+			}
+			M.entryv = append(M.entryv, RangedMapEntry{
+					v,
+					KeyRange{lo, hi_},
+			})
+		}
+		M.verify()
+		return M
+	}
+
+	// X creates RangedMapEntry{v, [lo,hi)}
+	X := func(lo,hi Key, v string) RangedMapEntry {
+		hi_ := hi
+		if hi_ != oo {
+			hi_--
+		}
+		return RangedMapEntry{v, KeyRange{lo, hi_}}
+	}
+
+	// y, n alias true/false
+	const y, n = true, false
+
+	// a, b, c, ... are shorthands for corresponding strings
+	const a, b, c, x = "a", "b", "c", "x"
+
+
+	testv := []testEntry{
+		// empty vs empty
+		E(
+			M(),			// M
+			X(0,0,x),		// X
+				M(),			// Set
+				M(),			// Del
+				y,			// Has
+				n),			// Intersects
+
+		// empty vs !empty
+		E(
+			M(),			// M
+			X(1,2,x),		// X
+				M(1,2,x),		// Set
+				M(),			// Del
+				n,			// Has
+				n),			// Intersects
+
+		// !empty vs empty
+		E(
+			M(1,2,a),		// M
+			X(0,0,x),		// X
+				M(1,2,a),		// Set
+				M(1,2,a),		// Del
+				y,			// Has
+				n),			// Intersects
+
+		// basic change
+		E(
+			M(1,2,a),		// M
+			X(1,2,x),		// X
+				M(1,2,x),		// Set
+				M(),			// Del
+				y,			// Has
+				y),			// Intersects
+
+		// adjacent [1,3) [3,5)
+		E(
+			M(1,3,a),		// M
+			X(3,5,x),		// X
+				M(1,3,a, 3,5,x),	// Set
+				M(1,3,a),		// Del
+				n,			// Has
+				n),			// Intersects
+
+		// overlapping [1,3) [2,4)
+		E(
+			M(1,3,a),		// M
+			X(2,4,x),		// X
+				M(1,2,a, 2,4,x),	// Set
+				M(1,2,a),		// Del
+				n,			// Has
+				y),			// Intersects
+
+		// [1,7) vs [3,5) -> split
+		E(
+			M(1,7,a),		// M
+			X(3,5,x),		// X
+				M(1,3,a, 3,5,x, 5,7,a),	// Set
+				M(1,3,a,        5,7,a),	// Del
+				y,			// Has
+				y),			// Intersects
+
+		// several ranges vs [-∞,∞)
+		E(
+			M(1,3,a, 5,7,b, 8,9,c),	// M
+			X(noo,oo,x),		// X
+				M(noo,oo,x),		// Set
+				M(),			// Del
+				n,			// Has
+				y),			// Intersects
+
+		E(
+			M(1,2,a, 2,3,b),	// M
+			X(1,3,x),		// X
+				M(1,3,x),		// Set
+				M(),			// Del
+				y,			// Has
+				y),			// Intersects
+
+		// coalesce (same value, no overlap)
+		E(
+			M(1,2,a, 4,5,a),	// M
+			X(2,4,a),		// X
+				M(1,5,a),		// Set
+				M(1,2,a, 4,5,a),	// Del
+				n,			// Has
+				n),			// Intersects
+
+		// coalesce (same value, overlap)
+		E(
+			M(1,4,a, 5,8,a),	// M
+			X(2,6,a),		// X
+				M(1,8,a),		// Set
+				M(1,2,a, 6,8,a),	// Del
+				n,			// Has
+				y),			// Intersects
+
+		// - shrink left/right (value !same) + new entry
+		E(
+			M(1,4,a),		// M
+			X(2,6,x),		// X
+				M(1,2,a, 2,6,x),	// Set
+				M(1,2,a),		// Del
+				n,			// Has
+				y),			// Intersects
+		E(
+			M(5,8,b),		// M
+			X(2,6,x),		// X
+				M(2,6,x, 6,8,b),	// Set
+				M(       6,8,b),	// Del
+				n,			// Has
+				y),			// Intersects
+		E(
+			M(1,4,a, 5,8,b),	// M
+			X(2,6,x),		// X
+				M(1,2,a, 2,6,x, 6,8,b),	// Set
+				M(1,2,a,        6,8,b),	// Del
+				n,			// Has
+				y),			// Intersects
+	}
+
+	for _, tt := range testv {
+		M := tt.M
+		X := tt.X
+		r := X.KeyRange
+		v := X.Value
+
+		assertMapHasRange(t, M, r, tt.Has)
+		assertMapIntersectsRange(t, M, r, tt.Intersects)
+		Mset := M.Clone()
+		Mdel := M.Clone()
+		Mset.SetRange(r, v)
+		Mdel.DelRange(r)
+
+		if !Mset.Equal(tt.Set) {
+			t.Errorf("SetRange:\n  M:   %s\n  e:   %s\n  ->·: %s\n  ok·: %s\n", M, X, Mset, tt.Set)
+
+		}
+
+		if !Mdel.Equal(tt.Del) {
+			t.Errorf("DelRange:\n  M:   %s\n  r:   %s\n  ->·: %s\n  ok·: %s\n", M, r, Mdel, tt.Del)
+
+		}
+
+		assertMapHasRange(t, Mset, r, true)
+		assertMapHasRange(t, Mdel, r, r.Empty())
+		assertMapIntersectsRange(t, Mset, r, !r.Empty())
+		assertMapIntersectsRange(t, Mdel, r, false)
+
+		verifyGet(t, M)
+		verifyGet(t, Mset)
+		verifyGet(t, Mdel)
+	}
+}
+
+// assertMapHasRange asserts that RangedMap M.HasRange(r) == hasOK.
+func assertMapHasRange(t *testing.T, M *RangedMap, r KeyRange, hasOK bool) {
+	t.Helper()
+	has := M.HasRange(r)
+	if !(has == hasOK) {
+		t.Errorf("HasRange:\n  M:   %s\n  r:   %s\n  ->·: %t\n  ok·: %t\n", M, r, has, hasOK)
+	}
+}
+
+// assertMapIntersectsRange asserts that RangedMap M.IntersectsRange(r) == intersectsOK.
+func assertMapIntersectsRange(t *testing.T, M *RangedMap, r KeyRange, intersectsOK bool) {
+	t.Helper()
+	intersects := M.IntersectsRange(r)
+	if !(intersects == intersectsOK) {
+		t.Errorf("IntersectsRange:\n  M:   %s\n  r:   %s\n  ->·: %t\n  ok·: %t\n", M, r, intersects, intersectsOK)
+	}
+}
+
+// verifyGet verifies RangedMap.Get .
+func verifyGet(t *testing.T, M *RangedMap) {
+	t.Helper()
+
+	var Mranges []RangedMapEntry
+	Mranges = append(Mranges, M.AllRanges()...) // copy just in case it changes on Get
+
+	// verify "has-data"
+	Z := KeyRange{-100,+100} // models [-∞,∞)
+	for _, e := range Mranges {
+		lo  := kmax(e.Lo,  Z.Lo)
+		hi_ := kmin(e.Hi_, Z.Hi_)
+		for k := lo; k <= hi_; k++ {
+			v, r, ok := M.Get_(k)
+			if !(v == e.Value && r == e.KeyRange && ok) {
+				t.Errorf("%s\tGet(%s):\nhave: %q%s, %t\nwant: %q%s, true",
+					M, KStr(k), v, r, ok, e.Value, e.KeyRange)
+			}
+		}
+	}
+
+	// verify "no-data"
+	// NA = [-∞,∞) \ M
+	na := RangedKeySet{}
+	na.AddRange(Z)
+	for _, e := range Mranges {
+		na.DelRange(e.KeyRange)
+	}
+
+	for _, r := range na.AllRanges() {
+		lo  := kmax(r.Lo,  Z.Lo)
+		hi_ := kmin(r.Hi_, Z.Hi_)
+		for k := lo; k <= hi_; k++ {
+			v, r_, ok := M.Get_(k)
+			if !(v == "" && r_.Empty() && !ok) {
+				t.Errorf("%s\tGet(%s):\nhave: %q%s, %t\nwant: %q[), false",
+					M, KStr(k), v, r_, ok, "")
+			}
+		}
+	}
+}
+
+
+// kmin returns min(a,b).
+func kmin(a, b Key) Key {
+	if a < b {
+		return a
+	} else {
+		return b
+	}
+}
+
+// kmax returns max(a,b).
+func kmax(a, b Key) Key {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}

wcfs/internal/xbtree/blib/rangeset.go

+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+// set of [lo,hi) Key ranges.
+
+//go:generate ./gen-rangemap _RangedMap_void void zrangemap_void.go
+
+
+// RangedKeySet is set of Keys with adjacent keys coalesced into Ranges.
+//
+// Zero value represents empty set.
+type RangedKeySet struct {
+	m _RangedMap_void
+}
+
+// void is used as value type for RangedMap to be used as set.
+type void struct{}
+func (_ void) String() string { return "" }
+
+
+
+// Add adds key k to the set.
+func (S *RangedKeySet) Add(k Key) {
+	S.AddRange(KeyRange{Lo: k, Hi_: k})
+}
+
+// Del removes key k from the set.
+func (S *RangedKeySet) Del(k Key) {
+	S.DelRange(KeyRange{Lo: k, Hi_: k})
+}
+
+// Has returns whether key k belongs to the set.
+func (S *RangedKeySet) Has(k Key) bool {
+	return S.HasRange(KeyRange{Lo: k, Hi_: k})
+}
+
+
+// AddRange adds range r to the set.
+func (S *RangedKeySet) AddRange(r KeyRange) {
+	S.m.SetRange(r, void{})
+}
+
+// DelRange removes range r from the set.
+func (S *RangedKeySet) DelRange(r KeyRange) {
+	S.m.DelRange(r)
+}
+
+// HasRange returns whether all keys from range r belong to the set.
+func (S *RangedKeySet) HasRange(r KeyRange) bool {
+	return S.m.HasRange(r)
+}
+
+// IntersectsRange returns whether some keys from range r belong to the set.
+func (S *RangedKeySet) IntersectsRange(r KeyRange) bool {
+	return S.m.IntersectsRange(r)
+}
+
+
+// Union returns RangedKeySet(A.keys | B.keys).
+func (A *RangedKeySet) Union(B *RangedKeySet) *RangedKeySet {
+	U := A.Clone()
+	U.UnionInplace(B)
+	return U
+}
+
+// Difference returns RangedKeySet(A.keys \ B.keys).
+func (A *RangedKeySet) Difference(B *RangedKeySet) *RangedKeySet {
+	D := A.Clone()
+	D.DifferenceInplace(B)
+	return D
+}
+
+// Intersection returns RangedKeySet(A.keys ^ B.keys).
+func (A *RangedKeySet) Intersection(B *RangedKeySet) *RangedKeySet {
+	I := A.Clone()
+	I.IntersectionInplace(B)
+	return I
+}
+
+func (A *RangedKeySet) UnionInplace(B *RangedKeySet) {
+	A.verify()
+	B.verify()
+	defer A.verify()
+
+	// XXX dumb
+	for _, e := range B.m.entryv {
+		A.AddRange(e.KeyRange)
+	}
+}
+
+func (A *RangedKeySet) DifferenceInplace(B *RangedKeySet) {
+	A.verify()
+	B.verify()
+	defer A.verify()
+
+	// XXX dumb
+	for _, e := range B.m.entryv {
+		if A.Empty() {
+			break
+		}
+		A.DelRange(e.KeyRange)
+	}
+}
+
+func (A *RangedKeySet) IntersectionInplace(B *RangedKeySet) {
+	A.verify()
+	B.verify()
+	defer A.verify()
+
+	// XXX very dumb
+	// A^B = (A∪B) \ (A\B ∪ B\A)
+	AdB := A.Difference(B)
+	BdA := B.Difference(A)
+	ddd := AdB
+	ddd.UnionInplace(BdA)
+	A.UnionInplace(B)
+	A.DifferenceInplace(ddd)
+}
+
+
+// --------
+
+// verify checks RangedKeySet for internal consistency.
+func (S *RangedKeySet) verify() {
+	S.m.verify()
+}
+
+// Clone returns copy of the set.
+func (orig *RangedKeySet) Clone() *RangedKeySet {
+	return &RangedKeySet{*orig.m.Clone()}
+}
+
+// Empty returns whether the set is empty.
+func (S *RangedKeySet) Empty() bool {
+	return S.m.Empty()
+}
+
+// Equal returns whether A == B.
+func (A *RangedKeySet) Equal(B *RangedKeySet) bool {
+	return A.m.Equal(&B.m)
+}
+
+// Clear removes all elements from the set.
+func (S *RangedKeySet) Clear() {
+	S.m.Clear()
+}
+
+// AllRanges returns slice of all key ranges in the set.
+//
+// TODO -> iter?
+func (S *RangedKeySet) AllRanges() /*readonly*/[]KeyRange {
+	// TODO we could use unsafe and cast .m.AllRanges to []KeyRange to avoid extra alloc/copy
+	// return []KeyRange(S.m.AllRanges())
+	ev := S.m.AllRanges()
+	rv := make([]KeyRange, len(ev))
+	for i := range ev {
+		rv[i] = ev[i].KeyRange
+	}
+	return rv
+}
+
+func (S RangedKeySet) String() string {
+	// RangedMap<void> supports formatting for set out of the box
+	return S.m.String()
+}

wcfs/internal/xbtree/blib/rangeset_test.go

+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+
+import (
+	"testing"
+	"unsafe"
+)
+
+func TestRangedKeySetTypes(t *testing.T) {
+	// verify that size(void) == 0  and  that _RangedMap_voidEntry has the same layout as KeyRange
+	sizeVoid := unsafe.Sizeof(void{})
+	if sizeVoid != 0 {
+		t.Errorf("sizeof(void) = %d  ; want 0", sizeVoid)
+	}
+
+	// verify that sizeof(set-entry) = sizeof(KeyRange)
+	// NOTE for this to be true Value needs to come first in RangedMapEntry
+	// (see github.com/golang/go/issues/48651)
+	sizeKeyRange := unsafe.Sizeof(KeyRange{})
+	sizeRangedMap_voidEntry := unsafe.Sizeof(_RangedMap_voidEntry{})
+	if sizeRangedMap_voidEntry != sizeKeyRange {
+		t.Errorf("sizeof(RangeMap_voidEntry)(%d)  !=  sizeof(KeyRange)(%d)",
+			sizeRangedMap_voidEntry, sizeKeyRange)
+	}
+}
+
+func TestRangedKeySet(t *testing.T) {
+	type testEntry struct {
+		A, B         *RangedKeySet
+		Union        *RangedKeySet
+		Difference   *RangedKeySet
+		Intersection *RangedKeySet
+	}
+	E := func(A, B, U, D, I *RangedKeySet) testEntry {
+		return testEntry{A, B, U, D, I}
+	}
+
+	// S is shorthand to create RangedKeySet, e.g. S(1,2, 4,5) will return {[1,2) [4,5)}
+	S := func(kv ...Key) *RangedKeySet {
+		l := len(kv)
+		if l % 2 != 0 {
+			panic("odd number of keys")
+		}
+		S := &RangedKeySet{}
+		for i := 0; i < l/2; i++ {
+			// construct .entryv directly, not via AddRange
+			lo := kv[2*i]
+			hi := kv[2*i+1]
+			hi_ := hi
+			if hi_ != oo {
+				hi_--
+			}
+			S.m.entryv = append(S.m.entryv, _RangedMap_voidEntry{
+					void{},
+					KeyRange{lo, hi_},
+			})
+		}
+		S.verify()
+		return S
+	}
+
+	testv := []testEntry{
+		E(
+			S(),	// A
+			S(),	// B
+				S(),	// U
+				S(),	// D
+				S()),	// I
+
+		E(
+			S(),	// A
+			S(1,2),	// B
+				S(1,2),	// U
+				S(),	// D
+				S()),	// I
+
+		E(
+			S(1,2),	// A
+			S(),	// B
+				S(1,2),	// U
+				S(1,2), // D
+				S()),	// I
+
+		E(
+			S(1,2),	// A
+			S(1,2),	// B
+				S(1,2),	// U
+				S(),	// D
+				S(1,2)),// I
+
+		// adjacent [1,3) [3,5)
+		E(
+			S(1,3), // A
+			S(3,5), // B
+				S(1,5),	// U
+				S(1,3),	// D
+				S()),	// I
+
+		// overlapping [1,3) [2,4)
+		E(
+			S(1,3),	// A
+			S(2,4),	// B
+				S(1,4),	// U
+				S(1,2),	// D
+				S(2,3)),// I
+
+		// [1,7) \ [3,5)  ->  [1,3) [5,7)
+		E(
+			S(1,7),	// A
+			S(3,5),	// B
+				S(1,7),		// U
+				S(1,3, 5,7),	// D
+				S(3,5)),	// I
+
+		// several ranges \ [-∞,∞) -> ø
+		E(
+			S(1,3, 5,7, 11,100), // A
+			S(noo, oo),          // B
+				S(noo, oo),		// U
+				S(),			// D
+				S(1,3, 5,7, 11,100)),	// I
+
+		// [1,3) [5,7) + insert [3,5) -> [1,7)
+		E(
+			S(1,3, 5,7),	// A
+			S(3,5),		// B
+				S(1,7),		// U
+				S(1,3, 5,7),	// D
+				S()),		// I
+
+		// delete covering several ranges
+		// [-1,0)  [1,3) [5,7) [9,11) [15,20)  [100,200)   \  [2,17)
+		E(
+			S(-1,0, 1,3, 5,7, 9,11, 15,20, 100,200),// A
+			S(2,17),				// B
+				S(-1,0, 1,20, 100,200),			// U
+				S(-1,0, 1,2, 17,20, 100,200),		// D
+				S(2,3, 5,7, 9,11, 15,17)),		// I
+	}
+
+	for _, tt := range testv {
+		A := tt.A
+		B := tt.B
+		U := A.Union(B)
+		D := A.Difference(B)
+		I := A.Intersection(B)
+
+		if !U.Equal(tt.Union) {
+			t.Errorf("Union:\n  A:   %s\n  B:   %s\n  ->u: %s\n  okU: %s\n", A, B, U, tt.Union)
+		}
+		if !D.Equal(tt.Difference) {
+			t.Errorf("Difference:\n  A:   %s\n  B:   %s\n  ->d: %s\n  okD: %s\n", A, B, D, tt.Difference)
+		}
+		if !I.Equal(tt.Intersection) {
+			t.Errorf("Intersection:\n  A:   %s\n  B:   %s\n  ->i: %s\n  okI: %s\n", A, B, I, tt.Intersection)
+		}
+
+		// HasRange
+		assertSetHasRanges(t, A, A.AllRanges(), true)
+		assertSetHasRanges(t, B, B.AllRanges(), true)
+		assertSetHasRanges(t, U, A.AllRanges(), true)
+		assertSetHasRanges(t, U, B.AllRanges(), true)
+		assertSetHasRanges(t, A, I.AllRanges(), true)
+		assertSetHasRanges(t, B, I.AllRanges(), true)
+		assertSetHasRanges(t, U, I.AllRanges(), true)
+
+		Dab := D
+		Dba := B.Difference(A)
+		assertSetHasRanges(t, A, Dab.AllRanges(), true)
+		assertSetHasRanges(t, B, Dab.AllRanges(), false)
+		assertSetHasRanges(t, B, Dba.AllRanges(), true)
+		assertSetHasRanges(t, A, Dba.AllRanges(), false)
+		assertSetHasRanges(t, Dab, I.AllRanges(), false)
+		assertSetHasRanges(t, Dba, I.AllRanges(), false)
+		assertSetHasRanges(t, I,   Dab.AllRanges(), false)
+		assertSetHasRanges(t, I,   Dba.AllRanges(), false)
+
+		// IntersectsRange  (= (A^B)!=ø)
+		assertSetIntersectsRanges(t, A, I.AllRanges(), !I.Empty())
+		assertSetIntersectsRanges(t, B, I.AllRanges(), !I.Empty())
+		assertSetIntersectsRanges(t, Dab, B.AllRanges(), false)
+		assertSetIntersectsRanges(t, Dba, A.AllRanges(), false)
+		assertSetIntersectsRanges(t, Dab, I.AllRanges(), false)
+		assertSetIntersectsRanges(t, Dba, I.AllRanges(), false)
+		assertSetIntersectsRanges(t, I,   Dab.AllRanges(), false)
+		assertSetIntersectsRanges(t, I,   Dba.AllRanges(), false)
+	}
+}
+
+// assertSetHasRanges asserts for all ranges from rangev that RangedSet S.HasRange(r) == hasOK.
+func assertSetHasRanges(t *testing.T, S *RangedKeySet, rangev []KeyRange, hasOK bool) {
+	t.Helper()
+	for _, r := range rangev {
+		has := S.HasRange(r)
+		if has != hasOK {
+			t.Errorf("HasRange:\n  S:   %s\n  r:   %s\n  ->: %v\n  ok: %v\n", S, r, has, hasOK)
+		}
+	}
+}
+
+// assertSetIntersectsRanges asserts for all ranges from rangev that RangedSet S.IntersectsRange(r) == intersectsOK.
+func assertSetIntersectsRanges(t *testing.T, S *RangedKeySet, rangev []KeyRange, intersectsOK bool) {
+	t.Helper()
+	for _, r := range rangev {
+		intersects := S.IntersectsRange(r)
+		if intersects != intersectsOK {
+			t.Errorf("IntersectsRange:\n  S:   %s\n  r:   %s\n  ->: %v\n  ok: %v\n", S, r, intersects, intersectsOK)
+		}
+	}
+}

wcfs/internal/xbtree/blib/zrangemap_str.go

+// Code generated by gen-rangemap _RangedMap_str string; DO NOT EDIT.
+
+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+// map [lo,hi) Key ranges to values.
+
+import (
+	"fmt"
+	"sort"
+)
+
+const trace_RangedMap_str = false
+const debug_RangedMap_str = false
+
+// _RangedMap_str is Key->string map with adjacent keys mapped to the same value coalesced into Ranges.
+//
+// Zero value represents empty map.
+type _RangedMap_str struct {
+	// TODO rework to use BTree lo->hi_ instead if in practice in treediff,
+	// and other usage places, N(ranges) turns out to be not small
+	// (i.e. performance turns out to be not acceptable)
+	entryv []_RangedMap_strEntry // lo↑
+}
+
+// _RangedMap_strEntry represents one entry in _RangedMap_str.
+type _RangedMap_strEntry struct {
+	Value    string
+	KeyRange
+}
+
+
+// Get returns value associated with key k.
+//
+// KeyRange indicates all keys adjacent to k, that are too mapped to the same value.
+func (M *_RangedMap_str) Get(k Key) (string, KeyRange) {
+	v, r, _ := M.Get_(k)
+	return v, r
+}
+
+// Set changes M to map key k to value v.
+func (M *_RangedMap_str) Set(k Key, v string) {
+	M.SetRange(KeyRange{Lo: k, Hi_: k}, v)
+}
+
+// Del removes key k.
+func (M *_RangedMap_str) Del(k Key) {
+	M.DelRange(KeyRange{Lo: k, Hi_: k})
+}
+
+// Has returns whether key k is present in the map.
+func (M *_RangedMap_str) Has(k Key) bool {
+	_, _, ok := M.Get_(k)
+	return ok
+}
+
+
+
+// Get_ is comma-ok version of Get.
+func (M *_RangedMap_str) Get_(k Key) (v string, r KeyRange, ok bool) {
+	r = KeyRange{0,-1} // zero value represents non-empty [0,1)
+	if trace_RangedMap_str {
+		fmt.Printf("\n\nGet_:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  k: %s\n", KStr(k))
+		defer func() {
+			fmt.Printf("->·: %v%s, %t\n", v, r, ok)
+		}()
+	}
+
+	M.verify()
+
+	// find first ilo: k < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		return k <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_str("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return
+	}
+
+	e := M.entryv[ilo]
+	if !(e.Lo <= k) { // not found
+		return
+	}
+
+	// found
+	return e.Value, e.KeyRange, true
+}
+
+// SetRange changes M to map key range r to value v.
+func (M *_RangedMap_str) SetRange(r KeyRange, v string) {
+	e := _RangedMap_strEntry{v,r}
+	if trace_RangedMap_str {
+		fmt.Printf("\n\nSetRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  e: %s\n", e)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	// clear range for r and insert new entry
+	// TODO optimize for same-value/set case (just merge all covered
+	// entries into one - see commented AddRange from set vvv)
+	i := M.delRange(r)
+	vInsert__RangedMap_str(&M.entryv, i, e)
+	debugf_RangedMap_str("\tinsert %s\t-> %s\n", e, M)
+
+	// check if we should merge inserted entry with right/left neighbours
+	if i+1 < len(M.entryv) { // right
+		x     := M.entryv[i]
+		right := M.entryv[i+1]
+		if (x.Hi_+1 == right.Lo) && (v == right.Value) {
+			vReplaceSlice__RangedMap_str(&M.entryv, i,i+2,
+				_RangedMap_strEntry{v, KeyRange{x.Lo, right.Hi_}})
+			debugf_RangedMap_str("\tmerge right\t-> %s\n", M)
+		}
+	}
+
+	if i > 0 { // left
+		left := M.entryv[i-1]
+		x    := M.entryv[i]
+		if (left.Hi_+1 == x.Lo) && (left.Value == v) {
+			vReplaceSlice__RangedMap_str(&M.entryv, i-1,i+1,
+				_RangedMap_strEntry{v, KeyRange{left.Lo, x.Hi_}})
+			debugf_RangedMap_str("\tmerge left\t-> %s\n", M)
+		}
+	}
+
+	// done
+
+/* how it was for just set:
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(S.rangev)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= S.rangev[i].Hi_
+	})
+	debugfRSet("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		S.rangev = append(S.rangev, r)
+		l++
+		debugfRSet("\tappend %s\t-> %s\n", r, S)
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if S.rangev[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugfRSet("\tjhi: %d\n", jhi)
+
+	// entries in [ilo:jhi) ∈ [r.Lo,r.hi) and should be merged into one
+	if (jhi - ilo) > 1 {
+		lo  := S.rangev[ilo].Lo
+		hi_ := S.rangev[jhi-1].Hi_
+		vReplaceSlice__RangedMap_str(&S.rangev, ilo,jhi, KeyRange{lo,hi_})
+		debugfRSet("\tmerge S[%d:%d]\t-> %s\n", ilo, jhi, S)
+	}
+	jhi = -1 // no longer valid
+
+	// if [r.lo,r.hi) was outside of any entry - create new entry
+	if r.Hi_ < S.rangev[ilo].Lo {
+		vInsert__RangedMap_str(&S.rangev, ilo, r)
+		debugfRSet("\tinsert %s\t-> %s\n", r, S)
+	}
+
+	// now we have covered entries merged as needed into [ilo]
+	// extend this entry if r coverage is wider
+	if r.Lo < S.rangev[ilo].Lo {
+		S.rangev[ilo].Lo = r.Lo
+		debugfRSet("\textend left\t-> %s\n", S)
+	}
+	if r.Hi_ > S.rangev[ilo].Hi_ {
+		S.rangev[ilo].Hi_ = r.Hi_
+		debugfRSet("\textend right\t-> %s\n", S)
+	}
+
+	// and check if we should merge it with right/left neighbours
+	if ilo+1 < len(S.rangev) { // right
+		if S.rangev[ilo].Hi_+1 == S.rangev[ilo+1].Lo {
+			vReplaceSlice__RangedMap_str(&S.rangev, ilo,ilo+2,
+				KeyRange{S.rangev[ilo].Lo, S.rangev[ilo+1].Hi_})
+			debugfRSet("\tmerge right\t-> %s\n", S)
+		}
+	}
+
+	if ilo > 0 { // left
+		if S.rangev[ilo-1].Hi_+1 == S.rangev[ilo].Lo {
+			vReplaceSlice__RangedMap_str(&S.rangev, ilo-1,ilo+1,
+				KeyRange{S.rangev[ilo-1].Lo, S.rangev[ilo].Hi_})
+			debugfRSet("\tmerge left\t-> %s\n", S)
+		}
+	}
+
+	// done
+*/
+}
+
+// DelRange removes range r from the map.
+func (M *_RangedMap_str) DelRange(r KeyRange) {
+	if trace_RangedMap_str {
+		fmt.Printf("\n\nDelRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	M.delRange(r)
+}
+
+// delRange deletes range r from the map and returns .entryv index where r
+// should be inserted/appended if needed.
+//
+// r must be !empty.
+func (M *_RangedMap_str) delRange(r KeyRange) (i int) {
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_str("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		debugf_RangedMap_str("\tnon-overlap right\n")
+		return l
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if M.entryv[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugf_RangedMap_str("\tjhi: %d\n", jhi)
+
+	if jhi == 0 {
+		debugf_RangedMap_str("\tnon-overlap left\n")
+		return 0
+	}
+
+	// [ilo+1:jhi-1] should be deleted
+	// [ilo] and [jhi-1] overlap with [r.lo,r.hi) - they should be deleted, or shrinked,
+	// or split+shrinked if ilo==jhi-1 and r is inside [ilo]
+	if jhi-ilo == 1 && M.entryv[ilo].Lo < r.Lo && r.Hi_ < M.entryv[ilo].Hi_ {
+		x := M.entryv[ilo]
+		vInsert__RangedMap_str(&M.entryv, ilo, x)
+		jhi++
+		debugf_RangedMap_str("\tpresplit copy %s\t-> %s\n", x, M)
+	}
+	if M.entryv[ilo].Lo < r.Lo { // shrink left
+		M.entryv[ilo].Hi_ = r.Lo-1
+		debugf_RangedMap_str("\tshrink [%d] left \t-> %s\n", ilo, M)
+		ilo++
+	}
+	if r.Hi_ < M.entryv[jhi-1].Hi_ { // shrink right
+		M.entryv[jhi-1].Lo = r.Hi_+1
+		debugf_RangedMap_str("\tshrink [%d] right\t-> %s\n", jhi-1, M)
+		jhi--
+	}
+
+	if (jhi - ilo) > 0 {
+		vDeleteSlice__RangedMap_str(&M.entryv, ilo,jhi)
+		debugf_RangedMap_str("\tdelete M[%d:%d]\t-> %s\n", ilo, jhi, M)
+	}
+
+	// done
+	return ilo
+}
+
+// HasRange returns whether all keys from range r belong to the map.
+func (M *_RangedMap_str) HasRange(r KeyRange) (yes bool) {
+	if trace_RangedMap_str {
+		fmt.Printf("\n\nHasRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer func() {
+			fmt.Printf("->·: %v\n", yes)
+		}()
+	}
+
+	M.verify()
+
+	if r.Empty() {
+		return true
+	}
+
+	// find first ilo: r.lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_str("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return false
+	}
+
+	// scan right and verify that whole r is covered
+	lo := r.Lo
+	for {
+		e := M.entryv[ilo]
+		debugf_RangedMap_str("\te: %s\ttocheck: %s\n", e, KeyRange{lo, r.Hi_})
+
+		if lo < e.Lo {
+			return false // hole in coverage
+		}
+		if r.Hi_ <= e.Hi_ {
+			return true  // reached full coverage
+		}
+
+		lo = e.Hi_
+		if lo < KeyMax {
+			lo++
+		}
+
+		ilo++
+		if ilo == l {
+			return false // r's right not fully covered
+		}
+	}
+}
+
+// IntersectsRange returns whether some keys from range r belong to the map.
+func (M *_RangedMap_str) IntersectsRange(r KeyRange) (yes bool) {
+	if trace_RangedMap_str {
+		fmt.Printf("\n\nIntersectsRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer func() {
+			fmt.Printf("->·: %v\n", yes)
+		}()
+	}
+
+	M.verify()
+
+	if r.Empty() {
+		return false
+	}
+
+	// find first ilo: r.lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_str("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return false
+	}
+
+	// [ilo].hi may be either inside r (≤ r.hi), or > r.hi
+	// - if it is inside  -> overlap is there,
+	// - if it is > r.hi  -> overlap is there if [ilo].lo < r.hi
+	// => in any case overlap is there if [ilo].lo < r.hi
+	return M.entryv[ilo].Lo <= r.Hi_
+}
+
+
+// --------
+
+// verify checks _RangedMap_str for internal consistency:
+// - ranges must be not overlapping and ↑
+// - adjacent ranges must map to different values
+func (M *_RangedMap_str) verify() {
+	// TODO !debug -> return
+
+	var badv []string
+	badf := func(format string, argv ...interface{}) {
+		badv = append(badv, fmt.Sprintf(format, argv...))
+	}
+	defer func() {
+		if badv != nil {
+			emsg := "M.verify: fail:\n\n"
+			for _, bad := range badv {
+				emsg += fmt.Sprintf("- %s\n", bad)
+			}
+			emsg += fmt.Sprintf("\nM: %s\n", M)
+			panic(emsg)
+		}
+	}()
+
+	hi_Prev := KeyMin
+	var v_Prev string
+	for i, e := range M.entryv {
+		hiPrev := hi_Prev + 1
+		if i > 0 {
+			if (e.Value == v_Prev) {
+				if !(hiPrev < e.Lo) { // NOTE not ≤ - adjacent ranges must be merged
+					badf("[%d]: same value: !(hiPrev < e.lo)", i)
+				}
+			} else {
+				if !(hi_Prev <= e.Lo) {
+					badf("[%d]: different value: !(hiPrev ≤ e.lo)", i)
+				}
+			}
+		}
+		if !(e.Lo <= e.Hi_) {
+			badf("[%d]: !(e.lo ≤ e.hi_)", i)
+		}
+		hi_Prev = e.Hi_
+		v_Prev  = e.Value
+	}
+}
+
+// Clone returns copy of the map.
+//
+// NOTE values are _not_ cloned.
+func (orig *_RangedMap_str) Clone() *_RangedMap_str {
+	klon := &_RangedMap_str{}
+	klon.entryv = append(klon.entryv, orig.entryv...)
+	return klon
+}
+
+// Empty returns whether the map is empty.
+func (M *_RangedMap_str) Empty() bool {
+	return len(M.entryv) == 0
+}
+
+// Equal returns whether A == B.
+func (A *_RangedMap_str) Equal(B *_RangedMap_str) bool {
+	if len(A.entryv) != len(B.entryv) {
+		return false
+	}
+	for i, ea := range A.entryv {
+		eb := B.entryv[i]
+		if ea != eb {
+			return false
+		}
+	}
+	return true
+}
+
+// Clear removes all elements from the map.
+func (M *_RangedMap_str) Clear() {
+	M.entryv = nil
+}
+
+// AllRanges returns slice of all key ranges in the set.
+//
+// TODO -> iter?
+func (M *_RangedMap_str) AllRanges() /*readonly*/[]_RangedMap_strEntry {
+	return M.entryv
+}
+
+func (M _RangedMap_str) String() string {
+	s := "{"
+	for i, e := range M.entryv {
+		if i > 0 {
+			s += " "
+		}
+		s += e.String()
+	}
+	s += "}"
+	return s
+}
+
+func (e _RangedMap_strEntry) String() string {
+	s := e.KeyRange.String()
+	v := fmt.Sprintf("%v", e.Value)
+	if v != "" { // omit ":<v>" in the case of set
+		s += ":" + v
+	}
+	return s
+}
+
+
+func debugf_RangedMap_str(format string, argv ...interface{}) {
+	if !debug_RangedMap_str {
+		return
+	}
+	fmt.Printf(format, argv...)
+}
+
+
+// ---- slice ops ----
+
+// vInsert__RangedMap_str inserts e into *pv[i].
+func vInsert__RangedMap_str(pv *[]_RangedMap_strEntry, i int, e _RangedMap_strEntry) {
+	v := *pv
+	v = append(v, _RangedMap_strEntry{})
+	copy(v[i+1:], v[i:])
+	v[i] = e
+	*pv = v
+}
+
+// vDeleteSlice__RangedMap_str deletes *pv[lo:hi].
+func vDeleteSlice__RangedMap_str(pv *[]_RangedMap_strEntry, lo,hi int) {
+	v := *pv
+	n := copy(v[lo:], v[hi:])
+	v = v[:lo+n]
+	*pv = v
+}
+
+// vReplaceSlice__RangedMap_str replaces *pv[lo:hi] with e.
+func vReplaceSlice__RangedMap_str(pv *[]_RangedMap_strEntry, lo,hi int, e _RangedMap_strEntry) {
+	v := *pv
+	n := copy(v[lo+1:], v[hi:])
+	v[lo] = e
+	v = v[:lo+1+n]
+	*pv = v
+}

wcfs/internal/xbtree/blib/zrangemap_void.go

+// Code generated by gen-rangemap _RangedMap_void void; DO NOT EDIT.
+
+// Copyright (C) 2021  Nexedi SA and Contributors.
+//                     Kirill Smelkov <kirr@nexedi.com>
+//
+// This program is free software: you can Use, Study, Modify and Redistribute
+// it under the terms of the GNU General Public License version 3, or (at your
+// option) any later version, as published by the Free Software Foundation.
+//
+// You can also Link and Combine this program with other software covered by
+// the terms of any of the Free Software licenses or any of the Open Source
+// Initiative approved licenses and Convey the resulting work. Corresponding
+// source of such a combination shall include the source code for all other
+// software used.
+//
+// This program is distributed WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
+// See COPYING file for full licensing terms.
+// See https://www.nexedi.com/licensing for rationale and options.
+
+package blib
+// map [lo,hi) Key ranges to values.
+
+import (
+	"fmt"
+	"sort"
+)
+
+const trace_RangedMap_void = false
+const debug_RangedMap_void = false
+
+// _RangedMap_void is Key->void map with adjacent keys mapped to the same value coalesced into Ranges.
+//
+// Zero value represents empty map.
+type _RangedMap_void struct {
+	// TODO rework to use BTree lo->hi_ instead if in practice in treediff,
+	// and other usage places, N(ranges) turns out to be not small
+	// (i.e. performance turns out to be not acceptable)
+	entryv []_RangedMap_voidEntry // lo↑
+}
+
+// _RangedMap_voidEntry represents one entry in _RangedMap_void.
+type _RangedMap_voidEntry struct {
+	Value    void
+	KeyRange
+}
+
+
+// Get returns value associated with key k.
+//
+// KeyRange indicates all keys adjacent to k, that are too mapped to the same value.
+func (M *_RangedMap_void) Get(k Key) (void, KeyRange) {
+	v, r, _ := M.Get_(k)
+	return v, r
+}
+
+// Set changes M to map key k to value v.
+func (M *_RangedMap_void) Set(k Key, v void) {
+	M.SetRange(KeyRange{Lo: k, Hi_: k}, v)
+}
+
+// Del removes key k.
+func (M *_RangedMap_void) Del(k Key) {
+	M.DelRange(KeyRange{Lo: k, Hi_: k})
+}
+
+// Has returns whether key k is present in the map.
+func (M *_RangedMap_void) Has(k Key) bool {
+	_, _, ok := M.Get_(k)
+	return ok
+}
+
+
+
+// Get_ is comma-ok version of Get.
+func (M *_RangedMap_void) Get_(k Key) (v void, r KeyRange, ok bool) {
+	r = KeyRange{0,-1} // zero value represents non-empty [0,1)
+	if trace_RangedMap_void {
+		fmt.Printf("\n\nGet_:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  k: %s\n", KStr(k))
+		defer func() {
+			fmt.Printf("->·: %v%s, %t\n", v, r, ok)
+		}()
+	}
+
+	M.verify()
+
+	// find first ilo: k < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		return k <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_void("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return
+	}
+
+	e := M.entryv[ilo]
+	if !(e.Lo <= k) { // not found
+		return
+	}
+
+	// found
+	return e.Value, e.KeyRange, true
+}
+
+// SetRange changes M to map key range r to value v.
+func (M *_RangedMap_void) SetRange(r KeyRange, v void) {
+	e := _RangedMap_voidEntry{v,r}
+	if trace_RangedMap_void {
+		fmt.Printf("\n\nSetRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  e: %s\n", e)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	// clear range for r and insert new entry
+	// TODO optimize for same-value/set case (just merge all covered
+	// entries into one - see commented AddRange from set vvv)
+	i := M.delRange(r)
+	vInsert__RangedMap_void(&M.entryv, i, e)
+	debugf_RangedMap_void("\tinsert %s\t-> %s\n", e, M)
+
+	// check if we should merge inserted entry with right/left neighbours
+	if i+1 < len(M.entryv) { // right
+		x     := M.entryv[i]
+		right := M.entryv[i+1]
+		if (x.Hi_+1 == right.Lo) && (v == right.Value) {
+			vReplaceSlice__RangedMap_void(&M.entryv, i,i+2,
+				_RangedMap_voidEntry{v, KeyRange{x.Lo, right.Hi_}})
+			debugf_RangedMap_void("\tmerge right\t-> %s\n", M)
+		}
+	}
+
+	if i > 0 { // left
+		left := M.entryv[i-1]
+		x    := M.entryv[i]
+		if (left.Hi_+1 == x.Lo) && (left.Value == v) {
+			vReplaceSlice__RangedMap_void(&M.entryv, i-1,i+1,
+				_RangedMap_voidEntry{v, KeyRange{left.Lo, x.Hi_}})
+			debugf_RangedMap_void("\tmerge left\t-> %s\n", M)
+		}
+	}
+
+	// done
+
+/* how it was for just set:
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(S.rangev)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= S.rangev[i].Hi_
+	})
+	debugfRSet("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		S.rangev = append(S.rangev, r)
+		l++
+		debugfRSet("\tappend %s\t-> %s\n", r, S)
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if S.rangev[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugfRSet("\tjhi: %d\n", jhi)
+
+	// entries in [ilo:jhi) ∈ [r.Lo,r.hi) and should be merged into one
+	if (jhi - ilo) > 1 {
+		lo  := S.rangev[ilo].Lo
+		hi_ := S.rangev[jhi-1].Hi_
+		vReplaceSlice__RangedMap_void(&S.rangev, ilo,jhi, KeyRange{lo,hi_})
+		debugfRSet("\tmerge S[%d:%d]\t-> %s\n", ilo, jhi, S)
+	}
+	jhi = -1 // no longer valid
+
+	// if [r.lo,r.hi) was outside of any entry - create new entry
+	if r.Hi_ < S.rangev[ilo].Lo {
+		vInsert__RangedMap_void(&S.rangev, ilo, r)
+		debugfRSet("\tinsert %s\t-> %s\n", r, S)
+	}
+
+	// now we have covered entries merged as needed into [ilo]
+	// extend this entry if r coverage is wider
+	if r.Lo < S.rangev[ilo].Lo {
+		S.rangev[ilo].Lo = r.Lo
+		debugfRSet("\textend left\t-> %s\n", S)
+	}
+	if r.Hi_ > S.rangev[ilo].Hi_ {
+		S.rangev[ilo].Hi_ = r.Hi_
+		debugfRSet("\textend right\t-> %s\n", S)
+	}
+
+	// and check if we should merge it with right/left neighbours
+	if ilo+1 < len(S.rangev) { // right
+		if S.rangev[ilo].Hi_+1 == S.rangev[ilo+1].Lo {
+			vReplaceSlice__RangedMap_void(&S.rangev, ilo,ilo+2,
+				KeyRange{S.rangev[ilo].Lo, S.rangev[ilo+1].Hi_})
+			debugfRSet("\tmerge right\t-> %s\n", S)
+		}
+	}
+
+	if ilo > 0 { // left
+		if S.rangev[ilo-1].Hi_+1 == S.rangev[ilo].Lo {
+			vReplaceSlice__RangedMap_void(&S.rangev, ilo-1,ilo+1,
+				KeyRange{S.rangev[ilo-1].Lo, S.rangev[ilo].Hi_})
+			debugfRSet("\tmerge left\t-> %s\n", S)
+		}
+	}
+
+	// done
+*/
+}
+
+// DelRange removes range r from the map.
+func (M *_RangedMap_void) DelRange(r KeyRange) {
+	if trace_RangedMap_void {
+		fmt.Printf("\n\nDelRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer fmt.Printf("->·: %s\n", M)
+	}
+
+	M.verify()
+	defer M.verify()
+
+	if r.Empty() {
+		return
+	}
+
+	M.delRange(r)
+}
+
+// delRange deletes range r from the map and returns .entryv index where r
+// should be inserted/appended if needed.
+//
+// r must be !empty.
+func (M *_RangedMap_void) delRange(r KeyRange) (i int) {
+	// find first ilo: r.Lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_void("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		debugf_RangedMap_void("\tnon-overlap right\n")
+		return l
+	}
+
+	// find last jhi: [jhi].Lo < r.hi
+	jhi := ilo
+	for ;; jhi++ {
+		if jhi == l {
+			break
+		}
+		if M.entryv[jhi].Lo <= r.Hi_ {
+			continue
+		}
+		break
+	}
+	debugf_RangedMap_void("\tjhi: %d\n", jhi)
+
+	if jhi == 0 {
+		debugf_RangedMap_void("\tnon-overlap left\n")
+		return 0
+	}
+
+	// [ilo+1:jhi-1] should be deleted
+	// [ilo] and [jhi-1] overlap with [r.lo,r.hi) - they should be deleted, or shrinked,
+	// or split+shrinked if ilo==jhi-1 and r is inside [ilo]
+	if jhi-ilo == 1 && M.entryv[ilo].Lo < r.Lo && r.Hi_ < M.entryv[ilo].Hi_ {
+		x := M.entryv[ilo]
+		vInsert__RangedMap_void(&M.entryv, ilo, x)
+		jhi++
+		debugf_RangedMap_void("\tpresplit copy %s\t-> %s\n", x, M)
+	}
+	if M.entryv[ilo].Lo < r.Lo { // shrink left
+		M.entryv[ilo].Hi_ = r.Lo-1
+		debugf_RangedMap_void("\tshrink [%d] left \t-> %s\n", ilo, M)
+		ilo++
+	}
+	if r.Hi_ < M.entryv[jhi-1].Hi_ { // shrink right
+		M.entryv[jhi-1].Lo = r.Hi_+1
+		debugf_RangedMap_void("\tshrink [%d] right\t-> %s\n", jhi-1, M)
+		jhi--
+	}
+
+	if (jhi - ilo) > 0 {
+		vDeleteSlice__RangedMap_void(&M.entryv, ilo,jhi)
+		debugf_RangedMap_void("\tdelete M[%d:%d]\t-> %s\n", ilo, jhi, M)
+	}
+
+	// done
+	return ilo
+}
+
+// HasRange returns whether all keys from range r belong to the map.
+func (M *_RangedMap_void) HasRange(r KeyRange) (yes bool) {
+	if trace_RangedMap_void {
+		fmt.Printf("\n\nHasRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer func() {
+			fmt.Printf("->·: %v\n", yes)
+		}()
+	}
+
+	M.verify()
+
+	if r.Empty() {
+		return true
+	}
+
+	// find first ilo: r.lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_void("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return false
+	}
+
+	// scan right and verify that whole r is covered
+	lo := r.Lo
+	for {
+		e := M.entryv[ilo]
+		debugf_RangedMap_void("\te: %s\ttocheck: %s\n", e, KeyRange{lo, r.Hi_})
+
+		if lo < e.Lo {
+			return false // hole in coverage
+		}
+		if r.Hi_ <= e.Hi_ {
+			return true  // reached full coverage
+		}
+
+		lo = e.Hi_
+		if lo < KeyMax {
+			lo++
+		}
+
+		ilo++
+		if ilo == l {
+			return false // r's right not fully covered
+		}
+	}
+}
+
+// IntersectsRange returns whether some keys from range r belong to the map.
+func (M *_RangedMap_void) IntersectsRange(r KeyRange) (yes bool) {
+	if trace_RangedMap_void {
+		fmt.Printf("\n\nIntersectsRange:\n")
+		fmt.Printf("  M: %s\n", M)
+		fmt.Printf("  r: %s\n", r)
+		defer func() {
+			fmt.Printf("->·: %v\n", yes)
+		}()
+	}
+
+	M.verify()
+
+	if r.Empty() {
+		return false
+	}
+
+	// find first ilo: r.lo < [ilo].hi
+	l := len(M.entryv)
+	ilo := sort.Search(l, func(i int) bool {
+		 return r.Lo <= M.entryv[i].Hi_
+	})
+	debugf_RangedMap_void("\tilo: %d\n", ilo)
+
+	if ilo == l { // not found
+		return false
+	}
+
+	// [ilo].hi may be either inside r (≤ r.hi), or > r.hi
+	// - if it is inside  -> overlap is there,
+	// - if it is > r.hi  -> overlap is there if [ilo].lo < r.hi
+	// => in any case overlap is there if [ilo].lo < r.hi
+	return M.entryv[ilo].Lo <= r.Hi_
+}
+
+
+// --------
+
+// verify checks _RangedMap_void for internal consistency:
+// - ranges must be not overlapping and ↑
+// - adjacent ranges must map to different values
+func (M *_RangedMap_void) verify() {
+	// TODO !debug -> return
+
+	var badv []string
+	badf := func(format string, argv ...interface{}) {
+		badv = append(badv, fmt.Sprintf(format, argv...))
+	}
+	defer func() {
+		if badv != nil {
+			emsg := "M.verify: fail:\n\n"
+			for _, bad := range badv {
+				emsg += fmt.Sprintf("- %s\n", bad)
+			}
+			emsg += fmt.Sprintf("\nM: %s\n", M)
+			panic(emsg)
+		}
+	}()
+
+	hi_Prev := KeyMin
+	var v_Prev void
+	for i, e := range M.entryv {
+		hiPrev := hi_Prev + 1
+		if i > 0 {
+			if (e.Value == v_Prev) {
+				if !(hiPrev < e.Lo) { // NOTE not ≤ - adjacent ranges must be merged
+					badf("[%d]: same value: !(hiPrev < e.lo)", i)
+				}
+			} else {
+				if !(hi_Prev <= e.Lo) {
+					badf("[%d]: different value: !(hiPrev ≤ e.lo)", i)
+				}
+			}
+		}
+		if !(e.Lo <= e.Hi_) {
+			badf("[%d]: !(e.lo ≤ e.hi_)", i)
+		}
+		hi_Prev = e.Hi_
+		v_Prev  = e.Value
+	}
+}
+
+// Clone returns copy of the map.
+//
+// NOTE values are _not_ cloned.
+func (orig *_RangedMap_void) Clone() *_RangedMap_void {
+	klon := &_RangedMap_void{}
+	klon.entryv = append(klon.entryv, orig.entryv...)
+	return klon
+}
+
+// Empty returns whether the map is empty.
+func (M *_RangedMap_void) Empty() bool {
+	return len(M.entryv) == 0
+}
+
+// Equal returns whether A == B.
+func (A *_RangedMap_void) Equal(B *_RangedMap_void) bool {
+	if len(A.entryv) != len(B.entryv) {
+		return false
+	}
+	for i, ea := range A.entryv {
+		eb := B.entryv[i]
+		if ea != eb {
+			return false
+		}
+	}
+	return true
+}
+
+// Clear removes all elements from the map.
+func (M *_RangedMap_void) Clear() {
+	M.entryv = nil
+}
+
+// AllRanges returns slice of all key ranges in the set.
+//
+// TODO -> iter?
+func (M *_RangedMap_void) AllRanges() /*readonly*/[]_RangedMap_voidEntry {
+	return M.entryv
+}
+
+func (M _RangedMap_void) String() string {
+	s := "{"
+	for i, e := range M.entryv {
+		if i > 0 {
+			s += " "
+		}
+		s += e.String()
+	}
+	s += "}"
+	return s
+}
+
+func (e _RangedMap_voidEntry) String() string {
+	s := e.KeyRange.String()
+	v := fmt.Sprintf("%v", e.Value)
+	if v != "" { // omit ":<v>" in the case of set
+		s += ":" + v
+	}
+	return s
+}
+
+
+func debugf_RangedMap_void(format string, argv ...interface{}) {
+	if !debug_RangedMap_void {
+		return
+	}
+	fmt.Printf(format, argv...)
+}
+
+
+// ---- slice ops ----
+
+// vInsert__RangedMap_void inserts e into *pv[i].
+func vInsert__RangedMap_void(pv *[]_RangedMap_voidEntry, i int, e _RangedMap_voidEntry) {
+	v := *pv
+	v = append(v, _RangedMap_voidEntry{})
+	copy(v[i+1:], v[i:])
+	v[i] = e
+	*pv = v
+}
+
+// vDeleteSlice__RangedMap_void deletes *pv[lo:hi].
+func vDeleteSlice__RangedMap_void(pv *[]_RangedMap_voidEntry, lo,hi int) {
+	v := *pv
+	n := copy(v[lo:], v[hi:])
+	v = v[:lo+n]
+	*pv = v
+}
+
+// vReplaceSlice__RangedMap_void replaces *pv[lo:hi] with e.
+func vReplaceSlice__RangedMap_void(pv *[]_RangedMap_voidEntry, lo,hi int, e _RangedMap_voidEntry) {
+	v := *pv
+	n := copy(v[lo+1:], v[hi:])
+	v[lo] = e
+	v = v[:lo+1+n]
+	*pv = v
+}