I'm trying figure out in-memory file manipulation for a Lambda project I'm working on. This dummy program illustrates my ignorance:

```
package main

import (
    "bytes"
    "fmt"
    "log"
)

func Append(input *[]byte, appendee string) (err error)  {
   buf := bytes.NewBuffer(*input)
   if _, err := buf.WriteString(appendee); err != nil {
       log.Println(err)
   } 

   return err
}

func main() {
   test := "this is a test\nThis test is short\nBut longer tests would work also\n"

   b := []byte(test)

   fmt.Println(b)

   err := Append(&b, "This is an appended line")

   if err != nil {
           fmt.Println("oops")
   }

   fmt.Println(b)
}

```

I'm hoping that y passing a reference to the byte array in the line that calls Append, that function can manipulate the same data structure that is in main, and then the print would include the appended line. But it does not. Here's the execution:

```
✗ go run test.go
[116 104 105 115 32 105 115 32 97 32 116 101 115 116 10 84 104 105 115 32 116 101 115 116 32 
105 115 32 115 104 111 114 116 10 66 117 116 32 108 111 110 103 101 114 32 116 101 115 116 
115 32 119 111 117 108 100 32 119 111 114 107 32 97 108 115 111 10]
[116 104 105 115 32 105 115 32 97 32 116 101 115 116 10 84 104 105 115 32 116 101 115 116 32 
105 115 32 115 104 111 114 116 10 66 117 116 32 108 111 110 103 101 114 32 116 101 115 116 
115 32 119 111 117 108 100 32 119 111 114 107 32 97 108 115 111 10]

```

What am I missing?