package main

import (
	"./a"
	"fmt"
)

func main() {
	const want = 120

	if got := a.Fact(5); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	if got := a.Fact[int64](5); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	if got := a.Fact(5.0); got != want {
		panic(fmt.Sprintf("got %f, want %f", got, want))
	}

            throws MisconfiguredToolchainException {
        List<ToolchainPrivate> toRet = new ArrayList<>();

        ToolchainFactory fact = factories.get(type);
        if (fact == null) {
            logger.error("Missing toolchain factory for type: " + type + ". Possibly caused by misconfigured project.");
        } else {
            List<ToolchainModel> availableToolchains =

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

func Fact[T interface{ int | int64 | float64 }](n T) T {
	if n == 1 {
		return 1
	}
	return n * Fact(n-1)

Most source code in Gradle is arranged by which part(s) of the build state model it acts on.
This affects the lifecycle of the code and the set of services available for dependency injection.
When working on some source code it is important to be aware of the model it acts on.  

        model.wtp.facet.facets.empty

        when: "configure wtp component and facet"
        model.wtp.component({ comp -> comp.deployName = 'name' } as Action<EclipseWtpComponent>)
        model.wtp.facet({ fac -> fac.facets.add(new Facet()) } as Action<EclipseWtpFacet>)

        then:
        model.wtp.component.deployName == 'name'
        model.wtp.facet.facets.size() == 1

                new Facet(FacetType.installed, 'jst.utility', '1.0'),
                new Facet(FacetType.installed, 'jst.java', '1.7')])
    }

    def "can add custom facets to java default facets"() {
        when:
        project.apply(plugin: 'java')
        wtpPlugin.apply(project)
        project.sourceCompatibility = 1.3

        project.eclipse.wtp {
            facet {

/**
 * A [KaSubstitutor] which substitution logic can be represented as a [Map] from a [KaTypeParameterSymbol] to corresponding [KaType]
 * This is an implementation details and Analysis API clients should not depend on the fact if some [KaSubstitutor] is [KaMapBackedSubstitutor] or not.
 */
@KaAnalysisApiInternals
interface KaMapBackedSubstitutor : KaSubstitutor {
    /**
     * Substitution rules in a form of a `Map<KaTypeParameterSymbol, KaType>`

    facet {
      file {
        beforeMerged {
          assert it.facets.contains(new Facet('facet.one', '1.0'))
          it.facets.add(new Facet('facet.two', '2.0'))
        }
        whenMerged {
          assert it.facets.contains(new Facet('facet.one', '1.0'))
          assert it.facets.contains(new Facet('facet.two', '2.0'))
          it.facets.add(new Facet('facet.three', '3.0'))
        }

        List<Toolchain> toolchains = new ArrayList<>();

        if (models != null) {
            ToolchainFactory fact = factories.get(type);

            if (fact == null) {
                logger.error(
                        "Missing toolchain factory for type: " + type + ". Possibly caused by misconfigured project.");
            } else {

        withModuleMetadata(expectation)
        withoutModuleMetadata(expectation)
    }

    /**
     * Short-hand notation for expecting a list of files independently of the fact module metadata is used or not
     * @param fileNames
     */
    void expectFiles(String... fileNames) {
        always {
            expectFiles(fileNames as List<String>)
        }
    }