# Histoire, conception et avenir

Il y a quelque temps, <a href="https://github.com/tiangolo/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">un utilisateur de **FastAPI** a demandé</a> :

> Quelle est l'histoire de ce projet ? Il semble être sorti de nulle part et est devenu génial en quelques semaines [...].

Voici un petit bout de cette histoire.

## Alternatives

J'aime entendre parler de l'utilisation du **FastAPI**, de ce que vous avez aimé dedans, dans quel projet/entreprise l'utilisez-vous, etc.

## Voter pour FastAPI

* <a href="https://www.slant.co/options/34241/~fastapi-review" class="external-link" target="_blank">Votez pour **FastAPI** sur Slant</a>.

                 llvm::ArrayRef<mlir::NamedAttribute> attrs);

  // Finds out the function definition for the given function name from the
  // graph and converts it to a function of the module. This method is called
  // on demand because the graph flib_def does not provide an iterator
  // interface.
  Status ConvertLibFunction(llvm::StringRef func_name);

  // Returns the list of nodes in the graph. Nodes are presented in the reverse

moet
ben
zonder
kan
hun
dus
alles
onder
ja
eens
hier
wie
werd
altijd
doch
wordt
wezen
kunnen
ons
zelf
tegen
na
reeds
wil
kon
niets
uw
iemand
geweest

        _ * lock.state
        1 * cleanupExecutor.cleanup()
        0 * _._

        where:
        accessType << [Exclusive, Shared, OnDemand, None]
    }

    def "cleans up on close when clean up has not already occurred"() {
        def access = newAccess(OnDemand)

        when:
        access.open()
        access.close()

        then:
        1 * cleanupExecutor.cleanup()
        0 * _

class PackageDependencyRulesTest {

    @Test
    fun `execution should not depend on provider`() {
        "..execution.." shouldNotDependOn "..provider.."
    }

    @Test
    fun `execution should not depend on resolver`() {
        "..execution.." shouldNotDependOn "..resolver.."
    }

    @Test
    fun `support should not depend on provider`() {
        "..support.." shouldNotDependOn "..provider.."
    }

    }

    def "can depend on char sequence"() {
        def input = new StringBuilder("other")

        given:
        1 * resolver.resolveTask("other") >> otherTask

        when:
        dependency.add(input)

        then:
        dependency.getDependencies(task) == toSet(otherTask)
    }

    def "can depend on a task instance"() {
        when:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

var (
	a, b = f() // ERROR "initialization cycle|depends upon itself|depend upon each other"
	c    = b   // GCCGO_ERROR "depends upon itself|depend upon each other"
)

func f() (int, int) {
	return c, c
}

------------------------------------------------------------

operators - Components that depend on native library 'operators'
+--- operators:failingSharedLibrary
+--- operators:failingStaticLibrary
|    \--- operatorsTest:failingCUnitExe (t)
+--- operators:passingSharedLibrary
\--- operators:passingStaticLibrary
     \--- operatorsTest:passingCUnitExe (t)

operatorsTest - Components that depend on Cunit test suite 'operatorsTest'
+--- operatorsTest:failingCUnitExe (t)

import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.TypeName;
import org.objectweb.asm.Type;

/**
 * Used since we don't want to depend on Gradle types directly, since that way we have to depend on Gradle projects like core-api.
 * And we don't want to depend on Gradle projects since that way we can't apply this annotation processor to them.
 */
public enum GradleReferencedType {