Idiomatic naming convention for exported struct and getter for the whole struct in Go

When I have a struct like the following:

// user.go
package user

type User struct {
    ID   int
    Name string
    // other fields
}

func NewUser() User {
    return User{ID: 1+1}
}

// for user list I can do it like this:
func Users() []User {
    // ...
    // return list of users
}

// But for sing user, what is the idiomatic way to name a getter here?
// Getter 1
func GetUser(id) User {
    // return the user that has the provided id
}

// Getter 2
func Get(id) User {
    // return the user that has the provided id
}

// Getter 3
func ByID(id) User {
    // return the user that has the provided id
}

// Getter 4
func OfID(id) User {
    // return the user that has the provided id
}

In another package I can use it like so:

package somepackage

import "user"


func doStuff() {
    u := user.NewUser()
    // do stuff
}

func doOtherStuff() {
    users = user.Users()
    for _, u := range users {
        // do other stuff
    }
}

func checkUser(useID int) {
    // Get the user of the `userID` id
    // this way?:
    u := user.GetUser(useID)

    // or this way?:
    u := user.Get(userID)

    // or?:
    u := user.ByID(userID)

    // or?:
    u := user.OfID(userID)
}

Off course I'd like to use something like:

u.User(id)

But that is not possible as the name User is used by the struct.

So what is the idiomatic way to name a getter in this case? Or should rename the struct to something else which I prefer not to?

Taking into account what is suggested by Effective Go the user package code could look like this:

package user

type (
  User struct {
    ID   int
    Name string
    // other fields
  }
  
  Users []User
}

// New creates new User.
func New() User {
    // Initialize User structure.
    return User{ID: 1 + 1}
}

// AdminUsers returns users with admin privileges.
func AdminUsers() Users {
   return Users{....}
}

func (l Users) Find(id int) (User, bool) {
  for i := range l {
    if l[i].ID == id {
       return l[id], true
    }
  }
  return User{}, false
}

I renamed NewUser to New as the user suffix duplicates the name of package here.

The Users function does not bring any value here. As i understand it returns some list but the name does not tells what is the purpose of having this list. I replaced it with Users type with a method for finding user on this list by id and example AdminUsers function which returns a list of admin user (in practice it will probably be repository and you will grab the whole list from the database every time).

The last part is the getter, which in my opinion is useless here, because getter will return exactly the same User as what you have in hand. Example:

u := user.New()
u1 := u.User()
// u1 == u