diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index be4c6887d4a6d..f8d037664fb46 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -1,5 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+const RegionAnnotation = NamedTuple{(:region, :label, :value), Tuple{UnitRange{Int}, Symbol, Any}}
+
 """
     AnnotatedString{S <: AbstractString} <: AbstractString
 
@@ -20,7 +22,8 @@ annotated with labeled values.
 
 The above diagram represents a `AnnotatedString` where three ranges have been
 annotated (labeled `A`, `B`, and `C`). Each annotation holds a label (`Symbol`)
-and a value (`Any`), paired together as a `Pair{Symbol, <:Any}`.
+and a value (`Any`). These three pieces of information are held as a
+`$RegionAnnotation`.
 
 Labels do not need to be unique, the same region can hold multiple annotations
 with the same label.
@@ -50,7 +53,7 @@ See also [`AnnotatedChar`](@ref), [`annotatedstring`](@ref),
 
 ```julia
 AnnotatedString(s::S<:AbstractString) -> AnnotatedString{S}
-AnnotatedString(s::S<:AbstractString, annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, <:Any}}})
+AnnotatedString(s::S<:AbstractString, annotations::Vector{$RegionAnnotation})
 ```
 
 A AnnotatedString can also be created with [`annotatedstring`](@ref), which acts much
@@ -66,7 +69,7 @@ julia> AnnotatedString("this is an example annotated string",
 """
 struct AnnotatedString{S <: AbstractString} <: AbstractString
     string::S
-    annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
+    annotations::Vector{RegionAnnotation}
 end
 
 """
@@ -75,8 +78,8 @@ end
 A Char with annotations.
 
 More specifically, this is a simple wrapper around any other
-[`AbstractChar`](@ref), which holds a list of arbitrary labeled annotations
-(`Pair{Symbol, <:Any}`) with the wrapped character.
+[`AbstractChar`](@ref), which holds a list of arbitrary labelled annotations
+(`NamedTuple{(:label, :value), Tuple{Symbol, Any}}`) with the wrapped character.
 
 See also: [`AnnotatedString`](@ref), [`annotatedstring`](@ref), `annotations`,
 and `annotate!`.
@@ -92,7 +95,7 @@ and `annotate!`.
 
 ```julia
 AnnotatedChar(s::S) -> AnnotatedChar{S}
-AnnotatedChar(s::S, annotations::Vector{Pair{Symbol, <:Any}})
+AnnotatedChar(s::S, annotations::Vector{NamedTuple{(:label, :value), Tuple{Symbol, Any}}})
 ```
 
 # Examples
@@ -104,26 +107,37 @@ julia> AnnotatedChar('j', :label => 1)
 """
 struct AnnotatedChar{C <: AbstractChar} <: AbstractChar
     char::C
-    annotations::Vector{Pair{Symbol, Any}}
+    annotations::Vector{NamedTuple{(:label, :value), Tuple{Symbol, Any}}}
 end
 
 ## Constructors ##
 
 # When called with overly-specialised arguments
 
-AnnotatedString(s::AbstractString, annots::Vector{<:Tuple{UnitRange{Int}, <:Pair{Symbol, <:Any}}}) =
-    AnnotatedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}(annots))
+AnnotatedString(s::AbstractString, annots::Vector) =
+    AnnotatedString(s, Vector{RegionAnnotation}(annots))
+
+AnnotatedString(s::AbstractString, annots) = AnnotatedString(s, collect(RegionAnnotation, annots))
 
-AnnotatedChar(c::AbstractChar, annots::Vector{<:Pair{Symbol, <:Any}}) =
-    AnnotatedChar(c, Vector{Pair{Symbol, Any}}(annots))
+AnnotatedChar(c::AbstractChar, annots::Vector) =
+    AnnotatedChar(c, Vector{NamedTuple{(:label, :value), Tuple{Symbol, Any}}}(annots))
+
+AnnotatedChar(c::AbstractChar, annots) = AnnotatedChar(c, collect(NamedTuple{(:label, :value), Tuple{Symbol, Any}}, annots))
 
 # Constructors to avoid recursive wrapping
 
-AnnotatedString(s::AnnotatedString, annots::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}) =
+AnnotatedString(s::AnnotatedString, annots::Vector{RegionAnnotation}) =
     AnnotatedString(s.string, vcat(s.annotations, annots))
 
-AnnotatedChar(c::AnnotatedChar, annots::Vector{Pair{Symbol, Any}}) =
-    AnnotatedChar(c.char, vcat(c.annotations, annots))
+AnnotatedString(s::AnnotatedString, annots::Vector) =
+    AnnotatedString(s, Vector{RegionAnnotation}(annots))
+
+AnnotatedString(s::AnnotatedString, annots) = AnnotatedString(s, collect(RegionAnnotation, annots))
+
+AnnotatedChar(c::AnnotatedChar, annots::Vector) =
+    AnnotatedChar(c.char, vcat(c.annotations, Vector{NamedTuple{(:label, :value), Tuple{Symbol, Any}}}(annots)))
+
+AnnotatedChar(c::AnnotatedChar, annots) = AnnotatedChar(c, collect(NamedTuple{(:label, :value), Tuple{Symbol, Any}}, annots))
 
 String(s::AnnotatedString{String}) = s.string # To avoid pointless overhead
 
@@ -131,14 +145,14 @@ String(s::AnnotatedString{String}) = s.string # To avoid pointless overhead
 
 convert(::Type{AnnotatedString}, s::AnnotatedString) = s
 convert(::Type{AnnotatedString{S}}, s::S) where {S <: AbstractString} =
-    AnnotatedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}())
+    AnnotatedString(s, Vector{RegionAnnotation}())
 convert(::Type{AnnotatedString}, s::S) where {S <: AbstractString} =
     convert(AnnotatedString{S}, s)
 AnnotatedString(s::S) where {S <: AbstractString} = convert(AnnotatedString{S}, s)
 
 convert(::Type{AnnotatedChar}, c::AnnotatedChar) = c
 convert(::Type{AnnotatedChar{C}}, c::C) where { C <: AbstractChar } =
-    AnnotatedChar{C}(c, Vector{Pair{Symbol, Any}}())
+    AnnotatedChar{C}(c, Vector{NamedTuple{(:label, :value), Tuple{Symbol, Any}}}())
 convert(::Type{AnnotatedChar}, c::C) where { C <: AbstractChar } =
     convert(AnnotatedChar{C}, c)
 
@@ -164,7 +178,7 @@ lastindex(s::AnnotatedString) = lastindex(s.string)
 function getindex(s::AnnotatedString, i::Integer)
     @boundscheck checkbounds(s, i)
     @inbounds if isvalid(s, i)
-        AnnotatedChar(s.string[i], Pair{Symbol, Any}[last(x) for x in annotations(s, i)])
+        AnnotatedChar(s.string[i], NamedTuple{(:label, :value), Tuple{Symbol, Any}}[(; label, value) for (; label, value) in annotations(s, i)])
     else
         string_index_err(s, i)
     end
