Constant struct in Go

A good workaround is to wrap it in a function.

func FEED_TO_INSERT() quzx.RssFeed {
    return quzx.RssFeed{ 0,
                    "",
                    "desc",
                    "www.some-site.com",
                    "upd_url",
                    "img_title",
                    "img_url",
                    0,
                    0,
                    0,
                    0,
                    0,
                    100,
                    "alt_name",
                    1,
                    1,
                    1,
                    "test",
                    100,
                    100,
                    0 }
}

Note: Make sure that the function is always returning a new object(or copy).

You should declare it as a var.

Go allows you to declare and initialize global variables at module scope.

Go does not have any concept of immutability. 'const' is not meant as a way to prevent variables from mutating or anything like that.

You could declare your struct fields as private and then create getter methods.

type ImmutableType struct {
  immutableField string
}

func (p ImmutableType) GetImmutableField() string {
  return p.immutableField
}

If you do this, the field itself will be inaccessible outside the module and will become sort of immutable.

However,

• this can only be done on the struct level, not when declaring a variable
• if you want to instantiate your struct outside of the module, you'll have to also create a constructor, which becomes kind of a mess since constructors are not really a commonly used practice in Go.

In order to "force" the use of your constructor, you might also declare your struct itself private, so it cannot be created as a composite literal without the private fields.

type immutableType struct {
  immutableField string
}

func (p immutableType) GetImmutableField() string {
  return p.immutableField
}

func CreateImmutableType(immutableField string) immutableType {
  return immutableType{
    immutableField: immutableField,
  }
}

TL;DR Go doesn't have immutability as a core concept, so implementing it requires a bunch of boilerplate.

As was said, Go does not support constant struct variables. This has a reason, compiler cannot ensure immutability of any struct (e.g. containing a pointer). Solution is rather simple: just use normal variable:

type Person struct {
    age int
}

var Luke = Person{10}

You can also use anonymous struct:

var Andrew = struct {
    age int
}{
    age: 13,
}

When you create this as a global variable, treat it as that - with care. The other recommendation is to use a function to return always a copy and that is the other extreme.

There is a possible implementation using type alias. As in mkopriva answer, only some intrinsic types can be constants. However, you can define a new type on top of those and write getters for your constant values.

package main

import "fmt"

type Config bool

func (_ Config) Prop() int {
    return -1
}

const DefaultConfig Config = false

func main() {
    fmt.Println(DefaultConfig.Prop())

    // This will not work
    // variable := Config(true)
    // DefaultConfig = variable
}

At the time I'm writing this, the Prop() function meets the requirements for inlining, so you may expect no overhead coming from the function call.