code: func (s *Slot) initiateFetch(c context.Context, fetcher Fetcher, now time.Time) (bool, interface{}, error) {
  	s.lock.Lock()
  	defer s.lock.Unlock()
  
  	// A cached value exists and it is still fresh? Return it right away. Someone
  	// refetched it already.
  	if s.initialized && isFresh(s.exp, now) {
  		return false, s.current, nil
  	}
  
  	// Fetching the value for the first time ever? Do it under the lock because
  	// there's nothing to return yet. All goroutines would have to wait for this
  	// initial fetch to complete. They'll all block on s.lock.RLock() in Get(...).
  	if !s.initialized {
  		result, exp, err := fetcher(nil)
  		if err != nil {
  			return false, nil, err
  		}
  		s.initialized = true
  		s.current = result
  		s.exp = setExpiry(c, exp)
  		return false, s.current, nil
  	}
  
  	// We have a cached copy but it has expired. Maybe some other goroutine is
  	// fetching it already? Return the cached stale copy if so.
  	if s.fetching {
  		return false, s.current, nil
  	}
  
  	// No one is fetching the value now, we should do it. Make other goroutines
  	// know we'll be fetching. Return the current value as well, to pass it to
  	// the fetch callback.
  	s.fetching = true
  	return true, s.current, nil
  }
docs: // initiateFetch modifies state of Slot to indicate that the current goroutine
  // is going to do the fetch if no one is fetching it now.
  //
  // Returns:
  //   * (true, known value, nil) if the current goroutine should refetch.
  //   * (false, known value, nil) if the fetch is no longer necessary.
  //   * (false, nil, err) if the initial fetch failed.