Make LazyMultiError constructed via function

service/datastore/datastore.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package datastore
 
 import (
         "fmt"
         "reflect"
 
@@ skipping 82 matching lines @@
                         return true
                 })
         }
 
         slice := v.Elem()
         mat := parseMultiArg(slice.Type())
         if !mat.valid || mat.newElem == nil {
                 return fmt.Errorf("invalid GetAll input type: %T", dst)
         }
 
-        lme := errors.LazyMultiError{Size: slice.Len()}
+        lme := errors.NewLazyMultiError(slice.Len())
         i := 0
         err := d.RawInterface.Run(q, func(k Key, pm PropertyMap, _ CursorCB) bool {
                 slice.Set(reflect.Append(slice, mat.newElem()))
                 itm := slice.Index(i)
                 mat.setKey(itm, k)
                 lme.Assign(i, mat.setPM(itm, pm))
                 i++
                 return true
         })
         if err == nil {
@@ skipping 35 matching lines @@
         mat := parseMultiArg(slice.Type())
         if !mat.valid {
                 return fmt.Errorf("invalid GetMulti input type: %T", dst)
         }
 
         keys, pms, err := mat.GetKeysPMs(d.NewKey, slice)
         if err != nil {
                 return err
         }
 
-        lme := errors.LazyMultiError{Size: len(keys)}
+        lme := errors.NewLazyMultiError(len(keys))
         i := 0
         meta := NewMultiMetaGetter(pms)
         err = d.RawInterface.GetMulti(keys, meta, func(pm PropertyMap, err error) {
                 if !lme.Assign(i, err) {
                         lme.Assign(i, mat.setPM(slice.Index(i), pm))
                 }
                 i++
         })
 
         if err == nil {
                 err = lme.Get()
         }
         return err
 }
 
 func (d *datastoreImpl) PutMulti(src interface{}) error {
         slice := reflect.ValueOf(src)
         mat := parseMultiArg(slice.Type())
         if !mat.valid {
                 return fmt.Errorf("invalid PutMulti input type: %T", src)
         }
 
         keys, vals, err := mat.GetKeysPMs(d.NewKey, slice)
         if err != nil {
                 return err
         }
 
-        lme := errors.LazyMultiError{Size: len(keys)}
+        lme := errors.NewLazyMultiError(len(keys))
         i := 0
         err = d.RawInterface.PutMulti(keys, vals, func(key Key, err error) {
                 if key != keys[i] {
                         mat.setKey(slice.Index(i), key)
                 }
                 lme.Assign(i, err)
                 i++
         })
 
         if err == nil {
                 err = lme.Get()
         }
         return err
 }
 
 func (d *datastoreImpl) DeleteMulti(keys []Key) (err error) {
-        lme := errors.LazyMultiError{Size: len(keys)}
+        lme := errors.NewLazyMultiError(len(keys))
         i := 0
         extErr := d.RawInterface.DeleteMulti(keys, func(internalErr error) {
                 lme.Assign(i, internalErr)
                 i++
         })
         err = lme.Get()
         if err == nil {
                 err = extErr
         }
         return
 }
 
 func (d *datastoreImpl) Raw() RawInterface {
         return d.RawInterface
 }