package singleflight

Import Path
	github.com/aws/smithy-go/internal/sync/singleflight (on go.dev)

Dependency Relation
	imports 6 packages, and imported by one package

Involved Source Files

	      docs.go
	      singleflight.go
Package-Level Type Names (total 4, 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)
			(*Group) 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.

			(*Group) DoChan(key string, fn func() (interface{}, error)) <-chan Result
				DoChan is like Do but returns a channel that will receive the
				results when they are ready.

				The returned channel will not be closed.

			(*Group) Forget(key string)
				Forget tells the singleflight to forget about a key.  Future calls
				to Do for this key will call the function rather than waiting for
				an earlier call to complete.

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


	 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 any
		As Outputs Of (at least one exported)
			func (*Group).DoChan(key string, fn func() (interface{}, error)) <-chan Result

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

		Fields (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 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
			forgotten bool
				forgotten indicates whether Forget was called with this call's key
				while the call was still in flight.

			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))

	 type panicError (struct)
		A panicError is an arbitrary value recovered from a panic
		with the stack trace during the execution of given function.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			stack []byte
			value interface{}
		Methods (only one, which is exported)
			(*panicError) Error() string
				Error implements error interface.

		Implements (at least one exported)
			*panicError : error


Package-Level Functions (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	 func newPanicError(v interface{}) error
Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var errGoexit error
		errGoexit indicates the runtime.Goexit was called in
		the user given function.

The pages are generated with Golds v0.4.9. (GOOS=linux GOARCH=amd64)