These dependencies can `raise` exceptions, the same as normal dependencies:

{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[10,15] *}

### Return values { #return-values }

And they can return values or not, the values won't be used.

So, you can reuse a normal dependency (that returns a value) you already use somewhere else, and even though the value won't be used, the dependency will be executed:

  // Views

  /**
   * {@inheritDoc}
   *
   * <p>Because a bimap has unique values, this method returns a {@link Set}, instead of the {@link
   * java.util.Collection} specified in the {@link Map} interface.
   */
  @Override
  Set<V> values();

  /**
   * Returns the inverse view of this bimap, which maps each of this bimap's values to its

public interface SourceSinkFactory<S, T> {

  /**
   * Returns the data to expect the source or sink to contain given the data that was used to create
   * the source or written to the sink. Typically, this will just return the input directly, but in
   * some cases it may alter the input. For example, if the factory returns a sliced view of a
   * source created with some given bytes, this method would return a subsequence of the given
   * (byte[]) data.
   */

			return quotaCfg, fmt.Errorf("invalid quota type 'fifo'")
		}
		return quotaCfg, fmt.Errorf("Invalid quota config %#v", quotaCfg)
	}
	return quotaCfg, err
}

func (sys *BucketQuotaSys) enforceQuotaHard(ctx context.Context, bucket string, size int64) error {
	if size < 0 {
		return nil
	}

	q, err := sys.Get(ctx, bucket)
	if err != nil {

			}
			s = []rune{}

		case escape:
			if i == patLen-1 {
				return false, errMalformedEscapeSequence
			}
			// Otherwise do nothing.

		default:
			s = append(s, r)
		}
	}
	if hasLeadingPercent {
		return strings.HasSuffix(text, string(s)), nil
	}
	return string(s) == text, nil
}

// matcher - Finds `pat` in `text`, and returns the part remainder of

}

// Send a payload to the remote server.
func (s *Stream) Send(b []byte) error {
	if s.Requests == nil {
		return errors.New("stream does not accept requests")
	}
	select {
	case s.Requests <- b:
		return nil
	case <-s.ctx.Done():
		return context.Cause(s.ctx)
	}
}

// Results returns the results from the remote server one by one.
// If any error is returned by the callback, the stream will be canceled.

	hasMonth := t.Month() != 1

	switch {
	case hasFracSecond:
		return t.Format(layoutNanosecond)
	case hasSecond:
		return t.Format(layoutSecond)
	case hasTime || hasZone:
		return t.Format(layoutMinute)
	case hasDay:
		return t.Format(layoutDay)
	case hasMonth:
		return t.Format(layoutMonth)
	default:
		return t.Format(layoutYear)
	}
}

const (
	timePartYear           = "YEAR"

func (c *Config) Enabled() bool {
	configLock.RLock()
	defer configLock.RUnlock()

	return c.Enable
}

// FrequencyDur - returns the currently configured callhome frequency
func (c *Config) FrequencyDur() time.Duration {
	configLock.RLock()
	defer configLock.RUnlock()

	if c.Frequency == 0 {
		return callhomeCycleDefault
	}

	return c.Frequency
}

// Update updates new callhome frequency

    T defaultValue = DEFAULTS.getInstance(type);
    if (defaultValue != null) {
      return defaultValue;
    }
    Class<? extends T> implementation = getImplementation(type);
    if (implementation != null) {
      return get(implementation);
    }
    if (type.isEnum()) {
      T[] enumConstants = type.getEnumConstants();
      return (enumConstants == null || enumConstants.length == 0) ? null : enumConstants[0];
    }

     */
    private samr() {
        // Utility class
    }

    /**
     * Returns the RPC interface syntax UUID and version for SAMR protocol.
     *
     * @return The SAMR interface UUID string
     */
    public static String getSyntax() {
        return "12345778-1234-abcd-ef00-0123456789ac:1.0";
    }

    /** Account control bit flag: Account is disabled */