pre:

// Here's an example of sparse matrix multiplication using rel (relational meets linear):
type matrixElem struct {
	R int
	C int
	V float64
}
type multElemA struct {
	R  int
	M  int
	VA float64
}
type multElemB struct {
	M  int
	C  int
	VB float64
}
type multElemC struct {
	R  int
	C  int
	M  int
	VA float64
	VB float64
}
type groupTup struct {
	VA float64
	VB float64
}
type valTup struct {
	V float64
}
groupAdd := func(val <-chan groupTup) valTup {
	res := valTup{}
	for vi := range val {
		res.V += vi.VA * vi.VB
	}
	return res
}

// representation of a matrix:
//  1 2
//  3 4
A := New([]matrixElem{
	{1, 1, 1.0},
	{1, 2, 2.0},
	{2, 1, 3.0},
	{2, 2, 4.0},
}, [][]string{[]string{"R", "C"}})

// representation of a matrix:
//  4 17
//  9 17
B := New([]matrixElem{
	{1, 1, 4.0},
	{1, 2, 17.0},
	{2, 1, 9.0},
	{2, 2, 17.0},
}, [][]string{[]string{"R", "C"}})

C := A.Rename(multElemA{}).Join(B.Rename(multElemB{}), multElemC{}).
	GroupBy(matrixElem{}, groupAdd)
	
fmt.Println("\n%#v",C)

// Output: (might be in any order)
// rel.New([]struct {
//  R int     
//  C int     
//  V float64 
// }{
//  {1, 1, 22,  },
//  {1, 2, 51,  },
//  {2, 1, 48,  },
//  {2, 2, 119, },
// })