func (c *Composed) FromBytes(buff []byte) (sif.Accumulator, error) {
	var deser [][]byte
	d := gob.NewDecoder(bytes.NewBuffer(buff))
	err := d.Decode(&deser)
	if err != nil {
		return nil, err
	}
	newAcs := make([]sif.Accumulator, len(c.accs))
	for i, b := range deser {
		a, err := c.accs[i].FromBytes(b)
		if err != nil {
			return nil, err
		}
		newAcs[i] = a
	}
	return &Composed{accs: newAcs}, nil
}
FromBytes produce a new Accumulator from serialized data
package accumulators
import (
	"bytes"
	"encoding/gob"
	"fmt"
	"github.com/go-sif/sif"
)
func Compose(faccs ...func() sif.Accumulator) func() sif.Accumulator {
	return func() sif.Accumulator {
		accs := make([]sif.Accumulator, len(faccs))
		for i, f := range faccs {
			accs[i] = f()
		}
		return &Composed{accs: accs}
	}
}
type Composed struct {
	accs []sif.Accumulator
}
func (c *Composed) GetResults() []sif.Accumulator {
	return c.accs
}
func (c *Composed) Accumulate(row sif.Row) error {
	for _, a := range c.accs {
		err := a.Accumulate(row)
		if err != nil {
			return err
		}
	}
	return nil
}
func (c *Composed) Merge(o sif.Accumulator) error {
	compa, ok := o.(*Composed)
	if !ok {
		return fmt.Errorf("incoming accumulator is not a Composed Accumulator")
	}
	for i, a := range c.accs {
		err := a.Merge(compa.accs[i])
		if err != nil {
			return err
		}
	}
	return nil
}
func (c *Composed) ToBytes() ([]byte, error) {
	result := make([][]byte, len(c.accs))
	totalSize := 0
	for i, a := range c.accs {
		buff, err := a.ToBytes()
		if err != nil {
			return nil, err
		}
		result[i] = buff
		totalSize += len(buff)
	}
	buff := new(bytes.Buffer)
	e := gob.NewEncoder(buff)
	err := e.Encode(result)
	if err != nil {
		return nil, err
	}
	return buff.Bytes(), nil
}