package singleflight

Import Path
	internal/singleflight (on go.dev)

Dependency Relation
	imports one package, and imported by one package

Involved Source Files

	   #d singleflight.go
		Package singleflight provides a duplicate function call suppression
		mechanism.
Package-Level Type Names (total 3, in which 2 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Group (struct)
		Group represents a class of work and forms a namespace in
		which units of work can be executed with duplicate suppression.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			m map[string]*call
				// lazily initialized

			mu sync.Mutex
				// protects m

		Methods (total 4, in which 3 are exported)
			(*T) Do(key string, fn func() (interface{}, error)) (v interface{}, err error, shared bool)
				Do executes and returns the results of the given function, making
				sure that only one execution is in-flight for a given key at a
				time. If a duplicate comes in, the duplicate caller waits for the
				original to complete and receives the same results.
				The return value shared indicates whether v was given to multiple callers.

			(*T) DoChan(key string, fn func() (interface{}, error)) (<-chan Result, bool)
				DoChan is like Do but returns a channel that will receive the
				results when they are ready. The second result is true if the function
				will eventually be called, false if it will not (because there is
				a pending request with this key).

			(*T) ForgetUnshared(key string) bool
				ForgetUnshared tells the singleflight to forget about a key if it is not
				shared with any other goroutines. Future calls to Do for a forgotten key
				will call the function rather than waiting for an earlier call to complete.
				Returns whether the key was forgotten or unknown--that is, whether no
				other goroutines are waiting for the result.

			/* one unexported ... *//* one unexported: */
			(*T) doCall(c *call, key string, fn func() (interface{}, error))
				doCall handles the single call for a key.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func net.(*Resolver).getLookupGroup() *Group

	 type Result (struct)
		Result holds the results of Do, so they can be passed
		on a channel.

		Fields (total 3, all are exported)
			Err error
			Shared bool
			Val interface{}
		As Outputs Of (at least one exported)
			func (*Group).DoChan(key string, fn func() (interface{}, error)) (<-chan Result, bool)

	/* one unexported ... *//* one unexported: */
	 type call (struct)
		call is an in-flight or completed singleflight.Do call

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			chans []chan<- Result
			dups int
				These fields are read and written with the singleflight
				mutex held before the WaitGroup is done, and are read but
				not written after the WaitGroup is done.

			err error
			val interface{}
				These fields are written once before the WaitGroup is done
				and are only read after the WaitGroup is done.

			wg sync.WaitGroup
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Group).doCall(c *call, key string, fn func() (interface{}, error))

The pages are generated with Golds v0.4.2. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.