How to ensure read-only variables and maps in golang

I want my programs have access to global read-only regex and maps. Here's what i thought of :

var myRegex *regexp.Regexp
var myMap map[string]string

func init() {
    myRegex = regexp.MustCompile("blah")
    myMap = map[string]string{"blah": "blah"}
}

or i can do

type myStruct struct {
    //  already have bunch of other struct fields
    myRegex    *regexp.Regexp
    myMap map[string]string
}


func Initialize() *myStruct {
  	m := myStruct {
        // bunch of other stuff
        myRegex: regexp.MustCompile("blah")
        myMap: map[string]string{"blah": "blah"}
}

But how i can ensure that these variables won't be writable by any other piece of my software ?

As long as you're dealing with pointers ( maps are pointers anyway ), you' ll never be able to ensure that your map or regex is ReadOnly.

( Ok, unless you copy the value with the function each time and return a new pointer... But i'm not sure that's what you want to achieve

If i take your example, and add a simple main code :

package main

import (
	"fmt"
	"regexp"
)

var myRegex *regexp.Regexp = regexp.MustCompile("blah")
var myMap map[string]string

func init() {
	myRegex = regexp.MustCompile("blah")
	myMap = map[string]string{"blah": "blah"}
}

type myStruct struct {
	//  already have bunch of other struct fields
	myRegex *regexp.Regexp
	myMap   map[string]string
}

func Initialize() myStruct {
	return myStruct{
		// bunch of other stuff
		myRegex: regexp.MustCompile("blah"),
		myMap:   map[string]string{"blah": "blah"},
	}
}

func getMap() map[string]string {
	return myMap
}

func main() {
	fmt.Println(myMap)
	myMap["blah2"] = "blah2"
	fmt.Println(myMap)
	fmt.Println(getMap())

	m := Initialize()

	fmt.Println(m.myMap)
	m.myMap["test"] = "test"
	fmt.Println(m.myMap)
}

you see that i can modify the maps:

❯ ./main
map[blah:blah]
map[blah:blah blah2:blah2]
map[blah:blah blah2:blah2]
map[blah:blah]
map[blah:blah test:test]

Regex would be exactly the same.

If you really want to ensure that your regex and maps will never be updated by mistake by another piece of code, there's couple of solutions; most of them consisting of moving your read-only variables in there own package and never give direct access to them. Something like this for instance

package mapreadonly

type ReadOnlyMap struct {
	m map[string]string
}

func (elem ReadOnlyMap) Get(key string) (string, bool) {
	value, ok := elem.m[key]
	return value, ok
}

var Map1 ReadOnlyMap = ReadOnlyMap{
	m: map[string]string{
		"blah": "blah",
	},
}

and then import this package in your other files that requires it.

But as said, your question is lacking a bit of context to ensure that the answer is what your expect.