A forma mais básica de passarmos uma matriz como argumento para uma função é por valor. 
                Vale lembrar que quando essa abordagem é utilizada, alterando o valor de um elemento 
                da matriz não irá refletir na variável que foi passada como argumento.
            
            
            Sintaxe F
            
func nome_funcao(param [<linha>][<coluna>] tipo_dado, linhas int, colunas int){ /*corpo*/}
            Sintaxe G
            
nome_funcao( nome_matriz )
            
                As sintaxe F e G acima mostram a declaração de um protótipo de uma função e a passagem de uma matriz como argumento
                respectivamente.
            
            Exemplo 6
            
package main
import "fmt"
func funcao(mat [2][3]int, linhas int , colunas int) {
	for i := 0; i < linhas; i++ {
		for j := 0; j < colunas; j++ {
			fmt.Printf("%d", mat[i][j])
		}
		fmt.Printf("\n")
	}
}
func main() {
	var vint [2][3]int 
	vint = [2][3]int{{1, 2, 3}, {3, 4, 5}}
	funcao(vint,2,3)
}
            Saída
            
123
345
            
                Para que seja possível a persistência de uma alteração feita em uma matriz, sendo esse acessado 
                dentro de uma função  ou método, é necessário fazer a passagem da matriz por referência utilizando o operador (&).
            
            Sintaxe H
            
func nome_funcao(param *[<linha>][<coluna>] tipo_dado, linhas int, colunas int){ /*corpo*/}
            Sintaxe I
            
nome_funcao(&nome_vetor, linhas, colunas)
            
                As sintaxe H e I acima mostram a declaração de um protótipo de uma função e a passagem de uma matriz como argumento
                respectivamente.
            
            Exemplo 7
            
package main
import "fmt"
func funcao(mat *[2][3]int, linhas int, colunas int) {
	for i := 0; i < linhas; i++ {
		for j := 0; j < colunas; j++ {
			mat[i][j] *= 2
		}
	}
}
func main() {
	var mint [2][3]int
	vint = [2][3]int{{1, 2, 3}, {3, 4, 5}}
	fmt.Println("antes:", mint)
	funcao(&mint, 2, 3)
	fmt.Println("depois:", mint)
}
            Saída
            
antes: [[1 2 3] [3 4 5]]
depois: [[2 4 6] [6 8 10]]
            
                O retorno de vetores em funções é feito da mesma forma como qualquer outro tipo de dado já 
                visto. Declaramos o tipo de retorno no protótipo da função como matriz com ou sem sua dimensão.
            
            Sintaxe J
            
func nome_funcao(<lista_parametros>) (nome_retorno [<linhas>][<colunas>]tipo_dado)
func nome_funcao(<lista_parametros>) ([<linhas>][<colunas>]tipo_dado)
func nome_funcao(<lista_parametros>) ([][]tipo_dado)
            Exemplo 8
            
package main
import "fmt"
func funcao1() (mat [][]int) {
	mat = [][]int{{1, 2}, {3, 4}}
	return
}
func funcao2() [2][2]int {
	mat := [2][2]int{{1, 2}, {3, 4}}
	return mat
}
func funcao3() [][]int {
	mat := [][]int{{1, 2}, {3, 4}}
	return mat
}
func main() {
	mint1 := funcao1()
	fmt.Println(mint1)
	mint2 := funcao2()
	fmt.Println(mint2)
	mint3 := funcao3()
	fmt.Println(mint3)
}
            
            Saída
            
[[1 2] [3 4]]
[[1 2] [3 4]]
[[1 2] [3 4]]