@@ -178,7 +192,8 @@ function show(io::IO, s::A) where {A <: AnnotatedString}
     print(io, '(')
     show(io, s.string)
     print(io, ", ")
-    show(IOContext(io, :typeinfo => typeof(annotations(s))), annotations(s))
+    tupanns = Vector{Tuple{UnitRange{Int}, Symbol, Any}}(map(values, s.annotations))
+    show(IOContext(io, :typeinfo => typeof(tupanns)), tupanns)
     print(io, ')')
 end
 
@@ -247,27 +262,27 @@ function annotatedstring(xs...)
     size = mapreduce(_str_sizehint, +, xs)
     buf = IOBuffer(sizehint=size)
     s = IOContext(buf, :color => true)
-    annotations = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    annotations = Vector{RegionAnnotation}()
     for x in xs
         size = filesize(s.io)
         if x isa AnnotatedString
-            for (region, annot) in x.annotations
-                push!(annotations, (size .+ (region), annot))
+            for annot in x.annotations
+                push!(annotations, setindex(annot, annot.region .+ size, :region))
             end
             print(s, x.string)
         elseif x isa SubString{<:AnnotatedString}
-            for (region, annot) in x.string.annotations
-                start, stop = first(region), last(region)
+            for annot in x.string.annotations
+                start, stop = first(annot.region), last(annot.region)
                 if start <= x.offset + x.ncodeunits && stop > x.offset
                     rstart = size + max(0, start - x.offset - 1) + 1
                     rstop = size + min(stop, x.offset + x.ncodeunits) - x.offset
-                    push!(annotations, (rstart:rstop, annot))
+                    push!(annotations, setindex(annot, rstart:rstop, :region))
                 end
             end
             print(s, SubString(x.string.string, x.offset, x.ncodeunits, Val(:noshift)))
         elseif x isa AnnotatedChar
             for annot in x.annotations
-                push!(annotations, (1+size:1+size, annot))
+                push!(annotations, (region=1+size:1+size, annot...))
             end
             print(s, x.char)
         else
@@ -280,7 +295,7 @@ end
 
 annotatedstring(s::AnnotatedString) = s
 annotatedstring(c::AnnotatedChar) =
-    AnnotatedString(string(c.char), [(1:ncodeunits(c), annot) for annot in c.annotations])
+    AnnotatedString(string(c.char), [(region=1:ncodeunits(c), annot...) for annot in c.annotations])
 
 AnnotatedString(s::SubString{<:AnnotatedString}) = annotatedstring(s)
 
@@ -288,18 +303,19 @@ function repeat(str::AnnotatedString, r::Integer)
     r == 0 && return one(AnnotatedString)
     r == 1 && return str
     unannot = repeat(str.string, r)
-    annotations = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    annotations = Vector{RegionAnnotation}()
     len = ncodeunits(str)
     fullregion = firstindex(str):lastindex(str)
-    if allequal(first, str.annotations) && first(first(str.annotations)) == fullregion
+    if isempty(str.annotations)
+    elseif allequal(a -> a.region, str.annotations) && first(str.annotations).region == fullregion
         newfullregion = firstindex(unannot):lastindex(unannot)
-        for (_, annot) in str.annotations
-            push!(annotations, (newfullregion, annot))
+        for annot in str.annotations
+            push!(annotations, setindex(annot, newfullregion, :region))
         end
     else
         for offset in 0:len:(r-1)*len
-            for (region, annot) in str.annotations
-                push!(annotations, (region .+ offset, annot))
+            for annot in str.annotations
+                push!(annotations, setindex(annot, annot.region .+ offset, :region))
             end
         end
     end
@@ -312,16 +328,18 @@ repeat(str::SubString{<:AnnotatedString}, r::Integer) =
 function repeat(c::AnnotatedChar, r::Integer)
     str = repeat(c.char, r)
     fullregion = firstindex(str):lastindex(str)
-    AnnotatedString(str, [(fullregion, annot) for annot in c.annotations])
+    AnnotatedString(str, [(region=fullregion, annot...) for annot in c.annotations])
 end
 
 function reverse(s::AnnotatedString)
     lastind = lastindex(s)
-    AnnotatedString(reverse(s.string),
-                 [(UnitRange(1 + lastind - last(region),
-                             1 + lastind - first(region)),
-                   annot)
-                  for (region, annot) in s.annotations])
+    AnnotatedString(
+        reverse(s.string),
+        [setindex(annot,
+                  UnitRange(1 + lastind - last(annot.region),
+                            1 + lastind - first(annot.region)),
+                  :region)
+         for annot in s.annotations])
 end
 
 # TODO optimise?
@@ -331,18 +349,17 @@ reverse(s::SubString{<:AnnotatedString}) = reverse(AnnotatedString(s))
 
 ## End AbstractString interface ##
 
-function _annotate!(annlist::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any}))
-    label, val = labelval
-    if val === nothing
-        deleteat!(annlist, findall(ann -> ann[1] == range && first(ann[2]) === label, annlist))
+function _annotate!(annlist::Vector{RegionAnnotation}, region::UnitRange{Int}, label::Symbol, @nospecialize(value::Any))
+    if value === nothing
+        deleteat!(annlist, findall(ann -> ann.region == region && ann.label === label, annlist))
     else
-        push!(annlist, (range, Pair{Symbol, Any}(label, val)))
+        push!(annlist, (; region, label, value))
     end
 end
 
 """
-    annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol => value)
-    annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol => value)
+    annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol, value)
+    annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol, value)
 
 Annotate a `range` of `str` (or the entire string) with a labeled value (`label` => `value`).
 To remove existing `label` annotations, use a value of `nothing`.
@@ -350,30 +367,30 @@ To remove existing `label` annotations, use a value of `nothing`.
 The order in which annotations are applied to `str` is semantically meaningful,
 as described in [`AnnotatedString`](@ref).
 """
-annotate!(s::AnnotatedString, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any})) =
-    (_annotate!(s.annotations, range, labelval); s)
+annotate!(s::AnnotatedString, range::UnitRange{Int}, label::Symbol, @nospecialize(val::Any)) =
+    (_annotate!(s.annotations, range, label, val); s)
 
-annotate!(ss::AnnotatedString, @nospecialize(labelval::Pair{Symbol, <:Any})) =
-    annotate!(ss, firstindex(ss):lastindex(ss), labelval)
+annotate!(ss::AnnotatedString, label::Symbol, @nospecialize(val::Any)) =
+    annotate!(ss, firstindex(ss):lastindex(ss), label, val)
 
-annotate!(s::SubString{<:AnnotatedString}, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any})) =
-    (annotate!(s.string, s.offset .+ (range), labelval); s)
+annotate!(s::SubString{<:AnnotatedString}, range::UnitRange{Int}, label::Symbol, @nospecialize(val::Any)) =
+    (annotate!(s.string, s.offset .+ (range), label, val); s)
 
