}

// Subscribers returns the number of current subscribers for all types.
func (ps *PubSub[T, M]) Subscribers() int32 {
	return atomic.LoadInt32(&ps.numSubscribers)
}

// New inits a PubSub system with a limit of maximum
// subscribers unless zero is specified
func New[T Maskable, M Maskable](maxSubscribers int32) *PubSub[T, M] {
	return &PubSub[T, M]{maxSubscribers: maxSubscribers}

// another (constant) declaration.
func (check *Checker) arity(pos syntax.Pos, names []*syntax.Name, inits []syntax.Expr, constDecl, inherited bool) {
	l := len(names)
	r := len(inits)

	const code = WrongAssignCount
	switch {
	case l < r:
		n := inits[l]
		if inherited {
			check.errorf(pos, code, "extra init expr at %s", n.Pos())
		} else {
			check.errorf(n, code, "extra init expr %s", n)

	case "priority":
		p.next()
		p.initdata.Priority = p.parseInt()
		p.expectEOL()

	case "init":
		p.next()
		for p.tok != '\n' && p.tok != ';' && p.tok != scanner.EOF {
			p.initdata.Inits = append(p.initdata.Inits, p.parsePackageInit())
		}
		p.expectEOL()

	case "init_graph":
		p.next()
		// The graph data is thrown away for now.
		for p.tok != '\n' && p.tok != ';' && p.tok != scanner.EOF {

		// number of initializers must match
		if len(info.InitOrder) != len(test.inits) {
			t.Errorf("package %s: got %d initializers; want %d", name, len(info.InitOrder), len(test.inits))
			continue
		}

		// initializers must match
		for i, want := range test.inits {
			got := info.InitOrder[i].String()
			if got != want {

	inittrace: setting inittrace=1 causes the runtime to emit a single line to standard
	error for each package with init work, summarizing the execution time and memory
	allocation. No information is printed for inits executed as part of plugin loading
	and for packages without both user defined and compiler generated init work.
	The format of this line is subject to change. Currently, it is:
		init # @#ms, # ms clock, # bytes, # allocs

		// number of initializers must match
		if len(info.InitOrder) != len(test.inits) {
			t.Errorf("package %s: got %d initializers; want %d", name, len(info.InitOrder), len(test.inits))
			continue
		}

		// initializers must match
		for i, want := range test.inits {
			got := info.InitOrder[i].String()
			if got != want {

            }
            return -1;
        }

        public void add(ScaledUnits<Q> units) {
            this.units.add(units);
            Collections.sort(this.units);
        }
    }

    private static class ScaledUnits<Q> extends Units<Q> {
        private final BaseUnits<Q> baseUnits;

        }
        int diff = units.compareTo(other.units);
        if (diff == 0) {
            return new Amount<>(value.add(other.value), units);
        }
        if (diff < 0) {
            return new Amount<>(value.add(other.units.scaleTo(other.value, units)), units);
        }
        return new Amount<>(units.scaleTo(value, other.units).add(other.value), other.units);
    }

        5.9     | Fruit.apples  | 2      | Fruit.oranges
    }

    def "can add amounts with same units"() {
        expect:
        Amount.valueOf(a, units) + Amount.valueOf(b, units) == Amount.valueOf(c, units)

        where:
        a    | b     | c      | units
        0    | 0     | 0      | Fruit.apples
        1    | 2     | 3      | Fruit.apples
        1    | 2     | 3      | Fruit.oranges

import java.math.BigDecimal;

public class DataAmount {
    public static final Units<DataAmount> BYTES = Units.base(DataAmount.class, "B");
    public static final Units<DataAmount> KILO_BYTES = BYTES.times(1024, "kB");
    public static final Units<DataAmount> MEGA_BYTES = KILO_BYTES.times(1024, "MB");
    public static final Units<DataAmount> GIGA_BYTES = MEGA_BYTES.times(1024, "GB");