Modifying receiver with a method on value?

package matrix

import (
	"errors"
	"strconv"
	"strings"
)

// Matrix matrix inteface
type Matrix interface {
	Rows() [][]int
	Cols() [][]int
	Set(r, c, val int) bool
}

// matrix implements the interface Matrix
type matrix struct {
	data [][]int
	rows int
	cols int
}

// New returns a valid matrix created from the input
func New(input string) (Matrix, error) {
	var m matrix
	rows := strings.Split(input, "\n")
	for r, row := range rows {
		rowElements := strings.Fields(row)

		switch {
		case r == 0:
			m.rows, m.cols = len(rows), len(rowElements)
			matrix, err := allocateMemory(m.rows, m.cols)
			if err != nil {
				return invalidMatrix()
			}
			m.data = matrix
		case len(rowElements) != m.cols:
			return invalidMatrix()
		}

		for c, element := range rowElements {
			element, err := strconv.Atoi(element)
			if err != nil {
				return invalidMatrix()
			}
			m.data[r][c] = element
		}
	}
	return m, nil
}

// invalidMatrix returns the error indicating the
// provided matrix is invalid
func invalidMatrix() (Matrix, error) {
	return nil, errors.New("invalid matrix")
}

// allocateMemory allocates a 2D slice of int having size RxC
func allocateMemory(R, C int) ([][]int, error) {
	if R < 1 || C < 1 {
		return nil, errors.New("invalid matrix")
	}
	matrix := make([][]int, R)
	for r := range matrix {
		matrix[r] = make([]int, C)
	}
	return matrix, nil
}

// Set sets the given value at (r,c) in the matrix,
// if (r,c) belongs to the matrix.
func (m matrix) Set(r, c, val int) bool {
	switch {
	case r < 0 || c < 0:
		return false
	case r >= m.rows || c >= m.cols:
		return false
	default:
		m.data[r][c] = val
		return true
	}
}

// order defines the order the matrix to export
// two useful values are columnMajor and rowMajor
type order int

const (
	columnMajor order = iota
	rowMajor
)

// Cols returns columns of the matrix.
func (m matrix) Cols() [][]int {
	return m.export(columnMajor)
}

// Rows returns rows of the matrix.
func (m matrix) Rows() [][]int {
	return m.export(rowMajor)
}

// export return the matrix in the required order;
// either columnMajor or rowMajor.
func (m matrix) export(o order) [][]int {
	var matrix [][]int
	var err error
	switch o {
	case columnMajor:
		matrix, err = allocateMemory(m.cols, m.rows)
		if err != nil {
			return nil
		}
		for r, row := range m.data {
			for c, element := range row {
				matrix[c][r] = element
			}
		}
	case rowMajor:
		matrix, err = allocateMemory(m.rows, m.cols)
		if err != nil {
			return nil
		}
		for r, row := range m.data {
			copy(matrix[r], row)
		}
	}
	return matrix
}

I am having a hard time understanding why the method Set() is able to modify the data of the struct. I had an understanding that methods defined on values cannot do that. I have tried to compare it with another problem where I cannot modify the content of receiver but in this case it just works. A test file for this code is available at test file. Any idea what I am missing?

The reason Set can modify the contents of the slice is that the slice is a reference value. Your other example (in the comment) attempts to assign the field holding the slice, and this won't work - because it's working on a copy. See this code sample:

package main
import (
"fmt"
)
type Holder struct {
s []int
v []int
}
func (h Holder) Set() {
// This will successfully modify the `s` slice's contents
h.s[0] = 99
// This will assign a new slice to a copy of the v field,
// so it won't affect the actual value on which this
// method is invoked. 
h.v = []int{1, 2, 3}
}
func main() {
var h Holder
h.s = []int{10, 20, 30}
h.v = []int{40, 50, 60}
fmt.Println("before Set:", h)
h.Set()
fmt.Println("after Set:", h)
}

You can run it on the playground, and it prints:

before Set: {[10 20 30] [40 50 60]}
after Set: {[99 20 30] [40 50 60]}

What happens here is that even though Set gets a copy of h, and hence h.s is a copy too, but both copies point to the same underlying slice, so the contents can be modified. Read this post for all the details.

A slice value contains (ptr, len, cap) where ptr is a pointer to the slice's underlying array. The Set method modifies the slice's underlying array by dereferencing the pointer. The slice value, stored in the field, is not modified.

The Go Language blog post on slices describes the slice memory layout in more detail.