func Func(key string, i interface{}) *Function {
	f := &Function{fv: reflect.ValueOf(i)}

	// Derive unique, somewhat stable key for this func.
	_, file, _, _ := runtime.Caller(1)
	fk, err := fileKey(file)
	if err != nil {
		// Not fatal, but log the error
		stdlog.Printf("delay: %v", err)
	}
	f.key = fk + ":" + key

	t := f.fv.Type()
	if t.Kind() != reflect.Func {
		f.err = errors.New("not a function")
		return f
	}
	if t.NumIn() == 0 || !isContext(t.In(0)) {
		f.err = errFirstArg
		return f
	}

	// Register the function's arguments with the gob package.
	// This is required because they are marshaled inside a []interface{}.
	// gob.Register only expects to be called during initialization;
	// that's fine because this function expects the same.
	for i := 0; i < t.NumIn(); i++ {
		// Only concrete types may be registered. If the argument has
		// interface type, the client is resposible for registering the
		// concrete types it will hold.
		if t.In(i).Kind() == reflect.Interface {
			continue
		}
		gob.Register(reflect.Zero(t.In(i)).Interface())
	}

	if old := funcs[f.key]; old != nil {
		old.err = fmt.Errorf("multiple functions registered for %s in %s", key, file)
	}
	funcs[f.key] = f
	return f
}
func Func(key string, i interface{}) *Function {
	f := &Function{fv: reflect.ValueOf(i)}

	
	_, file, _, _ := runtime.Caller(1)
	fk, err := fileKey(file)
	if err != nil {
		
		stdlog.Printf("delay: %v", err)
	}
	f.key = fk + ":" + key

	t := f.fv.Type()
	if t.Kind() != reflect.Func {
		f.err = errors.New("not a function")
		return f
	}
	if t.NumIn() == 0 || !isContext(t.In(0)) {
		f.err = errFirstArg
		return f
	}

	
	
	
	
	for i := 0; i < t.NumIn(); i++ {
		
		
		
		if t.In(i).Kind() == reflect.Interface {
			continue
		}
		gob.Register(reflect.Zero(t.In(i)).Interface())
	}

	if old := funcs[f.key]; old != nil {
		old.err = fmt.Errorf("multiple functions registered for %s in %s", key, file)
	}
	funcs[f.key] = f
	return f
}
func Func ( key string , i interface { } ) * Function { f := & Function { fv : reflect . ValueOf ( i ) } // Derive unique, somewhat stable key for this func. _ , file , _ , _ := runtime . Caller ( 1 ) fk , err := fileKey ( file ) if err != nil { // Not fatal, but log the error stdlog . Printf ( " " , err ) } f . key = fk + " " + key t := f . fv . Type ( ) if t . Kind ( ) != reflect . Func { f . err = errors . New ( " " ) return f } if t . NumIn ( ) == 0 || ! isContext ( t . In ( 0 ) ) { f . err = errFirstArg return f } // Register the function's arguments with the gob package. // This is required because they are marshaled inside a []interface{}. // gob.Register only expects to be called during initialization; // that's fine because this function expects the same. for i := 0 ; i < t . NumIn ( ) ; i ++ { // Only concrete types may be registered. If the argument has // interface type, the client is resposible for registering the // concrete types it will hold. if t . In ( i ) . Kind ( ) == reflect . Interface { continue } gob . Register ( reflect . Zero ( t . In ( i ) ) . Interface ( ) ) } if old := funcs [ f . key ] ; old != nil { old . err = fmt . Errorf ( " " , key , file ) } funcs [ f . key ] = f return f }
// Func declares a new Function. The second argument must be a function with a
// first argument of type context.Context.
// This function must be called at program initialization time. That means it
// must be called in a global variable declaration or from an init function.
// This restriction is necessary because the instance that delays a function
// call may not be the one that executes it. Only the code executed at program
// initialization time is guaranteed to have been run by an instance before it
// receives a request.
Func declares a new Function . The second argument must be a function with a first argument of type context . Context . This function must be called at program initialization time . That means it must be called in a global variable declaration or from an init function . This restriction is necessary because the instance that delays a function call may not be the one that executes it . Only the code executed at program initialization time is guaranteed to have been run by an instance before it receives a request .