func (f *Function) Task(args ...interface{}) (*taskqueue.Task, error) {
	if f.err != nil {
		return nil, fmt.Errorf("delay: func is invalid: %v", f.err)
	}

	nArgs := len(args) + 1 // +1 for the context.Context
	ft := f.fv.Type()
	minArgs := ft.NumIn()
	if ft.IsVariadic() {
		minArgs--
	}
	if nArgs < minArgs {
		return nil, fmt.Errorf("delay: too few arguments to func: %d < %d", nArgs, minArgs)
	}
	if !ft.IsVariadic() && nArgs > minArgs {
		return nil, fmt.Errorf("delay: too many arguments to func: %d > %d", nArgs, minArgs)
	}

	// Check arg types.
	for i := 1; i < nArgs; i++ {
		at := reflect.TypeOf(args[i-1])
		var dt reflect.Type
		if i < minArgs {
			// not a variadic arg
			dt = ft.In(i)
		} else {
			// a variadic arg
			dt = ft.In(minArgs).Elem()
		}
		// nil arguments won't have a type, so they need special handling.
		if at == nil {
			// nil interface
			switch dt.Kind() {
			case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
				continue // may be nil
			}
			return nil, fmt.Errorf("delay: argument %d has wrong type: %v is not nilable", i, dt)
		}
		switch at.Kind() {
		case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
			av := reflect.ValueOf(args[i-1])
			if av.IsNil() {
				// nil value in interface; not supported by gob, so we replace it
				// with a nil interface value
				args[i-1] = nil
			}
		}
		if !at.AssignableTo(dt) {
			return nil, fmt.Errorf("delay: argument %d has wrong type: %v is not assignable to %v", i, at, dt)
		}
	}

	inv := invocation{
		Key:  f.key,
		Args: args,
	}

	buf := new(bytes.Buffer)
	if err := gob.NewEncoder(buf).Encode(inv); err != nil {
		return nil, fmt.Errorf("delay: gob encoding failed: %v", err)
	}

	return &taskqueue.Task{
		Path:    path,
		Payload: buf.Bytes(),
	}, nil
}
func (f *Function) Task(args ...interface{}) (*taskqueue.Task, error) {
	if f.err != nil {
		return nil, fmt.Errorf("delay: func is invalid: %v", f.err)
	}

	nArgs := len(args) + 1 
	ft := f.fv.Type()
	minArgs := ft.NumIn()
	if ft.IsVariadic() {
		minArgs--
	}
	if nArgs < minArgs {
		return nil, fmt.Errorf("delay: too few arguments to func: %d < %d", nArgs, minArgs)
	}
	if !ft.IsVariadic() && nArgs > minArgs {
		return nil, fmt.Errorf("delay: too many arguments to func: %d > %d", nArgs, minArgs)
	}

	
	for i := 1; i < nArgs; i++ {
		at := reflect.TypeOf(args[i-1])
		var dt reflect.Type
		if i < minArgs {
			
			dt = ft.In(i)
		} else {
			
			dt = ft.In(minArgs).Elem()
		}
		
		if at == nil {
			
			switch dt.Kind() {
			case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
				continue 
			}
			return nil, fmt.Errorf("delay: argument %d has wrong type: %v is not nilable", i, dt)
		}
		switch at.Kind() {
		case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
			av := reflect.ValueOf(args[i-1])
			if av.IsNil() {
				
				
				args[i-1] = nil
			}
		}
		if !at.AssignableTo(dt) {
			return nil, fmt.Errorf("delay: argument %d has wrong type: %v is not assignable to %v", i, at, dt)
		}
	}

	inv := invocation{
		Key:  f.key,
		Args: args,
	}

	buf := new(bytes.Buffer)
	if err := gob.NewEncoder(buf).Encode(inv); err != nil {
		return nil, fmt.Errorf("delay: gob encoding failed: %v", err)
	}

	return &taskqueue.Task{
		Path:    path,
		Payload: buf.Bytes(),
	}, nil
}
func ( f * Function ) Task ( args ... interface { } ) ( * taskqueue . Task , error ) { if f . err != nil { return nil , fmt . Errorf ( " " , f . err ) } nArgs := len ( args ) + 1 // +1 for the context.Context ft := f . fv . Type ( ) minArgs := ft . NumIn ( ) if ft . IsVariadic ( ) { minArgs -- } if nArgs < minArgs { return nil , fmt . Errorf ( " " , nArgs , minArgs ) } if ! ft . IsVariadic ( ) && nArgs > minArgs { return nil , fmt . Errorf ( " " , nArgs , minArgs ) } // Check arg types. for i := 1 ; i < nArgs ; i ++ { at := reflect . TypeOf ( args [ i - 1 ] ) var dt reflect . Type if i < minArgs { // not a variadic arg dt = ft . In ( i ) } else { // a variadic arg dt = ft . In ( minArgs ) . Elem ( ) } // nil arguments won't have a type, so they need special handling. if at == nil { // nil interface switch dt . Kind ( ) { case reflect . Chan , reflect . Func , reflect . Interface , reflect . Map , reflect . Ptr , reflect . Slice : continue // may be nil } return nil , fmt . Errorf ( " " , i , dt ) } switch at . Kind ( ) { case reflect . Chan , reflect . Func , reflect . Interface , reflect . Map , reflect . Ptr , reflect . Slice : av := reflect . ValueOf ( args [ i - 1 ] ) if av . IsNil ( ) { // nil value in interface; not supported by gob, so we replace it // with a nil interface value args [ i - 1 ] = nil } } if ! at . AssignableTo ( dt ) { return nil , fmt . Errorf ( " " , i , at , dt ) } } inv := invocation { Key : f . key , Args : args , } buf := new ( bytes . Buffer ) if err := gob . NewEncoder ( buf ) . Encode ( inv ) ; err != nil { return nil , fmt . Errorf ( " " , err ) } return & taskqueue . Task { Path : path , Payload : buf . Bytes ( ) , } , nil }
// Task creates a Task that will invoke the function.
// Its parameters may be tweaked before adding it to a queue.
// Users should not modify the Path or Payload fields of the returned Task.
Task creates a Task that will invoke the function . Its parameters may be tweaked before adding it to a queue . Users should not modify the Path or Payload fields of the returned Task .