1,
		2,
		3,
	} // GC_ERROR "too few values in"

	_ = Foo{
		1,
		2,
		3,
		Bar{"A", "B"}, // ERROR "too many values in|too many expressions"
	}

	_ = Foo{ // GCCGO_ERROR "too few expressions"
		1,
		2,
		Bar{"A", "B"}, // ERROR "too many values in|too many expressions"
	} // GC_ERROR "too few values in"

func f(x int, y uint) {
	if true {
		return "a" > 10 // ERROR "^too many arguments to return$|return with value in function with no return|no result values expected|mismatched types"
	}
	return "gopher" == true, 10 // ERROR "^too many arguments to return$|return with value in function with no return|no result values expected|mismatched types"
}

func main() {
	f(2, 3 < "x", 10) // ERROR "too many arguments|invalid operation|incompatible type"

// run
//go:build !gcflags_noopt

// Copyright 2010 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.

// Test that many initializations can be done at link time and
// generate no executable init functions.
// Also test that trivial func init are optimized away.

package main

import (
	"errors"
	"unsafe"
)

// die after running into an undefined
// type in the argument list for a
// function.
// Does not compile.

package main

func mine(int b) int { // ERROR "undefined.*b"
	return b + 2 // ERROR "undefined.*b"
}

func main() {
	mine()     // ERROR "not enough arguments"
	c = mine() // ERROR "undefined.*c|not enough arguments"

<img src="/img/tutorial/websockets/image02.png">

And your **FastAPI** application with WebSockets will respond back:

<img src="/img/tutorial/websockets/image03.png">

You can send (and receive) many messages:

<img src="/img/tutorial/websockets/image04.png">

And all of them will use the same WebSocket connection.

## Using `Depends` and others

## Future

By this point, it's already clear that **FastAPI** with its ideas is being useful for many people.

It is being chosen over previous alternatives for suiting many use cases better.

Many developers and teams already depend on **FastAPI** for their projects (including me and my team).

But still, there are many improvements and features to come.

**FastAPI** has a great future ahead.

// run

// Copyright 2015 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.

// Test that tiny allocations with finalizers are correctly profiled.
// Previously profile special records could have been processed prematurely
// (while the object is still live).

package main

import (
	"runtime"
	"time"
	"unsafe"
)

func main() {

func f2ddd(_, _ int, _ ...int)

func f() {
	var x int
	f0(1)              // ERROR "too many arguments in call to f0\n\thave \(number\)\n\twant \(\)"
	f0(x)              // ERROR "too many arguments in call to f0\n\thave \(int\)\n\twant \(\)"
	f1()               // ERROR "not enough arguments in call to f1\n\thave \(\)\n\twant \(int\)"
	f1(1, 2)           // ERROR "too many arguments in call to f1\n\thave \(number, number\)\n\twant \(int\)"

}

func ExampleDumpRequestOut() {
	const body = "Go is a general-purpose language designed with systems programming in mind."
	req, err := http.NewRequest("PUT", "http://www.example.org", strings.NewReader(body))
	if err != nil {
		log.Fatal(err)
	}

func.func @fakeQuantFolded() -> (tensor<8xf32>) {
  %in = arith.constant dense<0.0> : tensor<8xf32>
  %min = arith.constant dense<0.0> : tensor<f32>
  %max = arith.constant dense<255.0> : tensor<f32>
  %mini = "tf.Identity"(%min) : (tensor<f32>) -> tensor<f32>
  %maxi = "tf.Identity"(%max) : (tensor<f32>) -> tensor<f32>
  %rst = "tf.FakeQuantWithMinMaxVars"(%in, %mini, %maxi) {num_bits = 5, narrow_range = false} : (tensor<8xf32>, tensor<f32>, tensor<f32>) -> tensor<8xf32>