-annotate!(s::SubString{<:AnnotatedString}, @nospecialize(labelval::Pair{Symbol, <:Any})) =
-    (annotate!(s.string, s.offset .+ (1:s.ncodeunits), labelval); s)
+annotate!(s::SubString{<:AnnotatedString}, label::Symbol, @nospecialize(val::Any)) =
+    (annotate!(s.string, s.offset .+ (1:s.ncodeunits), label, val); s)
 
 """
-    annotate!(char::AnnotatedChar, label::Symbol => value)
+    annotate!(char::AnnotatedChar, label::Symbol, value::Any)
 
 Annotate `char` with the pair `label => value`.
 """
-annotate!(c::AnnotatedChar, @nospecialize(labelval::Pair{Symbol, <:Any})) =
-    (push!(c.annotations, labelval); c)
+annotate!(c::AnnotatedChar, label::Symbol, @nospecialize(val::Any)) =
+    (push!(c.annotations, (; label, val)); c)
 
 """
     annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
                 [position::Union{Integer, UnitRange}]) ->
-        Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
+        Vector{RegionAnnotation}
 
 Get all annotations that apply to `str`. Should `position` be provided, only
 annotations that overlap with `position` will be returned.
@@ -389,15 +406,16 @@ See also: [`annotate!`](@ref).
 annotations(s::AnnotatedString) = s.annotations
 
 function annotations(s::SubString{<:AnnotatedString})
-    map(((region, annot),) -> (first(region)-s.offset:last(region)-s.offset, annot),
-        annotations(s.string, s.offset+1:s.offset+s.ncodeunits))
+    RegionAnnotation[
+        setindex(ann, first(ann.region)-s.offset:last(ann.region)-s.offset, :region)
+        for ann in annotations(s.string, s.offset+1:s.offset+s.ncodeunits)]
 end
 
 function annotations(s::AnnotatedString, pos::UnitRange{<:Integer})
     # TODO optimise
-    Tuple{UnitRange{Int64}, Pair{Symbol, Any}}[
-        (max(first(pos), first(region)):min(last(pos), last(region)), annot)
-        for (region, annot) in s.annotations if !isempty(intersect(pos, region))]
+    RegionAnnotation[
+        setindex(ann, max(first(pos), first(ann.region)):min(last(pos), last(ann.region)), :region)
+        for ann in s.annotations if !isempty(intersect(pos, ann.region))]
 end
 
 annotations(s::AnnotatedString, pos::Integer) = annotations(s, pos:pos)
@@ -409,7 +427,7 @@ annotations(s::SubString{<:AnnotatedString}, pos::UnitRange{<:Integer}) =
     annotations(s.string, first(pos)+s.offset:last(pos)+s.offset)
 
 """
-    annotations(chr::AnnotatedChar) -> Vector{Pair{Symbol, Any}}
+    annotations(chr::AnnotatedChar) -> Vector{NamedTuple{(:label, :value), Tuple{Symbol, Any}}}
 
 Get all annotations of `chr`, in the form of a vector of annotation pairs.
 """
@@ -434,7 +452,7 @@ string type of `str`).
 """
 function annotated_chartransform(f::Function, str::AnnotatedString, state=nothing)
     outstr = IOBuffer()
-    annots = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
+    annots = RegionAnnotation[]
     bytepos = firstindex(str) - 1
     offsets = [bytepos => 0]
     for c in str.string
@@ -451,11 +469,10 @@ function annotated_chartransform(f::Function, str::AnnotatedString, state=nothin
         end
     end
     for annot in str.annotations
-        region, value = annot
-        start, stop = first(region), last(region)
+        start, stop = first(annot.region), last(annot.region)
         start_offset = last(offsets[findlast(<=(start) ∘ first, offsets)::Int])
         stop_offset  = last(offsets[findlast(<=(stop) ∘ first, offsets)::Int])
-        push!(annots, ((start + start_offset):(stop + stop_offset), value))
+        push!(annots, setindex(annot, (start + start_offset):(stop + stop_offset), :region))
     end
     AnnotatedString(String(take!(outstr)), annots)
 end
@@ -464,10 +481,10 @@ end
 
 struct AnnotatedIOBuffer <: AbstractPipe
     io::IOBuffer
-    annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
+    annotations::Vector{RegionAnnotation}
 end
 
-AnnotatedIOBuffer(io::IOBuffer) = AnnotatedIOBuffer(io, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}())
+AnnotatedIOBuffer(io::IOBuffer) = AnnotatedIOBuffer(io, Vector{RegionAnnotation}())
 AnnotatedIOBuffer() = AnnotatedIOBuffer(IOBuffer())
 
 function show(io::IO, aio::AnnotatedIOBuffer)
@@ -489,8 +506,8 @@ copy(io::AnnotatedIOBuffer) = AnnotatedIOBuffer(copy(io.io), copy(io.annotations
 
 annotations(io::AnnotatedIOBuffer) = io.annotations
 
-annotate!(io::AnnotatedIOBuffer, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any})) =
-    (_annotate!(io.annotations, range, labelval); io)
+annotate!(io::AnnotatedIOBuffer, range::UnitRange{Int}, label::Symbol, @nospecialize(val::Any)) =
+    (_annotate!(io.annotations, range, label, val); io)
 
 function write(io::AnnotatedIOBuffer, astr::Union{AnnotatedString, SubString{<:AnnotatedString}})
     astr = AnnotatedString(astr)
