How to set bool pointer to true in struct literal?

Question

I have the function below which accepts a bool pointer. I'm wondering if there is any notation which allows me to set the value of the is field to true in the struct literal; basically without to define a new identifier (i.e. var x := true ; handler{is: &x} )

package main

import "fmt"

func main() {
    fmt.Println("Hello, playground")
    check(handler{is: new(bool) })
}


type handler struct{
    is *bool
}

func check(is handler){}

Measly

Related: #30716854 – Manhunt

You can use package pointer, for example: var _ *bool = pointer.Bool(true) – Robby

Note: if you are dealing with AWS Go SDK, there is an aws.Bool() function specifically for this. – Undernourished

Answer 1

You can do that but it's not optimal:

h := handler{is: &[]bool{true}[0]}
fmt.Println(*h.is) // Prints true

Basically it creates a slice with one bool of value true, indexes its first element and takes its address. No new variable is created, but there is a lot of boilerplate (and backing array will remain in memory until the address to its first element exists).

A better solution would be to write a helper function:

func newTrue() *bool {
    b := true
    return &b
}

And using it:

h := handler{is: newTrue()}
fmt.Println(*h.is) // Prints true

You can also do it with a one-liner anonymous function:

h := handler{is: func() *bool { b := true; return &b }()}
fmt.Println(*h.is) // Prints true

Or a variant:

h := handler{is: func(b bool) *bool { return &b }(true)}

To see all your options, check out my other answer: How do I do a literal *int64 in Go?

Manhunt

I guess I have to go with the ugly slice of bools b/c the syntax is provided as a command argument to a generator so I can't afford a helper function. – Measly

@Theuserwithnohat I don't see why your case wouldn't allow a function. Care to share more details? – Manhunt

The syntax (type fields) is supposed to be provided to a command line/generator. Providing a function as cli argument is not nice. – Measly

isn't it better just to create a spurious variable? performance implications? – Greenfield

@Greenfield Yes, that's preferable. Probably the one-liner helper gets inlined too. – Manhunt

Answer 2

This simplest way is to write a short function to turn a bool into a *bool.

func BoolPointer(b bool) *bool {
    return &b
}

h := handler{is: BoolPointer(true)}

Livelong

Answer 3

No.

There is no syntax to define a pointer to a primitive type, other than the zero value returned by new. The same goes for numeric types, and strings.

You either need to create a value before hand to take the address of, or you create the pointer with a zero value, and assign a new value after the fact.

Baker

Answer 4

I used a function similar to @icza but in a way more convenient (for me)

I created a BoolAddr function in my utils package

package utils

func BoolAddr(b bool) *bool {
    boolVar := b
    return &boolVar
}

For me it's easier to use

package main
    
import "example.com/example/utils"
...
type Example struct {
    isActive *bool
}
    
ex := Expample {
    isActive: utils.BoolAddr(true)
}
...

Staceestacey

Answer 5

If you're using Go version 1.18 or later, you can take advantage of the newly introduced generics feature to create a utility function that generates a pointer to any given type.

func Pointer[T any](d T) *T {
    return &d
}

How to use:

type Example struct {
    isActive *bool
}

ex := Example {
    isActive: Pointer(true),
}

Wiretap

Answer 6

One of the reasons why pointers are helpful in go or any language for that matter, is they help us to "pass by reference". So if we pass anything by reference we can then "change" that thing. A function which takes a pointer to bool, can change the bool's value effectively even after the function returns. This is the very thing we do not want with constants, ie. their values should not change. Hence this restriction makes sense.

Apart from the tricks mentioned by icza above, would want to add a point here. Mostly we use pointers to bools rather than bools directly in order to use the nil value of pointers effectively, which otherwise have to be either true or false. If that IS the case, then you might want to use optional bool flags directly in the functions, rather than have pointers to bool or even a struct wrapping the single bool pointer as shown in your example, doing away with the complete requirement of a struct even.. Now, of course if the struct is reqd for any other reason, you can very well use any of the tricks by icza above. Btw, you can directly have a copy of the bool value for using the adress of as below as well.

const check = true
chk := check
fmt.Println(&chk) // will give you the address of chk
chk = false
fmt.Println(chk) // will print false
fmt.Println(check) // will print true

Standfast