Golang how to create map to pointer to slice using make

I want to create a dynamically initialized bitmap data structure. I'm trying to use the golang maps for this:

type Register map[bool]*[]bool

The way I'm initializing the map is:

register := make(Register)
register[true] := make(*[]bool, len(arr))  // arr is the array for which i want to create the bitmap

This obviously creates compilation issue with the error:

error: cannot make type *[]bool

I have also tried using the pointer syntax:

register[true] = &(make([]bool, len(arr)))

Which gives me the error:

cannot take the address of make([]bool, len(arr))

The reason I want the map values to be *[]bool is so that the write back to the map stays sane and in-place.

While go doesn't complain about map[bool]*[]bool hence its a valid type.
If it is valid the what is the idomatic way to use it in the fashion I want to. If not then what would be the alternate way?

Use the following code to create a pointer to a slice:

register := make(Register)
s := make([]bool, len(arr)) // create addressable slice value s.
register[true] = &s

You can use new to eliminate the variable declaration, but this approach does not reduce the number of lines of code and it adds another map index operation.

register := make(Register)
register[true] = new([]bool)
*register[true] = make([]bool, len(arr))

Declare a function to move the assignment on to a single line:

func makeSlice(n int) *[]bool {
    s := make([]bool, len(arr))
    return &s
}

...

register := Register{true: makeSlice(len(arr))}

Because the map keys have two possible values, true and false, you might be able to simplify the code by using a struct instead of a map:

type Register struct {
    t, f []bool
}

register := Register{t: make([]bool, len(arr))}

The struct fields in register are addressable, so you can use &register.t to get the *[]bool.

A variation on this theme is to use an array:

type Register [2][]bool
register := Register{1: make([]bool, len(arr))}

If you modify the slice elements only and not the slice value, then there's no need to use a pointer to the slice.

type Register map[bool][]bool
register := make(Register)
register[true] := make([]bool, len(arr))

If you do modify the slice value, the map[bool][]bool may be more efficient and easier to use. The application will need to assign back to the map when the slice value is modified, but you eliminate the indirections.

Another option is using the new function:

package main
import "fmt"

func main() {
   type Register map[bool]*[]bool
   register := make(Register)
   register[true] = new([]bool)
   // main.Register{true:(*[]bool)(0xc000004078)}
   fmt.Printf("%#v\n", register)
}

https://golang.org/pkg/builtin#new