title: Is it better to use methods over closures?
body: <p>I have a simple type of data that only consists of an uint32, but many operations can be performed on this data. All files that use this data reside in the same package and therefore can access the unexported uint32 inside the struct which is not preferable. I recently learned about the power of closures and was wondering if it is better to use a struct that contains functions that perform the tasks or to have the uint32 stored in the struct and then just use methods with a receiver of the struct.</p>
  
  <p>This is a basic representation of an OpenGL shader. Both the method and closure options, look the same to the caller but perform differently under the hood.</p>
  
  <p>Closure:</p>
  
  <pre><code>type Shader struct {
      getID  func() uint32
      delete func()
  }
  
  func CreateShader(shader string) Shader {
      var id uint32
      //Do work...
      return Shader{
          getID: func() uint32 {
              return id
          },
          delete: func() {
              gl.DeleteShader(id)
          },
      }
  }
  </code></pre>
  
  <p>Methods:</p>
  
  <pre><code>type Shader struct {
      id uint32
  }
  
  func CreateShader(shader string) Shader{
      var id uint32
      //Do work...
      return Shader{id: id}
  }
  
  func (s Shader) getID() uint32 {
      return s.id
  }
  
  func (s Shader) delete() {
      gl.DeleteShader(s.id)
  }
  </code></pre>
  
  <p>Both options appear like this in use:</p>
  
  <pre><code>func main() {
      shader := CreateShader("shader.code")
      id := shader.getID()
      fmt.Println(id)
      shader.delete()
  }
  </code></pre>
  
  <p>The miss use I thought to avoid was that the caller could affect the id type without Shader knowing. Something similar to:</p>
  
  <pre><code>shader.id = 4102 // or some other change
  </code></pre>
  
  <p>With the use of closures this behavior is impossible and requires the caller to go use the proper calls.</p>
  
  <p>As mentioned in the comments, it is possible to use a shader package and unexport the shader type. I didn't use this because I thought it was improper to make an entire package just to hold one file. But perhaps it is proper if it solidifies correct use of the type.</p>
  
  <p>Is there any reason that the closure version is "wrong" compared to the methods? Are there any golang standards that would classify either choice better suited for my use case? I expect the caller to not touch the id of the shader and think that the use of closures makes it clearer the proper use of the shader type.</p>