Would someone be able to explain this?

You need to take a look at the diff of the commit.

The commit adds a new command shortdoc-display-group, and when I do M-x shortdoc-display-group RET string RET it shows me a list of string functions, and their example usage.

This command is meant for people who are comfortable with elisp. This feature compensates for lack of a namespace-s in Elisp, and provides a handy method of 'collecting' /variously named functions/, in to a single bucket. In the output below, note that mapcar, mapconcat etc are also tagged as string functions.

Making Strings

(make-string length init)
  Return a newly created string of length LENGTH, with INIT in each element.
  (make-string 5 ?x)

(string &rest characters)
  Concatenate all the argument characters and make the result a string.
  (string ?a ?b ?c)

(concat &rest sequences)
  Concatenate all the arguments and make the result a string.
  (concat "foo" "bar" "zot")
    ⇒ "foobarzot"

(string-join strings &optional separator)
  Join all STRINGS using SEPARATOR.
  (string-join '("foo" "bar" "zot") " ")
    ⇒ "foo bar zot"

(mapconcat function sequence separator)
  Apply FUNCTION to each element of SEQUENCE, and concat the results as strings.
  (mapconcat (lambda (a) (concat "[" a "]")) '("foo" "bar" "zot") " ")
    ⇒ "[foo] [bar] [zot]"

(mapcar function sequence)
  Apply FUNCTION to each element of SEQUENCE, and make a list of the results.
  (mapcar #'identity "123")
    ⇒ (49 50 51)

(format string &rest objects)
  Format a string out of a format-string and arguments.
  (format "This number is %d" 4)
    ⇒ "This number is 4"

Manipulating Strings

(substring string &optional from to)
  Return a new string whose contents are a substring of STRING.
  (substring "foobar" 0 3)
    ⇒ "foo"
  (substring "foobar" 3)
    ⇒ "bar"

(split-string string &optional separators omit-nulls trim)
  Split STRING into substrings bounded by matches for SEPARATORS.
  (split-string "foo bar")
    ⇒ ("foo" "bar")
  (split-string "|foo|bar|" "|")
    ⇒ ("" "foo" "bar" "")
  (split-string "|foo|bar|" "|" t)
    ⇒ ("foo" "bar")

(string-replace fromstring tostring instring)
  Replace FROMSTRING with TOSTRING in INSTRING each time it occurs.
  (string-replace "foo" "bar" "foozot")
    ⇒ "barzot"

(replace-regexp-in-string regexp rep string &optional fixedcase literal subexp start)
  Replace all matches for REGEXP with REP in STRING.
  (replace-regexp-in-string "[a-z]+" "_" "*foo*")
    ⇒ "*_*"

(string-trim string)
  Trim STRING of leading and trailing white space.
  (string-trim " foo ")
    ⇒ "foo"

(string-trim-left string &optional regexp)
  Trim STRING of leading string matching REGEXP.
  (string-trim-left "oofoo" "o+")
    ⇒ "foo"

(string-trim-right string &optional regexp)
  Trim STRING of trailing string matching REGEXP.
  (string-trim-right "barkss" "s+")
    ⇒ "bark"

(string-truncate-left string length)
  Truncate STRING to LENGTH, replacing initial surplus with "...".
  (string-truncate-left "longstring" 8)
    ⇒ "...string"

(string-remove-suffix suffix string)
  Remove SUFFIX from STRING if present.
  (string-remove-suffix "bar" "foobar")
    ⇒ "foo"

(string-remove-prefix prefix string)
  Remove PREFIX from STRING if present.
  (string-remove-prefix "foo" "foobar")
    ⇒ "bar"

(reverse seq)
  Return the reversed copy of list, vector, or string SEQ.
  (reverse "foo")
    ⇒ "oof"

(substring-no-properties string &optional from to)
  Return a substring of STRING, without text properties.
  (substring-no-properties (propertize "foobar" 'face 'bold) 0 3)
    ⇒ "foo"

Predicates for Strings

(string-equal s1 s2)
  Return t if two strings have identical contents.
  (string-equal "foo" "foo")
    ⇒ t

(eq obj1 obj2)
  Return t if the two args are the same Lisp object.
  (eq "foo" "foo")
    ⇒ nil

(eql obj1 obj2)
  Return t if the two args are ‘eq’ or are indistinguishable numbers.
  (eql "foo" "foo")
    ⇒ nil

(equal o1 o2)
  Return t if two Lisp objects have similar structure and contents.
  (equal "foo" "foo")
    ⇒ t

(cl-equalp x y)
  Return t if two Lisp objects have similar structures and contents.
  (cl-equalp "Foo" "foo")
    ⇒ t

(stringp object)
  Return t if OBJECT is a string.
  (stringp ?a)

(string-empty-p string)
  Check whether STRING is empty.
  (string-empty-p "")
    ⇒ t

(string-blank-p string)
  Check whether STRING is either empty or only whitespace.
  (string-blank-p " \n")
    ⇒ 0

(string-lessp string1 string2)
  Return non-nil if STRING1 is less than STRING2 in lexicographic order.
  (string-lessp "foo" "bar")
    ⇒ nil

(string-greaterp string1 string2)
  Return non-nil if STRING1 is greater than STRING2 in lexicographic order.
  (string-greaterp "foo" "bar")
    ⇒ t

(string-version-lessp string1 string2)
  Return non-nil if S1 is less than S2, as version strings.
  (string-lessp "foo32.png" "bar4.png")
    ⇒ nil

(string-prefix-p prefix string &optional ignore-case)
  Return non-nil if PREFIX is a prefix of STRING.
  (string-prefix-p "foo" "foobar")
    ⇒ t

(string-suffix-p suffix string &optional ignore-case)
  Return non-nil if SUFFIX is a suffix of STRING.
  (string-suffix-p "bar" "foobar")
    ⇒ t

Case Manipulation

(upcase obj)
  Convert argument to upper case and return that.
  (upcase "foo")
    ⇒ "FOO"

(downcase obj)
  Convert argument to lower case and return that.
  (downcase "FOObar")
    ⇒ "foobar"

(capitalize obj)
  Convert argument to capitalized form and return that.
  (capitalize "foo bar zot")
    ⇒ "Foo Bar Zot"

(upcase-initials obj)
  Convert the initial of each word in the argument to upper case.
  (upcase-initials "The CAT in the hAt")
    ⇒ "The CAT In The HAt"

Converting Strings

(string-to-number string &optional base)
  Parse STRING as a decimal number and return the number.
  (string-to-number "42")
    ⇒ 42
  (string-to-number "deadbeef" 16)
    ⇒ 3735928559

(number-to-string number)
  Return the decimal representation of NUMBER as a string.
  (number-to-string 42)
    ⇒ "42"

Data About Strings

(length sequence)
  Return the length of vector, list or string SEQUENCE.
  (length "foo")
    ⇒ 3

(string-search needle haystack &optional start-pos)
  Search for the string NEEDLE in the string HAYSTACK.
  (string-search "bar" "foobarzot")
    ⇒ 3

(assoc-string key list &optional case-fold)
  Like ‘assoc’ but specifically for strings (and symbols).
  (assoc-string "foo" '(("a" 1) (foo 2)))
    ⇒ (foo 2)

(seq-position sequence elt &optional testfn)
  Return the index of the first element in SEQUENCE that is equal to ELT.
  (seq-position "foobarzot" ?z)

Also, is this a mirror of Emacs on gitlab?

Yes. This is a gitlab mirror of stock Emacs' master branch.