golang how does the rune() function work

As stated in @Michael's first-rate comment fmt.Println([]rune("foo")) is a conversion of a string to a slice of runes []rune. When you convert from string to []rune, each utf-8 char in that string becomes a Rune. See https://stackoverflow.com/a/51611567/12817546. Similarly, in the reverse conversion, when converted from []rune to string, each rune becomes a utf-8 char in the string. See https://stackoverflow.com/a/51611567/12817546. A []rune can also be set to a byte, float64, int or a bool.

package main

import (
    . "fmt"
)

func main() {
    r := []rune("foo")
    c := []interface{}{byte(r[0]), float64(r[0]), int(r[0]), r, string(r), r[0] != 0}
    checkType(c)
}

func checkType(s []interface{}) {
    for k, _ := range s {
        Printf("%T %v\n", s[k], s[k])
    }
}

byte(r[0]) is set to “uint8 102”, float64(r[0]) is set to “float64 102”,int(r[0]) is set to “int 102”, r is the rune” []int32 [102 111 111]”, string(r) prints “string foo”, r[0] != 0 and shows “bool true”.

[]rune to string conversion is supported natively by the spec. See the comment in https://stackoverflow.com/a/46021588/12817546. In Go then a string is a sequence of bytes. However, since multiple bytes can represent a rune code-point, a string value can also contain runes. So, it can be converted to a []rune , or vice versa. See https://stackoverflow.com/a/19325804/12817546.

Note, there are only two built-in type aliases in Go, byte (alias of uint8) and rune (alias of int32). See https://Go101.org/article/type-system-overview.html. Rune literals are just 32-bit integer values. For example, the rune literal 'a' is actually the number "97". See https://stackoverflow.com/a/19311218/12817546. Quotes edited.

Think of runes as an abstraction layer built on purpose into the language so it can transparently support UTF-8. Since not everybody speaks English, and you might find yourself handling other languages like French, German or Japanese, I would advise you to take a good read on this: https://go.dev/blog/strings

And also to try running this:

import "fmt"

func main() {
    fmt.Println([]rune("Hello 世界!"))
}

You will see that the Sino-Japanese characters have a peculiar numerical difference when printing their values in comparison with the other chars:

[72 101 108 108 111 32 19990 30028 33]

This is because these are not on the ASCII table and you can't represent them with a single byte. When Golang was created it was designed with Unicode support in mind and part of the language. You don't need a library for handling UTF-8. It's built-in, like written in stone!