code: func (e *edge) execOp(ctx context.Context) (interface{}, error) {
  	cacheKeys, inputs := e.commitOptions()
  	results, subExporters, err := e.op.Exec(ctx, toResultSlice(inputs))
  	if err != nil {
  		return nil, err
  	}
  
  	index := e.edge.Index
  	if len(results) <= int(index) {
  		return nil, errors.Errorf("invalid response from exec need %d index but %d results received", index, len(results))
  	}
  
  	res := results[int(index)]
  
  	for i := range results {
  		if i != int(index) {
  			go results[i].Release(context.TODO())
  		}
  	}
  
  	var exporters []CacheExporter
  
  	for _, cacheKey := range cacheKeys {
  		ck, err := e.op.Cache().Save(cacheKey, res, time.Now())
  		if err != nil {
  			return nil, err
  		}
  
  		if exp, ok := ck.Exporter.(*exporter); ok {
  			exp.edge = e
  		}
  
  		exps := make([]CacheExporter, 0, len(subExporters))
  		for _, exp := range subExporters {
  			exps = append(exps, exp.Exporter)
  		}
  
  		exporters = append(exporters, ck.Exporter)
  		exporters = append(exporters, exps...)
  	}
  
  	ek := make([]ExportableCacheKey, 0, len(cacheKeys))
  	for _, ck := range cacheKeys {
  		ek = append(ek, ExportableCacheKey{
  			CacheKey: ck,
  			Exporter: &mergedExporter{exporters: exporters},
  		})
  	}
  
  	return NewCachedResult(res, ek), nil
  }
docs: // execOp creates a request to execute the vertex operation