consumer.accept(get());
    }

    /**
     * Applies a function to the lazily computed value and returns its value
     *
     * @param function the value to apply to the lazily computed value
     * @param <V> the return type
     * @return the result of the function, applied on the lazily computed value
     */
    default <V> V apply(Function<? super T, V> function) {

	if lazy.req != nil {
		return audit.GetAuditIDTruncated(lazy.req.Context())
	}

	return "unknown"
}

// lazyVerb implements String() string and it will
// lazily get normalized Verb
type lazyVerb struct {
	req *http.Request
}

func (lazy *lazyVerb) String() string {
	if lazy.req == nil {
		return "unknown"
	}
	return metrics.NormalizedVerb(lazy.req)
}

	res T
	err error

	done uint32
	m    sync.Mutex
}

var _ Lazy[any] = &lazyImpl[any]{}

// New returns a new lazily computed value. The value is guaranteed to only be computed a single time.
func New[T any](f func() (T, error)) Lazy[T] {
	return &lazyImpl[T]{getter: f}
}

// NewWithRetry returns a new lazily computed value. The value will be computed on each call until a
// non-nil error is returned.

 * limitations under the License.
 */
package org.gradle.api;

/**
 * Types can implement this interface when they provide a human-readable display name.
 * It is strongly encouraged to compute this display name lazily: computing a display name,
 * even if it's only a string concatenation, can take a significant amount of time during
 * configuration for something that would only be used, typically, in error messages.
 *
 * @since 3.4
 */

class KtStaticModuleDependentsProvider(private val modules: List<KtModule>) : KotlinModuleDependentsProviderBase() {
    private val directDependentsByKtModule: Map<KtModule, Set<KtModule>> by lazy {
        // Direct dependencies should be computed lazily, because the built-ins module will be reachable via module dependencies. Getting
        // the built-ins module relies on the built-ins session, which may depend on services that are registered after

        then:
        extension.baseDir == new File(project.file("newBuildDir"), ReportingExtension.DEFAULT_REPORTS_DIR_NAME)
    }

    def "reports dir can be changed lazily"() {
        given:
        def dir = "a"

        when:
        extension.baseDir = { dir }

        then:
        extension.baseDir == project.file("a")

        when:
        dir = "b"

                outputFile = layout.buildDirectory.file("merged.txt")
                inputFiles.add(createFile1.outputFile)
                inputFiles.add(createFile2.outputFile)
            }

            // Set values lazily
            createFile1.inputFile = layout.projectDirectory.file("file1-source.txt")
            createFile1.outputFile = layout.buildDirectory.file("file1.txt")

import org.jetbrains.kotlin.analysis.api.symbols.KaSymbolOrigin
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol

/**
 * A [KaFirSymbol] that is backed by some [PsiElement] and builds [firSymbol] lazily (by convention), allowing some properties to be
 * calculated without the need to build a [firSymbol].
 */
internal interface KaFirPsiSymbol<P : PsiElement, out S : FirBasedSymbol<*>> : KaFirSymbol<S> {
    override val psi: P

  }

  /**
   * Creates a {@code Striped<Lock>} with lazily initialized, weakly referenced locks. Every lock is
   * reentrant.
   *
   * @param stripes the minimum number of stripes (locks) required
   * @return a new {@code Striped<Lock>}
   */
  public static Striped<Lock> lazyWeakLock(int stripes) {
    return lazy(stripes, () -> new ReentrantLock(false));
  }

    /**
     * Lazily adds a collection of outgoing artifacts to this configuration. These artifacts are included in all variants.
     *
     * @param provider The provider of the artifacts to add.
     * @since 7.4
     */
    void artifacts(Provider<? extends Iterable<?>> provider);

    /**