func (rl *MultiRateLimiterImpl) Rate() float64 {
	result := rl.rateLimiters[0].Rate()
	for _, rateLimiter := range rl.rateLimiters {
		newRate := rateLimiter.Rate()
		if result > newRate {
			result = newRate
		}
	}
	return result
}
Rate returns the rate per second for this rate limiter
package quotas
import (
	"context"
	"fmt"
	"time"
	"golang.org/x/time/rate"
)
const (
	InfDuration = rate.InfDuration
)
type (
	MultiRateLimiterImpl struct {
		rateLimiters []RateLimiter
	}
)
var _ RateLimiter = (*MultiRateLimiterImpl)(nil)
func NewMultiRateLimiter(
	rateLimiters []RateLimiter,
) *MultiRateLimiterImpl {
	if len(rateLimiters) == 0 {
		panic("expect at least one rate limiter")
	}
	return &MultiRateLimiterImpl{
		rateLimiters: rateLimiters,
	}
}
func (rl *MultiRateLimiterImpl) Allow() bool {
	return rl.AllowN(time.Now(), 1)
}
func (rl *MultiRateLimiterImpl) AllowN(now time.Time, numToken int) bool {
	length := len(rl.rateLimiters)
	reservations := make([]Reservation, 0, length)
	for _, rateLimiter := range rl.rateLimiters {
		reservation := rateLimiter.ReserveN(now, numToken)
		if !reservation.OK() || reservation.DelayFrom(now) > 0 {
			if reservation.OK() {
				reservation.CancelAt(now)
			}
			for _, reservation := range reservations {
				reservation.CancelAt(now)
			}
			return false
		}
		reservations = append(reservations, reservation)
	}
	return true
}
func (rl *MultiRateLimiterImpl) Reserve() Reservation {
	return rl.ReserveN(time.Now(), 1)
}
func (rl *MultiRateLimiterImpl) ReserveN(now time.Time, numToken int) Reservation {
	length := len(rl.rateLimiters)
	reservations := make([]Reservation, 0, length)
	for _, rateLimiter := range rl.rateLimiters {
		reservation := rateLimiter.ReserveN(now, numToken)
		if !reservation.OK() {
			for _, reservation := range reservations {
				reservation.CancelAt(now)
			}
			return NewMultiReservation(false, nil)
		}
		reservations = append(reservations, reservation)
	}
	return NewMultiReservation(true, reservations)
}
func (rl *MultiRateLimiterImpl) Wait(ctx context.Context) error {
	return rl.WaitN(ctx, 1)
}
func (rl *MultiRateLimiterImpl) WaitN(ctx context.Context, numToken int) error {
	select {
	case <-ctx.Done():
		return ctx.Err()
	default:
	}
	now := time.Now().UTC()
	reservation := rl.ReserveN(now, numToken)
	if !reservation.OK() {
		return fmt.Errorf("rate: Wait(n=%d) would exceed context deadline", numToken)
	}
	delay := reservation.DelayFrom(now)
	if delay == 0 {
		return nil
	}
	waitLimit := InfDuration
	if deadline, ok := ctx.Deadline(); ok {
		waitLimit = deadline.Sub(now)
	}
	if waitLimit < delay {
		reservation.CancelAt(now)
		return fmt.Errorf("rate: Wait(n=%d) would exceed context deadline", numToken)
	}
	t := time.NewTimer(delay)
	defer t.Stop()
	select {
	case <-t.C:
		return nil
	case <-ctx.Done():
		reservation.CancelAt(time.Now())
		return ctx.Err()
	}
}