code: func Append(to interface{}, from ...interface{}) (interface{}, error) {
  	tov, toIsNil := indirect(reflect.ValueOf(to))
  
  	toIsNil = toIsNil || to == nil
  	var tot reflect.Type
  
  	if !toIsNil {
  		if tov.Kind() != reflect.Slice {
  			return nil, fmt.Errorf("expected a slice, got %T", to)
  		}
  
  		tot = tov.Type().Elem()
  		toIsNil = tov.Len() == 0
  
  		if len(from) == 1 {
  			fromv := reflect.ValueOf(from[0])
  			if fromv.Kind() == reflect.Slice {
  				if toIsNil {
  					// If we get nil []string, we just return the []string
  					return from[0], nil
  				}
  
  				fromt := reflect.TypeOf(from[0]).Elem()
  
  				// If we get []string []string, we append the from slice to to
  				if tot == fromt {
  					return reflect.AppendSlice(tov, fromv).Interface(), nil
  				} else if !fromt.AssignableTo(tot) {
  					// Fall back to a []interface{} slice.
  					return appendToInterfaceSliceFromValues(tov, fromv)
  
  				}
  			}
  		}
  	}
  
  	if toIsNil {
  		return Slice(from...), nil
  	}
  
  	for _, f := range from {
  		fv := reflect.ValueOf(f)
  		if !fv.Type().AssignableTo(tot) {
  			// Fall back to a []interface{} slice.
  			return appendToInterfaceSlice(tov, from...)
  		}
  		tov = reflect.Append(tov, fv)
  	}
  
  	return tov.Interface(), nil
  }
docs: // Append appends from to a slice to and returns the resulting slice.
  // If length of from is one and the only element is a slice of same type as to,
  // it will be appended.