@@ -501,7 +518,7 @@ function write(io::AnnotatedIOBuffer, astr::Union{AnnotatedString, SubString{<:A
 end
 
 write(io::AnnotatedIOBuffer, c::AnnotatedChar) =
-    write(io, AnnotatedString(string(c), map(a -> (1:ncodeunits(c), a), annotations(c))))
+    write(io, AnnotatedString(string(c), [(region=1:ncodeunits(c), a...) for a in c.annotations]))
 write(io::AnnotatedIOBuffer, x::AbstractString) = write(io.io, x)
 write(io::AnnotatedIOBuffer, s::Union{SubString{String}, String}) = write(io.io, s)
 write(io::AnnotatedIOBuffer, b::UInt8) = write(io.io, b)
@@ -512,8 +529,8 @@ function write(dest::AnnotatedIOBuffer, src::AnnotatedIOBuffer)
     srcpos = position(src)
     nb = write(dest.io, src.io)
     isappending || _clear_annotations_in_region!(dest.annotations, destpos:destpos+nb)
-    srcannots = [(max(1 + srcpos, first(region)):last(region), annot)
-                 for (region, annot) in src.annotations if first(region) >= srcpos]
+    srcannots = [setindex(annot, max(1 + srcpos, first(annot.region)):last(annot.region), :region)
+                 for annot in src.annotations if first(annot.region) >= srcpos]
     _insert_annotations!(dest, srcannots, destpos - srcpos)
     nb
 end
@@ -537,7 +554,7 @@ function write(io::AbstractPipe, c::AnnotatedChar)
 end
 
 """
-    _clear_annotations_in_region!(annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}, span::UnitRange{Int})
+    _clear_annotations_in_region!(annotations::Vector{RegionAnnotation}, span::UnitRange{Int})
 
 Erase the presence of `annotations` within a certain `span`.
 
@@ -545,21 +562,27 @@ This operates by removing all elements of `annotations` that are entirely
 contained in `span`, truncating ranges that partially overlap, and splitting
 annotations that subsume `span` to just exist either side of `span`.
 """
-function _clear_annotations_in_region!(annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}, span::UnitRange{Int})
+function _clear_annotations_in_region!(annotations::Vector{RegionAnnotation}, span::UnitRange{Int})
     # Clear out any overlapping pre-existing annotations.
-    filter!(((region, _),) -> first(region) < first(span) || last(region) > last(span), annotations)
-    extras = Tuple{Int, Tuple{UnitRange{Int}, Pair{Symbol, Any}}}[]
+    filter!(ann -> first(ann.region) < first(span) || last(ann.region) > last(span), annotations)
+    extras = Tuple{Int, RegionAnnotation}[]
     for i in eachindex(annotations)
-        region, annot = annotations[i]
+        annot = annotations[i]
+        region = annot.region
         # Test for partial overlap
         if first(region) <= first(span) <= last(region) || first(region) <= last(span) <= last(region)
-            annotations[i] = (if first(region) < first(span)
-                                        first(region):first(span)-1
-                                    else last(span)+1:last(region) end, annot)
+            annotations[i] =
+                setindex(annot,
+                         if first(region) < first(span)
+                             first(region):first(span)-1
+                         else
+                             last(span)+1:last(region)
+                         end,
+                         :region)
             # If `span` fits exactly within `region`, then we've only copied over
             # the beginning overhang, but also need to conserve the end overhang.
             if first(region) < first(span) && last(span) < last(region)
-                push!(extras, (i, (last(span)+1:last(region), annot)))
+                push!(extras, (i, setindex(annot, last(span)+1:last(region), :region)))
             end
         end
     end
@@ -571,7 +594,7 @@ function _clear_annotations_in_region!(annotations::Vector{Tuple{UnitRange{Int},
 end
 
 """
-    _insert_annotations!(io::AnnotatedIOBuffer, annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}, offset::Int = position(io))
+    _insert_annotations!(io::AnnotatedIOBuffer, annotations::Vector{RegionAnnotation}, offset::Int = position(io))
 
 Register new `annotations` in `io`, applying an `offset` to their regions.
 
@@ -587,19 +610,19 @@ This is implemented so that one can say write an `AnnotatedString` to an
 `AnnotatedIOBuffer` one character at a time without needlessly producing a
 new annotation for each character.
 """
-function _insert_annotations!(io::AnnotatedIOBuffer, annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}, offset::Int = position(io))
+function _insert_annotations!(io::AnnotatedIOBuffer, annotations::Vector{RegionAnnotation}, offset::Int = position(io))
     run = 0
-    if !isempty(io.annotations) && last(first(last(io.annotations))) == offset
+    if !isempty(io.annotations) && last(last(io.annotations).region) == offset
         for i in reverse(axes(annotations, 1))
             annot = annotations[i]
-            first(first(annot)) == 1 || continue
+            first(annot.region) == 1 || continue
             i <= length(io.annotations) || continue
-            if last(annot) == last(last(io.annotations))
+            if annot.label == last(io.annotations).label && annot.value == last(io.annotations).value
                 valid_run = true
                 for runlen in 1:i
-                    new_range, new_annot = annotations[begin+runlen-1]
-                    old_range, old_annot = io.annotations[end-i+runlen]
-                    if last(old_range) != offset || first(new_range) != 1 || old_annot != new_annot
+                    new = annotations[begin+runlen-1]
+                    old = io.annotations[end-i+runlen]
+                    if last(old.region) != offset || first(new.region) != 1 || old.label != new.label || old.value != new.value
                         valid_run = false
                         break
                     end
@@ -613,14 +636,14 @@ function _insert_annotations!(io::AnnotatedIOBuffer, annotations::Vector{Tuple{U
     end
     for runindex in 0:run-1
         old_index = lastindex(io.annotations) - run + 1 + runindex
-        old_region, annot = io.annotations[old_index]
-        new_region, _ = annotations[begin+runindex]
-        io.annotations[old_index] = (first(old_region):last(new_region)+offset, annot)
+        old = io.annotations[old_index]
+        new = annotations[begin+runindex]
+        io.annotations[old_index] = setindex(old, first(old.region):last(new.region)+offset, :region)
     end
     for index in run+1:lastindex(annotations)
-        region, annot = annotations[index]
-        start, stop = first(region), last(region)
-        push!(io.annotations, (start+offset:stop+offset, annot))
+        annot = annotations[index]
+        start, stop = first(annot.region), last(annot.region)
+        push!(io.annotations, setindex(annotations[index], start+offset:stop+offset, :region))
     end
 end
 
@@ -628,8 +651,8 @@ function read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{T}}) where {T <: Abs
     if (start = position(io)) == 0
         AnnotatedString(read(io.io, T), copy(io.annotations))
     else
-        annots = [(UnitRange{Int}(max(1, first(region) - start), last(region)-start), val)
-                  for (region, val) in io.annotations if last(region) > start]
+        annots = [setindex(annot, UnitRange{Int}(max(1, first(annot.region) - start), last(annot.region)-start), :region)
+                  for annot in io.annotations if last(annot.region) > start]
         AnnotatedString(read(io.io, T), annots)
     end
 end
@@ -639,7 +662,7 @@ read(io::AnnotatedIOBuffer, ::Type{AnnotatedString}) = read(io, AnnotatedString{
 function read(io::AnnotatedIOBuffer, ::Type{AnnotatedChar{T}}) where {T <: AbstractChar}
     pos = position(io)
     char = read(io.io, T)
-    annots = Pair{Symbol, Any}[annot for (range, annot) in io.annotations if pos+1 in range]
+    annots = [NamedTuple{(:label, :value)}(annot) for annot in io.annotations if pos+1 in annot.region]
     AnnotatedChar(char, annots)
 end
 read(io::AnnotatedIOBuffer, ::Type{AnnotatedChar{AbstractChar}}) = read(io, AnnotatedChar{Char})
@@ -647,8 +670,8 @@ read(io::AnnotatedIOBuffer, ::Type{AnnotatedChar}) = read(io, AnnotatedChar{Char
 
 function truncate(io::AnnotatedIOBuffer, size::Integer)
     truncate(io.io, size)
-    filter!(((range, _),) -> first(range) <= size, io.annotations)
-    map!(((range, val),) -> (first(range):min(size, last(range)), val),
+    filter!(ann -> first(ann.region) <= size, io.annotations)
+    map!(ann -> setindex(ann, first(ann.region):min(size, last(ann.region)), :region),
          io.annotations, io.annotations)
     io
 end
diff --git a/base/strings/io.jl b/base/strings/io.jl
index acbd945c8e137..e1544d16cc52a 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -811,12 +811,12 @@ function AnnotatedString(chars::AbstractVector{C}) where {C<:AbstractChar}
             end
         end
     end
-    annots = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
+    annots = RegionAnnotation[]
     point = 1
     for c in chars
         if c isa AnnotatedChar
             for annot in c.annotations
-                push!(annots, (point:point, annot))
+                push!(annots, (point:point, annot...))
             end
         end
         point += ncodeunits(c)
diff --git a/doc/src/manual/strings.md b/doc/src/manual/strings.md
index 5ba27b3921cec..219e1c9468feb 100644
--- a/doc/src/manual/strings.md
+++ b/doc/src/manual/strings.md
@@ -1226,7 +1226,7 @@ to keep the string annotations.
 
 ```jldoctest
 julia> str = Base.AnnotatedString("hello there",
-               [(1:5, :word => :greeting), (7:11, :label => 1)])
+               [(1:5, :word, :greeting), (7:11, :label, 1)])
 "hello there"
 
 julia> length(str)
@@ -1238,7 +1238,7 @@ julia> lpad(str, 14)
 julia> typeof(lpad(str, 7))
 Base.AnnotatedString{String}
 
-julia> str2 = Base.AnnotatedString(" julia", [(2:6, :face => :magenta)])
+julia> str2 = Base.AnnotatedString(" julia", [(2:6, :face, :magenta)])
 " julia"
 
 julia> Base.annotatedstring(str, str2)
diff --git a/stdlib/Markdown/src/render/terminal/formatting.jl b/stdlib/Markdown/src/render/terminal/formatting.jl
index 3274483801c77..c9dadfb5f3d94 100644
--- a/stdlib/Markdown/src/render/terminal/formatting.jl
+++ b/stdlib/Markdown/src/render/terminal/formatting.jl
@@ -19,9 +19,9 @@ function with_output_annotations(f::Function, io::AnnotIO, annots::Pair{Symbol,
     start = position(aio) + 1
     f(io)
     stop = position(aio)
-    sortedindex = searchsortedlast(aio.annotations, (start:stop,), by=first)
+    sortedindex = searchsortedlast(aio.annotations, (region=start:stop,), by=a -> a.region)
     for (i, annot) in enumerate(annots)
-        insert!(aio.annotations, sortedindex + i, (start:stop, annot))
+        insert!(aio.annotations, sortedindex + i, (start:stop, annot...))
     end
 end
 
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index 90aaadd6ede24..c7e7610105e84 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -2,7 +2,7 @@
 
 @testset "AnnotatedString" begin
     str = Base.AnnotatedString("some string")
-    @test str == Base.AnnotatedString(str.string, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[])
+    @test str == Base.AnnotatedString(str.string, Base.RegionAnnotation[])
     @test length(str) == 11
     @test ncodeunits(str) == 11
     @test convert(Base.AnnotatedString, str) === str
@@ -15,9 +15,9 @@
     @test str * str == Base.AnnotatedString("some stringsome string")
     @test str[3:4] == SubString("me")
     @test SubString("me") == str[3:4]
-    Base.annotate!(str, 1:4, :thing => 0x01)
-    Base.annotate!(str, 6:11, :other => 0x02)
-    Base.annotate!(str, 1:11, :all => 0x03)
+    Base.annotate!(str, 1:4, :thing, 0x01)
+    Base.annotate!(str, 6:11, :other, 0x02)
+    Base.annotate!(str, 1:11, :all, 0x03)
     #  :thing :other
     #  ┌┸─┐ ┌──┸─┐
     # "some string"
@@ -27,21 +27,21 @@
     @test str[3:4] != SubString("me")
     @test SubString("me") != str[3:4]
     @test Base.AnnotatedString(str[3:4]) ==
-        Base.AnnotatedString("me", [(1:2, :thing => 0x01), (1:2, :all => 0x03)])
+        Base.AnnotatedString("me", [(1:2, :thing, 0x01), (1:2, :all, 0x03)])
     @test Base.AnnotatedString(str[3:6]) ==
-        Base.AnnotatedString("me s", [(1:2, :thing => 0x01), (4:4, :other => 0x02), (1:4, :all => 0x03)])
-    @test str == Base.AnnotatedString("some string", [(1:4, :thing => 0x01), (6:11, :other => 0x02), (1:11, :all => 0x03)])
+        Base.AnnotatedString("me s", [(1:2, :thing, 0x01), (4:4, :other, 0x02), (1:4, :all, 0x03)])
+    @test str == Base.AnnotatedString("some string", [(1:4, :thing, 0x01), (6:11, :other, 0x02), (1:11, :all, 0x03)])
     @test str != Base.AnnotatedString("some string")
-    @test str != Base.AnnotatedString("some string", [(1:1, :thing => 0x01), (1:11, :all => 0x03), (6:6, :other => 0x02)])
-    @test str != Base.AnnotatedString("some string", [(1:4, :thing => 0x11), (1:11, :all => 0x13), (6:11, :other => 0x12)])
-    @test str != Base.AnnotatedString("some thingg", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (6:11, :other => 0x02)])
-    @test Base.AnnotatedString([Base.AnnotatedChar('a', [:a => 1]), Base.AnnotatedChar('b', [:b => 2])]) ==
-        Base.AnnotatedString("ab", [(1:1, :a => 1), (2:2, :b => 2)])
+    @test str != Base.AnnotatedString("some string", [(1:1, :thing, 0x01), (1:11, :all, 0x03), (6:6, :other, 0x02)])
+    @test str != Base.AnnotatedString("some string", [(1:4, :thing, 0x11), (1:11, :all, 0x13), (6:11, :other, 0x12)])
+    @test str != Base.AnnotatedString("some thingg", [(1:4, :thing, 0x01), (1:11, :all, 0x03), (6:11, :other, 0x02)])
+    @test Base.AnnotatedString([Base.AnnotatedChar('a', [(:a, 1)]), Base.AnnotatedChar('b', [(:b, 2)])]) ==
+        Base.AnnotatedString("ab", [(1:1, :a, 1), (2:2, :b, 2)])
     let allstrings =
-        ['a', Base.AnnotatedChar('a'), Base.AnnotatedChar('a', [:aaa => 0x04]),
+        ['a', Base.AnnotatedChar('a'), Base.AnnotatedChar('a', [(:aaa, 0x04)]),
          "a string", Base.AnnotatedString("a string"),
-         Base.AnnotatedString("a string", [(1:2, :hmm => '%')]),
-         SubString(Base.AnnotatedString("a string", [(1:2, :hmm => '%')]), 1:1)]
+         Base.AnnotatedString("a string", [(1:2, :hmm, '%')]),
+         SubString(Base.AnnotatedString("a string", [(1:2, :hmm, '%')]), 1:1)]
         for str1 in repeat(allstrings, 2)
             for str2 in repeat(allstrings, 2)
                 @test String(str1 * str2) ==
@@ -54,10 +54,10 @@
         end
     end
     # @test collect(Base.eachstyle(str)) ==
-    #     [("some", [:thing => 0x01, :all => 0x03]),
-    #     (" string", [:all => 0x03, :other => 0x02])]
+    #     [("some", [:thing, 0x01, :all, 0x03]),
+    #     (" string", [:all, 0x03, :other, 0x02])]
     @test chopprefix(sprint(show, str), "Base.") ==
-        "AnnotatedString{String}(\"some string\", [(1:4, :thing => 0x01), (6:11, :other => 0x02), (1:11, :all => 0x03)])"
+        "AnnotatedString{String}(\"some string\", [(1:4, :thing, 0x01), (6:11, :other, 0x02), (1:11, :all, 0x03)])"
     @test eval(Meta.parse(repr(str))) == str
     @test sprint(show, MIME("text/plain"), str) == "\"some string\""
 end
@@ -70,16 +70,16 @@ end
     @test uppercase(chr) == Base.AnnotatedChar('C')
     @test titlecase(chr) == Base.AnnotatedChar('C')
     @test lowercase(Base.AnnotatedChar('C')) == chr
-    str = Base.AnnotatedString("hmm", [(1:1, :attr => "h0h0"),
-                               (1:2, :attr => "h0m1"),
-                               (2:3, :attr => "m1m2")])
-    @test str[1] == Base.AnnotatedChar('h', Pair{Symbol, Any}[:attr => "h0h0"])
-    @test str[2] == Base.AnnotatedChar('m', Pair{Symbol, Any}[:attr => "h0m1", :attr => "m1m2"])
-    @test str[3] == Base.AnnotatedChar('m', Pair{Symbol, Any}[:attr => "m1m2"])
+    str = Base.AnnotatedString("hmm", [(1:1, :attr, "h0h0"),
+                               (1:2, :attr, "h0m1"),
+                               (2:3, :attr, "m1m2")])
+    @test str[1] == Base.AnnotatedChar('h', [(:attr, "h0h0")])
+    @test str[2] == Base.AnnotatedChar('m', [(:attr, "h0m1"), (:attr, "m1m2")])
+    @test str[3] == Base.AnnotatedChar('m', [(:attr, "m1m2")])
 end
 
 @testset "Styling preservation" begin
-    str = Base.AnnotatedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (6:11, :other => 0x02)])
+    str = Base.AnnotatedString("some string", [(1:4, :thing, 0x01), (1:11, :all, 0x03), (6:11, :other, 0x02)])
     @test match(r".e", str).match == str[3:4]
     @test  match(r"(.e)", str).captures == [str[3:4]]
     let m0 = match(r"(.)e", str)
@@ -89,43 +89,43 @@ end
         end
     end
     @test lpad(str, 12) ==
-        Base.AnnotatedString(" some string", [(2:5, :thing => 0x01),
-                                      (2:12, :all => 0x03),
-                                      (7:12, :other => 0x02)])
+        Base.AnnotatedString(" some string", [(2:5, :thing, 0x01),
+                                      (2:12, :all, 0x03),
+                                      (7:12, :other, 0x02)])
     @test rpad(str, 12) ==
-        Base.AnnotatedString("some string ", [(1:4, :thing => 0x01),
-                                      (1:11, :all => 0x03),
-                                      (6:11, :other => 0x02)])
-    str1 = Base.AnnotatedString("test", [(1:4, :label => 5)])
-    str2 = Base.AnnotatedString("case", [(2:3, :label => "oomph")])
+        Base.AnnotatedString("some string ", [(1:4, :thing, 0x01),
+                                      (1:11, :all, 0x03),
+                                      (6:11, :other, 0x02)])
+    str1 = Base.AnnotatedString("test", [(1:4, :label, 5)])
+    str2 = Base.AnnotatedString("case", [(2:3, :label, "oomph")])
     @test join([str1, str1], ' ') ==
         Base.AnnotatedString("test test",
-                     [(1:4, :label => 5),
-                      (6:9, :label => 5)])
-    @test join([str1, str1], Base.AnnotatedString(" ", [(1:1, :label => 2)])) ==
+                     [(1:4, :label, 5),
+                      (6:9, :label, 5)])
+    @test join([str1, str1], Base.AnnotatedString(" ", [(1:1, :label, 2)])) ==
         Base.AnnotatedString("test test",
-                     [(1:4, :label => 5),
-                      (5:5, :label => 2),
-                      (6:9, :label => 5)])
+                     [(1:4, :label, 5),
+                      (5:5, :label, 2),
+                      (6:9, :label, 5)])
     @test join((String(str1), str1), ' ') ==
-        Base.AnnotatedString("test test", [(6:9, :label => 5)])
-    @test repeat(str1, 2) == Base.AnnotatedString("testtest", [(1:8, :label => 5)])
-    @test repeat(str2, 2) == Base.AnnotatedString("casecase", [(2:3, :label => "oomph"),
-                                                       (6:7, :label => "oomph")])
-    @test repeat(str1[1], 3) == Base.AnnotatedString("ttt", [(1:3, :label => 5)])
-    @test reverse(str1) == Base.AnnotatedString("tset", [(1:4, :label => 5)])
-    @test reverse(str2) == Base.AnnotatedString("esac", [(2:3, :label => "oomph")])
+        Base.AnnotatedString("test test", [(6:9, :label, 5)])
+    @test repeat(str1, 2) == Base.AnnotatedString("testtest", [(1:8, :label, 5)])
+    @test repeat(str2, 2) == Base.AnnotatedString("casecase", [(2:3, :label, "oomph"),
+                                                       (6:7, :label, "oomph")])
+    @test repeat(str1[1], 3) == Base.AnnotatedString("ttt", [(1:3, :label, 5)])
+    @test reverse(str1) == Base.AnnotatedString("tset", [(1:4, :label, 5)])
+    @test reverse(str2) == Base.AnnotatedString("esac", [(2:3, :label, "oomph")])
 end
 
 @testset "Unicode" begin
     for words in (["ᲃase", "cɦɒnɡeȿ", "can", "CHⱯNGE", "Сodeunıts"],
                   ["Сodeunıts", "ᲃase", "cɦɒnɡeȿ", "can", "CHⱯNGE"])
-        ann_words = [Base.AnnotatedString(w, [(1:ncodeunits(w), :i => i)])
+        ann_words = [Base.AnnotatedString(w, [(1:ncodeunits(w), :i, i)])
                      for (i, w) in enumerate(words)]
         ann_str = join(ann_words, '-')
         for transform in (lowercase, uppercase, titlecase)
             t_words = map(transform, words)
-            ann_t_words = [Base.AnnotatedString(w, [(1:ncodeunits(w), :i => i)])
+            ann_t_words = [Base.AnnotatedString(w, [(1:ncodeunits(w), :i, i)])
                         for (i, w) in enumerate(t_words)]
             ann_t_str = join(ann_t_words, '-')
             t_ann_str = transform(ann_str)
@@ -134,7 +134,7 @@ end
         end
         for transform in (uppercasefirst, lowercasefirst)
             t_words = vcat(transform(first(words)), words[2:end])
-            ann_t_words = [Base.AnnotatedString(w, [(1:ncodeunits(w), :i => i)])
+            ann_t_words = [Base.AnnotatedString(w, [(1:ncodeunits(w), :i, i)])
                         for (i, w) in enumerate(t_words)]
             ann_t_str = join(ann_t_words, '-')
             t_ann_str = transform(ann_str)
@@ -146,31 +146,32 @@ end
 
 @testset "AnnotatedIOBuffer" begin
     aio = Base.AnnotatedIOBuffer()
+    vec2ann(v::Vector{<:Tuple}) = collect(Base.RegionAnnotation, v)
     # Append-only writing
-    @test write(aio, Base.AnnotatedString("hello", [(1:5, :tag => 1)])) == 5
+    @test write(aio, Base.AnnotatedString("hello", [(1:5, :tag, 1)])) == 5
     @test write(aio, ' ') == 1
-    @test write(aio, Base.AnnotatedString("world", [(1:5, :tag => 2)])) == 5
-    @test Base.annotations(aio) == [(1:5, :tag => 1), (7:11, :tag => 2)]
+    @test write(aio, Base.AnnotatedString("world", [(1:5, :tag, 2)])) == 5
+    @test Base.annotations(aio) == vec2ann([(1:5, :tag, 1), (7:11, :tag, 2)])
     # Check `annotate!`, including region sorting
     @test truncate(aio, 0).io.size == 0
     @test write(aio, "hello world") == ncodeunits("hello world")
-    @test Base.annotate!(aio, 1:5, :tag => 1) === aio
-    @test Base.annotate!(aio, 7:11, :tag => 2) === aio
-    @test Base.annotations(aio) == [(1:5, :tag => 1), (7:11, :tag => 2)]
+    @test Base.annotate!(aio, 1:5, :tag, 1) === aio
+    @test Base.annotate!(aio, 7:11, :tag, 2) === aio
+    @test Base.annotations(aio) == vec2ann([(1:5, :tag, 1), (7:11, :tag, 2)])
     # Reading
     @test read(seekstart(deepcopy(aio.io)), String) == "hello world"
     @test read(seekstart(deepcopy(aio)), String) == "hello world"
-    @test read(seek(aio, 0), Base.AnnotatedString) == Base.AnnotatedString("hello world", [(1:5, :tag => 1), (7:11, :tag => 2)])
-    @test read(seek(aio, 1), Base.AnnotatedString) == Base.AnnotatedString("ello world", [(1:4, :tag => 1), (6:10, :tag => 2)])
-    @test read(seek(aio, 4), Base.AnnotatedString) == Base.AnnotatedString("o world", [(1:1, :tag => 1), (3:7, :tag => 2)])
-    @test read(seek(aio, 5), Base.AnnotatedString) == Base.AnnotatedString(" world", [(2:6, :tag => 2)])
+    @test read(seek(aio, 0), Base.AnnotatedString) == Base.AnnotatedString("hello world", [(1:5, :tag, 1), (7:11, :tag, 2)])
+    @test read(seek(aio, 1), Base.AnnotatedString) == Base.AnnotatedString("ello world", [(1:4, :tag, 1), (6:10, :tag, 2)])
+    @test read(seek(aio, 4), Base.AnnotatedString) == Base.AnnotatedString("o world", [(1:1, :tag, 1), (3:7, :tag, 2)])
+    @test read(seek(aio, 5), Base.AnnotatedString) == Base.AnnotatedString(" world", [(2:6, :tag, 2)])
     @test read(seekend(aio), Base.AnnotatedString) == Base.AnnotatedString("")
-    @test read(seekstart(truncate(deepcopy(aio), 5)), Base.AnnotatedString) == Base.AnnotatedString("hello", [(1:5, :tag => 1)])
-    @test read(seekstart(truncate(deepcopy(aio), 6)), Base.AnnotatedString) == Base.AnnotatedString("hello ", [(1:5, :tag => 1)])
-    @test read(seekstart(truncate(deepcopy(aio), 7)), Base.AnnotatedString) == Base.AnnotatedString("hello w", [(1:5, :tag => 1), (7:7, :tag => 2)])
-    @test read(seek(aio, 0), Base.AnnotatedChar) == Base.AnnotatedChar('h', [:tag => 1])
-    @test read(seek(aio, 5), Base.AnnotatedChar) == Base.AnnotatedChar(' ', Pair{Symbol, Any}[])
-    @test read(seek(aio, 6), Base.AnnotatedChar) == Base.AnnotatedChar('w', [:tag => 2])
+    @test read(seekstart(truncate(deepcopy(aio), 5)), Base.AnnotatedString) == Base.AnnotatedString("hello", [(1:5, :tag, 1)])
+    @test read(seekstart(truncate(deepcopy(aio), 6)), Base.AnnotatedString) == Base.AnnotatedString("hello ", [(1:5, :tag, 1)])
+    @test read(seekstart(truncate(deepcopy(aio), 7)), Base.AnnotatedString) == Base.AnnotatedString("hello w", [(1:5, :tag, 1), (7:7, :tag, 2)])
+    @test read(seek(aio, 0), Base.AnnotatedChar) == Base.AnnotatedChar('h', [(:tag, 1)])
+    @test read(seek(aio, 5), Base.AnnotatedChar) == Base.AnnotatedChar(' ', [])
+    @test read(seek(aio, 6), Base.AnnotatedChar) == Base.AnnotatedChar('w', [(:tag, 2)])
     # Check method compatibility with IOBuffer
     @test position(aio) == 7
     @test seek(aio, 4) === aio
@@ -180,19 +181,19 @@ end
     # Writing into the middle of the buffer
     @test write(seek(aio, 6), "alice") == 5 # Replace 'world' with 'alice'
     @test read(seekstart(aio), String) == "hello alice"
-    @test Base.annotations(aio) == [(1:5, :tag => 1), (7:11, :tag => 2)] # Should be unchanged
-    @test write(seek(aio, 0), Base.AnnotatedString("hey-o", [(1:5, :hey => 'o')])) == 5
+    @test Base.annotations(aio) == vec2ann([(1:5, :tag, 1), (7:11, :tag, 2)]) # Should be unchanged
+    @test write(seek(aio, 0), Base.AnnotatedString("hey-o", [(1:5, :hey, 'o')])) == 5
     @test read(seekstart(aio), String) == "hey-o alice"
-    @test Base.annotations(aio) == [(7:11, :tag => 2), (1:5, :hey => 'o')] # First annotation should have been entirely replaced
-    @test write(seek(aio, 7), Base.AnnotatedString("bbi", [(1:3, :hey => 'a')])) == 3 # a[lic => bbi]e ('alice' => 'abbie')
+    @test Base.annotations(aio) == vec2ann([(7:11, :tag, 2), (1:5, :hey, 'o')]) # First annotation should have been entirely replaced
+    @test write(seek(aio, 7), Base.AnnotatedString("bbi", [(1:3, :hey, 'a')])) == 3 # a[lic, bbi]e ('alice', 'abbie')
     @test read(seekstart(aio), String) == "hey-o abbie"
-    @test Base.annotations(aio) == [(7:7, :tag => 2), (11:11, :tag => 2), (1:5, :hey => 'o'), (8:10, :hey => 'a')]
+    @test Base.annotations(aio) == vec2ann([(7:7, :tag, 2), (11:11, :tag, 2), (1:5, :hey, 'o'), (8:10, :hey, 'a')])
     @test write(seek(aio, 0), Base.AnnotatedString("ab")) == 2 # Check first annotation's region is adjusted correctly
     @test read(seekstart(aio), String) == "aby-o abbie"
-    @test Base.annotations(aio) == [(7:7, :tag => 2), (11:11, :tag => 2), (3:5, :hey => 'o'), (8:10, :hey => 'a')]
+    @test Base.annotations(aio) == vec2ann([(7:7, :tag, 2), (11:11, :tag, 2), (3:5, :hey, 'o'), (8:10, :hey, 'a')])
     @test write(seek(aio, 3), Base.AnnotatedString("ss")) == 2
     @test read(seekstart(aio), String) == "abyss abbie"
-    @test Base.annotations(aio) == [(7:7, :tag => 2), (11:11, :tag => 2), (3:3, :hey => 'o'), (8:10, :hey => 'a')]
+    @test Base.annotations(aio) == vec2ann([(7:7, :tag, 2), (11:11, :tag, 2), (3:3, :hey, 'o'), (8:10, :hey, 'a')])
     # Writing one buffer to another
     newaio = Base.AnnotatedIOBuffer()
     @test write(newaio, seekstart(aio)) == 11
@@ -202,36 +203,37 @@ end
     @test sort(Base.annotations(newaio)) == sort(Base.annotations(aio))
     @test write(newaio, seek(aio, 5)) == 6
     @test read(seekstart(newaio), String) == "abyss abbie abbie"
-    @test sort(Base.annotations(newaio)) == sort(vcat(Base.annotations(aio), [(13:13, :tag => 2), (14:16, :hey => 'a'), (17:17, :tag => 2)]))
+    @test sort(Base.annotations(newaio)) ==
+        sort(vcat(Base.annotations(aio), vec2ann([(13:13, :tag, 2), (14:16, :hey, 'a'), (17:17, :tag, 2)])))
     # The `_insert_annotations!` cautious-merging optimisation
     aio = Base.AnnotatedIOBuffer()
-    @test write(aio, Base.AnnotatedChar('a', [:a => 1, :b => 2])) == 1
-    @test Base.annotations(aio) == [(1:1, :a => 1), (1:1, :b => 2)]
-    @test write(aio, Base.AnnotatedChar('b', [:a => 1, :b => 2])) == 1
-    @test Base.annotations(aio) == [(1:2, :a => 1), (1:2, :b => 2)]
+    @test write(aio, Base.AnnotatedChar('a', [(:a, 1), (:b, 2)])) == 1
+    @test Base.annotations(aio) == vec2ann([(1:1, :a, 1), (1:1, :b, 2)])
+    @test write(aio, Base.AnnotatedChar('b', [(:a, 1), (:b, 2)])) == 1
+    @test Base.annotations(aio) == vec2ann([(1:2, :a, 1), (1:2, :b, 2)])
     let aio2 = copy(aio) # A different start makes merging too risky to do.
-        @test write(aio2, Base.AnnotatedChar('c', [:a => 0, :b => 2])) == 1
-        @test Base.annotations(aio2) == [(1:2, :a => 1), (1:2, :b => 2), (3:3, :a => 0), (3:3, :b => 2)]
+        @test write(aio2, Base.AnnotatedChar('c', [(:a, 0), (:b, 2)])) == 1
+        @test Base.annotations(aio2) == vec2ann([(1:2, :a, 1), (1:2, :b, 2), (3:3, :a, 0), (3:3, :b, 2)])
     end
     let aio2 = copy(aio) # Merging some run of the most recent annotations is fine though.
-        @test write(aio2, Base.AnnotatedChar('c', [:b => 2])) == 1
-        @test Base.annotations(aio2) == [(1:2, :a => 1), (1:3, :b => 2)]
+        @test write(aio2, Base.AnnotatedChar('c', [(:b, 2)])) == 1
+        @test Base.annotations(aio2) == vec2ann([(1:2, :a, 1), (1:3, :b, 2)])
     end
     let aio2 = copy(aio) # ...and any subsequent annotations after a matching run can just be copied over.
-        @test write(aio2, Base.AnnotatedChar('c', [:b => 2, :c => 3, :d => 4])) == 1
-        @test Base.annotations(aio2) == [(1:2, :a => 1), (1:3, :b => 2), (3:3, :c => 3), (3:3, :d => 4)]
+        @test write(aio2, Base.AnnotatedChar('c', [(:b, 2), (:c, 3), (:d, 4)])) == 1
+        @test Base.annotations(aio2) == vec2ann([(1:2, :a, 1), (1:3, :b, 2), (3:3, :c, 3), (3:3, :d, 4)])
     end
     let aio2 = Base.AnnotatedIOBuffer()
-        @test write(aio2, Base.AnnotatedChar('a', [:b => 1])) == 1
-        @test write(aio2, Base.AnnotatedChar('b', [:a => 1, :b => 1])) == 1
+        @test write(aio2, Base.AnnotatedChar('a', [(:b, 1)])) == 1
+        @test write(aio2, Base.AnnotatedChar('b', [(:a, 1), (:b, 1)])) == 1
         @test read(seekstart(aio2), Base.AnnotatedString) ==
-            Base.AnnotatedString("ab", [(1:1, :b => 1), (2:2, :a => 1), (2:2, :b => 1)])
+            Base.AnnotatedString("ab", [(1:1, :b, 1), (2:2, :a, 1), (2:2, :b, 1)])
     end
     # Working through an IOContext
     aio = Base.AnnotatedIOBuffer()
     wrapio = IOContext(aio)
-    @test write(wrapio, Base.AnnotatedString("hey", [(1:3, :x => 1)])) == 3
-    @test write(wrapio, Base.AnnotatedChar('a', [:y => 2])) == 1
+    @test write(wrapio, Base.AnnotatedString("hey", [(1:3, :x, 1)])) == 3
+    @test write(wrapio, Base.AnnotatedChar('a', [(:y, 2)])) == 1
     @test read(seekstart(aio), Base.AnnotatedString) ==
-        Base.AnnotatedString("heya", [(1:3, :x => 1), (4:4, :y => 2)])
+        Base.AnnotatedString("heya", [(1:3, :x, 1), (4:4, :y, 2)])
 end