assignment to go

• Google Classroom
• Google Workspace Admin
• Google Cloud

Getting started with Assignments

Learn how to use Assignments to easily distribute, analyze, and grade student work – all while using the collaborative power of Google Workspace.

Find tips and tricks from teachers like you

Get the most out of Assignments with these simple tips from fellow teachers and educators.

Discover training lessons and related resources to accelerate your learning

Error loading content :( Please try again later

• {[ item.label ]}

{[ collectionContentCtrl.activeTopic.label ]} All resources  ({[ collectionContentCtrl.totalItemsCount ]})

{[ item.eyebrow ]}

{[ item.name ]}

{[ item.description ]}

{[ item.featured_text ]}

No results matching your selection :( Clear filters to show all results

Dive into Assignments

Already have Google Workspace for Education? Sign in to Assignments to explore the features and capabilities.

Get support from our help center

See how assignments can help you easily distribute, analyze, and grade student work, you're now viewing content for united states..

For content more relevant to your region, choose a different location:

Understanding Assignments

What this handout is about.

The first step in any successful college writing venture is reading the assignment. While this sounds like a simple task, it can be a tough one. This handout will help you unravel your assignment and begin to craft an effective response. Much of the following advice will involve translating typical assignment terms and practices into meaningful clues to the type of writing your instructor expects. See our short video for more tips.

Basic beginnings

Regardless of the assignment, department, or instructor, adopting these two habits will serve you well :

• Read the assignment carefully as soon as you receive it. Do not put this task off—reading the assignment at the beginning will save you time, stress, and problems later. An assignment can look pretty straightforward at first, particularly if the instructor has provided lots of information. That does not mean it will not take time and effort to complete; you may even have to learn a new skill to complete the assignment.
• Ask the instructor about anything you do not understand. Do not hesitate to approach your instructor. Instructors would prefer to set you straight before you hand the paper in. That’s also when you will find their feedback most useful.

Assignment formats

Many assignments follow a basic format. Assignments often begin with an overview of the topic, include a central verb or verbs that describe the task, and offer some additional suggestions, questions, or prompts to get you started.

An Overview of Some Kind

The instructor might set the stage with some general discussion of the subject of the assignment, introduce the topic, or remind you of something pertinent that you have discussed in class. For example:

“Throughout history, gerbils have played a key role in politics,” or “In the last few weeks of class, we have focused on the evening wear of the housefly …”

The Task of the Assignment

Pay attention; this part tells you what to do when you write the paper. Look for the key verb or verbs in the sentence. Words like analyze, summarize, or compare direct you to think about your topic in a certain way. Also pay attention to words such as how, what, when, where, and why; these words guide your attention toward specific information. (See the section in this handout titled “Key Terms” for more information.)

“Analyze the effect that gerbils had on the Russian Revolution”, or “Suggest an interpretation of housefly undergarments that differs from Darwin’s.”

Additional Material to Think about

Here you will find some questions to use as springboards as you begin to think about the topic. Instructors usually include these questions as suggestions rather than requirements. Do not feel compelled to answer every question unless the instructor asks you to do so. Pay attention to the order of the questions. Sometimes they suggest the thinking process your instructor imagines you will need to follow to begin thinking about the topic.

“You may wish to consider the differing views held by Communist gerbils vs. Monarchist gerbils, or Can there be such a thing as ‘the housefly garment industry’ or is it just a home-based craft?”

These are the instructor’s comments about writing expectations:

“Be concise”, “Write effectively”, or “Argue furiously.”

Technical Details

These instructions usually indicate format rules or guidelines.

“Your paper must be typed in Palatino font on gray paper and must not exceed 600 pages. It is due on the anniversary of Mao Tse-tung’s death.”

The assignment’s parts may not appear in exactly this order, and each part may be very long or really short. Nonetheless, being aware of this standard pattern can help you understand what your instructor wants you to do.

Interpreting the assignment

Ask yourself a few basic questions as you read and jot down the answers on the assignment sheet:

Why did your instructor ask you to do this particular task?

Who is your audience.

• What kind of evidence do you need to support your ideas?

What kind of writing style is acceptable?

• What are the absolute rules of the paper?

Try to look at the question from the point of view of the instructor. Recognize that your instructor has a reason for giving you this assignment and for giving it to you at a particular point in the semester. In every assignment, the instructor has a challenge for you. This challenge could be anything from demonstrating an ability to think clearly to demonstrating an ability to use the library. See the assignment not as a vague suggestion of what to do but as an opportunity to show that you can handle the course material as directed. Paper assignments give you more than a topic to discuss—they ask you to do something with the topic. Keep reminding yourself of that. Be careful to avoid the other extreme as well: do not read more into the assignment than what is there.

Of course, your instructor has given you an assignment so that they will be able to assess your understanding of the course material and give you an appropriate grade. But there is more to it than that. Your instructor has tried to design a learning experience of some kind. Your instructor wants you to think about something in a particular way for a particular reason. If you read the course description at the beginning of your syllabus, review the assigned readings, and consider the assignment itself, you may begin to see the plan, purpose, or approach to the subject matter that your instructor has created for you. If you still aren’t sure of the assignment’s goals, try asking the instructor. For help with this, see our handout on getting feedback .

Given your instructor’s efforts, it helps to answer the question: What is my purpose in completing this assignment? Is it to gather research from a variety of outside sources and present a coherent picture? Is it to take material I have been learning in class and apply it to a new situation? Is it to prove a point one way or another? Key words from the assignment can help you figure this out. Look for key terms in the form of active verbs that tell you what to do.

Key Terms: Finding Those Active Verbs

Here are some common key words and definitions to help you think about assignment terms:

Information words Ask you to demonstrate what you know about the subject, such as who, what, when, where, how, and why.

• define —give the subject’s meaning (according to someone or something). Sometimes you have to give more than one view on the subject’s meaning
• describe —provide details about the subject by answering question words (such as who, what, when, where, how, and why); you might also give details related to the five senses (what you see, hear, feel, taste, and smell)
• explain —give reasons why or examples of how something happened
• illustrate —give descriptive examples of the subject and show how each is connected with the subject
• summarize —briefly list the important ideas you learned about the subject
• trace —outline how something has changed or developed from an earlier time to its current form
• research —gather material from outside sources about the subject, often with the implication or requirement that you will analyze what you have found

Relation words Ask you to demonstrate how things are connected.

• compare —show how two or more things are similar (and, sometimes, different)
• contrast —show how two or more things are dissimilar
• apply—use details that you’ve been given to demonstrate how an idea, theory, or concept works in a particular situation
• cause —show how one event or series of events made something else happen
• relate —show or describe the connections between things

Interpretation words Ask you to defend ideas of your own about the subject. Do not see these words as requesting opinion alone (unless the assignment specifically says so), but as requiring opinion that is supported by concrete evidence. Remember examples, principles, definitions, or concepts from class or research and use them in your interpretation.

• assess —summarize your opinion of the subject and measure it against something
• prove, justify —give reasons or examples to demonstrate how or why something is the truth
• evaluate, respond —state your opinion of the subject as good, bad, or some combination of the two, with examples and reasons
• support —give reasons or evidence for something you believe (be sure to state clearly what it is that you believe)
• synthesize —put two or more things together that have not been put together in class or in your readings before; do not just summarize one and then the other and say that they are similar or different—you must provide a reason for putting them together that runs all the way through the paper
• analyze —determine how individual parts create or relate to the whole, figure out how something works, what it might mean, or why it is important
• argue —take a side and defend it with evidence against the other side

More Clues to Your Purpose As you read the assignment, think about what the teacher does in class:

• What kinds of textbooks or coursepack did your instructor choose for the course—ones that provide background information, explain theories or perspectives, or argue a point of view?
• In lecture, does your instructor ask your opinion, try to prove their point of view, or use keywords that show up again in the assignment?
• What kinds of assignments are typical in this discipline? Social science classes often expect more research. Humanities classes thrive on interpretation and analysis.
• How do the assignments, readings, and lectures work together in the course? Instructors spend time designing courses, sometimes even arguing with their peers about the most effective course materials. Figuring out the overall design to the course will help you understand what each assignment is meant to achieve.

Now, what about your reader? Most undergraduates think of their audience as the instructor. True, your instructor is a good person to keep in mind as you write. But for the purposes of a good paper, think of your audience as someone like your roommate: smart enough to understand a clear, logical argument, but not someone who already knows exactly what is going on in your particular paper. Remember, even if the instructor knows everything there is to know about your paper topic, they still have to read your paper and assess your understanding. In other words, teach the material to your reader.

Aiming a paper at your audience happens in two ways: you make decisions about the tone and the level of information you want to convey.

• Tone means the “voice” of your paper. Should you be chatty, formal, or objective? Usually you will find some happy medium—you do not want to alienate your reader by sounding condescending or superior, but you do not want to, um, like, totally wig on the man, you know? Eschew ostentatious erudition: some students think the way to sound academic is to use big words. Be careful—you can sound ridiculous, especially if you use the wrong big words.
• The level of information you use depends on who you think your audience is. If you imagine your audience as your instructor and they already know everything you have to say, you may find yourself leaving out key information that can cause your argument to be unconvincing and illogical. But you do not have to explain every single word or issue. If you are telling your roommate what happened on your favorite science fiction TV show last night, you do not say, “First a dark-haired white man of average height, wearing a suit and carrying a flashlight, walked into the room. Then a purple alien with fifteen arms and at least three eyes turned around. Then the man smiled slightly. In the background, you could hear a clock ticking. The room was fairly dark and had at least two windows that I saw.” You also do not say, “This guy found some aliens. The end.” Find some balance of useful details that support your main point.

You’ll find a much more detailed discussion of these concepts in our handout on audience .

The Grim Truth

With a few exceptions (including some lab and ethnography reports), you are probably being asked to make an argument. You must convince your audience. It is easy to forget this aim when you are researching and writing; as you become involved in your subject matter, you may become enmeshed in the details and focus on learning or simply telling the information you have found. You need to do more than just repeat what you have read. Your writing should have a point, and you should be able to say it in a sentence. Sometimes instructors call this sentence a “thesis” or a “claim.”

So, if your instructor tells you to write about some aspect of oral hygiene, you do not want to just list: “First, you brush your teeth with a soft brush and some peanut butter. Then, you floss with unwaxed, bologna-flavored string. Finally, gargle with bourbon.” Instead, you could say, “Of all the oral cleaning methods, sandblasting removes the most plaque. Therefore it should be recommended by the American Dental Association.” Or, “From an aesthetic perspective, moldy teeth can be quite charming. However, their joys are short-lived.”

Convincing the reader of your argument is the goal of academic writing. It doesn’t have to say “argument” anywhere in the assignment for you to need one. Look at the assignment and think about what kind of argument you could make about it instead of just seeing it as a checklist of information you have to present. For help with understanding the role of argument in academic writing, see our handout on argument .

What kind of evidence do you need?

There are many kinds of evidence, and what type of evidence will work for your assignment can depend on several factors–the discipline, the parameters of the assignment, and your instructor’s preference. Should you use statistics? Historical examples? Do you need to conduct your own experiment? Can you rely on personal experience? See our handout on evidence for suggestions on how to use evidence appropriately.

Make sure you are clear about this part of the assignment, because your use of evidence will be crucial in writing a successful paper. You are not just learning how to argue; you are learning how to argue with specific types of materials and ideas. Ask your instructor what counts as acceptable evidence. You can also ask a librarian for help. No matter what kind of evidence you use, be sure to cite it correctly—see the UNC Libraries citation tutorial .

You cannot always tell from the assignment just what sort of writing style your instructor expects. The instructor may be really laid back in class but still expect you to sound formal in writing. Or the instructor may be fairly formal in class and ask you to write a reflection paper where you need to use “I” and speak from your own experience.

Try to avoid false associations of a particular field with a style (“art historians like wacky creativity,” or “political scientists are boring and just give facts”) and look instead to the types of readings you have been given in class. No one expects you to write like Plato—just use the readings as a guide for what is standard or preferable to your instructor. When in doubt, ask your instructor about the level of formality they expect.

No matter what field you are writing for or what facts you are including, if you do not write so that your reader can understand your main idea, you have wasted your time. So make clarity your main goal. For specific help with style, see our handout on style .

Technical details about the assignment

The technical information you are given in an assignment always seems like the easy part. This section can actually give you lots of little hints about approaching the task. Find out if elements such as page length and citation format (see the UNC Libraries citation tutorial ) are negotiable. Some professors do not have strong preferences as long as you are consistent and fully answer the assignment. Some professors are very specific and will deduct big points for deviations.

Usually, the page length tells you something important: The instructor thinks the size of the paper is appropriate to the assignment’s parameters. In plain English, your instructor is telling you how many pages it should take for you to answer the question as fully as you are expected to. So if an assignment is two pages long, you cannot pad your paper with examples or reword your main idea several times. Hit your one point early, defend it with the clearest example, and finish quickly. If an assignment is ten pages long, you can be more complex in your main points and examples—and if you can only produce five pages for that assignment, you need to see someone for help—as soon as possible.

Tricks that don’t work

Your instructors are not fooled when you:

• spend more time on the cover page than the essay —graphics, cool binders, and cute titles are no replacement for a well-written paper.
• use huge fonts, wide margins, or extra spacing to pad the page length —these tricks are immediately obvious to the eye. Most instructors use the same word processor you do. They know what’s possible. Such tactics are especially damning when the instructor has a stack of 60 papers to grade and yours is the only one that low-flying airplane pilots could read.
• use a paper from another class that covered “sort of similar” material . Again, the instructor has a particular task for you to fulfill in the assignment that usually relates to course material and lectures. Your other paper may not cover this material, and turning in the same paper for more than one course may constitute an Honor Code violation . Ask the instructor—it can’t hurt.
• get all wacky and “creative” before you answer the question . Showing that you are able to think beyond the boundaries of a simple assignment can be good, but you must do what the assignment calls for first. Again, check with your instructor. A humorous tone can be refreshing for someone grading a stack of papers, but it will not get you a good grade if you have not fulfilled the task.

Critical reading of assignments leads to skills in other types of reading and writing. If you get good at figuring out what the real goals of assignments are, you are going to be better at understanding the goals of all of your classes and fields of study.

You may reproduce it for non-commercial use if you use the entire handout and attribute the source: The Writing Center, University of North Carolina at Chapel Hill

Make a Gift

Purdue Online Writing Lab Purdue OWL® College of Liberal Arts

Welcome to the Purdue Online Writing Lab

Welcome to the Purdue OWL

This page is brought to you by the OWL at Purdue University. When printing this page, you must include the entire legal notice.

Copyright ©1995-2018 by The Writing Lab & The OWL at Purdue and Purdue University. All rights reserved. This material may not be published, reproduced, broadcast, rewritten, or redistributed without permission. Use of this site constitutes acceptance of our terms and conditions of fair use.

The Online Writing Lab at Purdue University houses writing resources and instructional material, and we provide these as a free service of the Writing Lab at Purdue. Students, members of the community, and users worldwide will find information to assist with many writing projects. Teachers and trainers may use this material for in-class and out-of-class instruction.

The Purdue On-Campus Writing Lab and Purdue Online Writing Lab assist clients in their development as writers—no matter what their skill level—with on-campus consultations, online participation, and community engagement. The Purdue Writing Lab serves the Purdue, West Lafayette, campus and coordinates with local literacy initiatives. The Purdue OWL offers global support through online reference materials and services.

A Message From the Assistant Director of Content Development 

The Purdue OWL® is committed to supporting  students, instructors, and writers by offering a wide range of resources that are developed and revised with them in mind. To do this, the OWL team is always exploring possibilties for a better design, allowing accessibility and user experience to guide our process. As the OWL undergoes some changes, we welcome your feedback and suggestions by email at any time.

Please don't hesitate to contact us via our contact page  if you have any questions or comments.

All the best,

Social Media

Facebook twitter.

The Go Programming Language Specification

Language version go1.22 (feb 6, 2024), introduction.

This is the reference manual for the Go programming language. The pre-Go1.18 version, without generics, can be found here . For more information and other documents, see go.dev .

Go is a general-purpose language designed with systems programming in mind. It is strongly typed and garbage-collected and has explicit support for concurrent programming. Programs are constructed from packages , whose properties allow efficient management of dependencies.

The syntax is compact and simple to parse, allowing for easy analysis by automatic tools such as integrated development environments.

The syntax is specified using a variant of Extended Backus-Naur Form (EBNF):

Productions are expressions constructed from terms and the following operators, in increasing precedence:

Lowercase production names are used to identify lexical (terminal) tokens. Non-terminals are in CamelCase. Lexical tokens are enclosed in double quotes "" or back quotes `` .

The form a … b represents the set of characters from a through b as alternatives. The horizontal ellipsis … is also used elsewhere in the spec to informally denote various enumerations or code snippets that are not further specified. The character … (as opposed to the three characters ... ) is not a token of the Go language.

A link of the form [ Go 1.xx ] indicates that a described language feature (or some aspect of it) was changed or added with language version 1.xx and thus requires at minimum that language version to build. For details, see the linked section in the appendix .

Source code representation

Source code is Unicode text encoded in UTF-8 . The text is not canonicalized, so a single accented code point is distinct from the same character constructed from combining an accent and a letter; those are treated as two code points. For simplicity, this document will use the unqualified term character to refer to a Unicode code point in the source text.

Each code point is distinct; for instance, uppercase and lowercase letters are different characters.

Implementation restriction: For compatibility with other tools, a compiler may disallow the NUL character (U+0000) in the source text.

Implementation restriction: For compatibility with other tools, a compiler may ignore a UTF-8-encoded byte order mark (U+FEFF) if it is the first Unicode code point in the source text. A byte order mark may be disallowed anywhere else in the source.

The following terms are used to denote specific Unicode character categories:

In The Unicode Standard 8.0 , Section 4.5 "General Category" defines a set of character categories. Go treats all characters in any of the Letter categories Lu, Ll, Lt, Lm, or Lo as Unicode letters, and those in the Number category Nd as Unicode digits.

Letters and digits

The underscore character _ (U+005F) is considered a lowercase letter.

Lexical elements

Comments serve as program documentation. There are two forms:

• Line comments start with the character sequence // and stop at the end of the line.
• General comments start with the character sequence /* and stop with the first subsequent character sequence */ .

A comment cannot start inside a rune or string literal , or inside a comment. A general comment containing no newlines acts like a space. Any other comment acts like a newline.

Tokens form the vocabulary of the Go language. There are four classes: identifiers , keywords , operators and punctuation , and literals . White space , formed from spaces (U+0020), horizontal tabs (U+0009), carriage returns (U+000D), and newlines (U+000A), is ignored except as it separates tokens that would otherwise combine into a single token. Also, a newline or end of file may trigger the insertion of a semicolon . While breaking the input into tokens, the next token is the longest sequence of characters that form a valid token.

The formal syntax uses semicolons ";" as terminators in a number of productions. Go programs may omit most of these semicolons using the following two rules:

• an identifier
• an integer , floating-point , imaginary , rune , or string literal
• one of the keywords break , continue , fallthrough , or return
• one of the operators and punctuation ++ , -- , ) , ] , or }
• To allow complex statements to occupy a single line, a semicolon may be omitted before a closing ")" or "}" .

To reflect idiomatic use, code examples in this document elide semicolons using these rules.

Identifiers

Identifiers name program entities such as variables and types. An identifier is a sequence of one or more letters and digits. The first character in an identifier must be a letter.

Some identifiers are predeclared .

The following keywords are reserved and may not be used as identifiers.

Operators and punctuation

The following character sequences represent operators (including assignment operators ) and punctuation [ Go 1.18 ]:

Integer literals

An integer literal is a sequence of digits representing an integer constant . An optional prefix sets a non-decimal base: 0b or 0B for binary, 0 , 0o , or 0O for octal, and 0x or 0X for hexadecimal [ Go 1.13 ]. A single 0 is considered a decimal zero. In hexadecimal literals, letters a through f and A through F represent values 10 through 15.

For readability, an underscore character _ may appear after a base prefix or between successive digits; such underscores do not change the literal's value.

Floating-point literals

A floating-point literal is a decimal or hexadecimal representation of a floating-point constant .

A decimal floating-point literal consists of an integer part (decimal digits), a decimal point, a fractional part (decimal digits), and an exponent part ( e or E followed by an optional sign and decimal digits). One of the integer part or the fractional part may be elided; one of the decimal point or the exponent part may be elided. An exponent value exp scales the mantissa (integer and fractional part) by 10 exp .

A hexadecimal floating-point literal consists of a 0x or 0X prefix, an integer part (hexadecimal digits), a radix point, a fractional part (hexadecimal digits), and an exponent part ( p or P followed by an optional sign and decimal digits). One of the integer part or the fractional part may be elided; the radix point may be elided as well, but the exponent part is required. (This syntax matches the one given in IEEE 754-2008 §5.12.3.) An exponent value exp scales the mantissa (integer and fractional part) by 2 exp [ Go 1.13 ].

For readability, an underscore character _ may appear after a base prefix or between successive digits; such underscores do not change the literal value.

Imaginary literals

An imaginary literal represents the imaginary part of a complex constant . It consists of an integer or floating-point literal followed by the lowercase letter i . The value of an imaginary literal is the value of the respective integer or floating-point literal multiplied by the imaginary unit i [ Go 1.13 ]

For backward compatibility, an imaginary literal's integer part consisting entirely of decimal digits (and possibly underscores) is considered a decimal integer, even if it starts with a leading 0 .

Rune literals

A rune literal represents a rune constant , an integer value identifying a Unicode code point. A rune literal is expressed as one or more characters enclosed in single quotes, as in 'x' or '\n' . Within the quotes, any character may appear except newline and unescaped single quote. A single quoted character represents the Unicode value of the character itself, while multi-character sequences beginning with a backslash encode values in various formats.

The simplest form represents the single character within the quotes; since Go source text is Unicode characters encoded in UTF-8, multiple UTF-8-encoded bytes may represent a single integer value. For instance, the literal 'a' holds a single byte representing a literal a , Unicode U+0061, value 0x61 , while 'ä' holds two bytes ( 0xc3 0xa4 ) representing a literal a -dieresis, U+00E4, value 0xe4 .

Several backslash escapes allow arbitrary values to be encoded as ASCII text. There are four ways to represent the integer value as a numeric constant: \x followed by exactly two hexadecimal digits; \u followed by exactly four hexadecimal digits; \U followed by exactly eight hexadecimal digits, and a plain backslash \ followed by exactly three octal digits. In each case the value of the literal is the value represented by the digits in the corresponding base.

Although these representations all result in an integer, they have different valid ranges. Octal escapes must represent a value between 0 and 255 inclusive. Hexadecimal escapes satisfy this condition by construction. The escapes \u and \U represent Unicode code points so within them some values are illegal, in particular those above 0x10FFFF and surrogate halves.

After a backslash, certain single-character escapes represent special values:

An unrecognized character following a backslash in a rune literal is illegal.

String literals

A string literal represents a string constant obtained from concatenating a sequence of characters. There are two forms: raw string literals and interpreted string literals.

Raw string literals are character sequences between back quotes, as in `foo` . Within the quotes, any character may appear except back quote. The value of a raw string literal is the string composed of the uninterpreted (implicitly UTF-8-encoded) characters between the quotes; in particular, backslashes have no special meaning and the string may contain newlines. Carriage return characters ('\r') inside raw string literals are discarded from the raw string value.

Interpreted string literals are character sequences between double quotes, as in "bar" . Within the quotes, any character may appear except newline and unescaped double quote. The text between the quotes forms the value of the literal, with backslash escapes interpreted as they are in rune literals (except that \' is illegal and \" is legal), with the same restrictions. The three-digit octal ( \ nnn ) and two-digit hexadecimal ( \x nn ) escapes represent individual bytes of the resulting string; all other escapes represent the (possibly multi-byte) UTF-8 encoding of individual characters . Thus inside a string literal \377 and \xFF represent a single byte of value 0xFF =255, while ÿ , \u00FF , \U000000FF and \xc3\xbf represent the two bytes 0xc3 0xbf of the UTF-8 encoding of character U+00FF.

These examples all represent the same string:

If the source code represents a character as two code points, such as a combining form involving an accent and a letter, the result will be an error if placed in a rune literal (it is not a single code point), and will appear as two code points if placed in a string literal.

There are boolean constants , rune constants , integer constants , floating-point constants , complex constants , and string constants . Rune, integer, floating-point, and complex constants are collectively called numeric constants .

A constant value is represented by a rune , integer , floating-point , imaginary , or string literal, an identifier denoting a constant, a constant expression , a conversion with a result that is a constant, or the result value of some built-in functions such as min or max applied to constant arguments, unsafe.Sizeof applied to certain values , cap or len applied to some expressions , real and imag applied to a complex constant and complex applied to numeric constants. The boolean truth values are represented by the predeclared constants true and false . The predeclared identifier iota denotes an integer constant.

In general, complex constants are a form of constant expression and are discussed in that section.

Numeric constants represent exact values of arbitrary precision and do not overflow. Consequently, there are no constants denoting the IEEE-754 negative zero, infinity, and not-a-number values.

Constants may be typed or untyped . Literal constants, true , false , iota , and certain constant expressions containing only untyped constant operands are untyped.

A constant may be given a type explicitly by a constant declaration or conversion , or implicitly when used in a variable declaration or an assignment statement or as an operand in an expression . It is an error if the constant value cannot be represented as a value of the respective type. If the type is a type parameter, the constant is converted into a non-constant value of the type parameter.

An untyped constant has a default type which is the type to which the constant is implicitly converted in contexts where a typed value is required, for instance, in a short variable declaration such as i := 0 where there is no explicit type. The default type of an untyped constant is bool , rune , int , float64 , complex128 , or string respectively, depending on whether it is a boolean, rune, integer, floating-point, complex, or string constant.

Implementation restriction: Although numeric constants have arbitrary precision in the language, a compiler may implement them using an internal representation with limited precision. That said, every implementation must:

• Represent integer constants with at least 256 bits.
• Represent floating-point constants, including the parts of a complex constant, with a mantissa of at least 256 bits and a signed binary exponent of at least 16 bits.
• Give an error if unable to represent an integer constant precisely.
• Give an error if unable to represent a floating-point or complex constant due to overflow.
• Round to the nearest representable constant if unable to represent a floating-point or complex constant due to limits on precision.

These requirements apply both to literal constants and to the result of evaluating constant expressions .

A variable is a storage location for holding a value . The set of permissible values is determined by the variable's type .

A variable declaration or, for function parameters and results, the signature of a function declaration or function literal reserves storage for a named variable. Calling the built-in function new or taking the address of a composite literal allocates storage for a variable at run time. Such an anonymous variable is referred to via a (possibly implicit) pointer indirection .

Structured variables of array , slice , and struct types have elements and fields that may be addressed individually. Each such element acts like a variable.

The static type (or just type ) of a variable is the type given in its declaration, the type provided in the new call or composite literal, or the type of an element of a structured variable. Variables of interface type also have a distinct dynamic type , which is the (non-interface) type of the value assigned to the variable at run time (unless the value is the predeclared identifier nil , which has no type). The dynamic type may vary during execution but values stored in interface variables are always assignable to the static type of the variable.

A variable's value is retrieved by referring to the variable in an expression ; it is the most recent value assigned to the variable. If a variable has not yet been assigned a value, its value is the zero value for its type.

A type determines a set of values together with operations and methods specific to those values. A type may be denoted by a type name , if it has one, which must be followed by type arguments if the type is generic. A type may also be specified using a type literal , which composes a type from existing types.

The language predeclares certain type names. Others are introduced with type declarations or type parameter lists . Composite types —array, struct, pointer, function, interface, slice, map, and channel types—may be constructed using type literals.

Predeclared types, defined types, and type parameters are called named types . An alias denotes a named type if the type given in the alias declaration is a named type.

Boolean types

A boolean type represents the set of Boolean truth values denoted by the predeclared constants true and false . The predeclared boolean type is bool ; it is a defined type .

Numeric types

An integer , floating-point , or complex type represents the set of integer, floating-point, or complex values, respectively. They are collectively called numeric types . The predeclared architecture-independent numeric types are:

The value of an n -bit integer is n bits wide and represented using two's complement arithmetic .

There is also a set of predeclared integer types with implementation-specific sizes:

To avoid portability issues all numeric types are defined types and thus distinct except byte , which is an alias for uint8 , and rune , which is an alias for int32 . Explicit conversions are required when different numeric types are mixed in an expression or assignment. For instance, int32 and int are not the same type even though they may have the same size on a particular architecture.

String types

A string type represents the set of string values. A string value is a (possibly empty) sequence of bytes. The number of bytes is called the length of the string and is never negative. Strings are immutable: once created, it is impossible to change the contents of a string. The predeclared string type is string ; it is a defined type .

The length of a string s can be discovered using the built-in function len . The length is a compile-time constant if the string is a constant. A string's bytes can be accessed by integer indices 0 through len(s)-1 . It is illegal to take the address of such an element; if s[i] is the i 'th byte of a string, &s[i] is invalid.

Array types

An array is a numbered sequence of elements of a single type, called the element type. The number of elements is called the length of the array and is never negative.

The length is part of the array's type; it must evaluate to a non-negative constant representable by a value of type int . The length of array a can be discovered using the built-in function len . The elements can be addressed by integer indices 0 through len(a)-1 . Array types are always one-dimensional but may be composed to form multi-dimensional types.

An array type T may not have an element of type T , or of a type containing T as a component, directly or indirectly, if those containing types are only array or struct types.

Slice types

A slice is a descriptor for a contiguous segment of an underlying array and provides access to a numbered sequence of elements from that array. A slice type denotes the set of all slices of arrays of its element type. The number of elements is called the length of the slice and is never negative. The value of an uninitialized slice is nil .

The length of a slice s can be discovered by the built-in function len ; unlike with arrays it may change during execution. The elements can be addressed by integer indices 0 through len(s)-1 . The slice index of a given element may be less than the index of the same element in the underlying array.

A slice, once initialized, is always associated with an underlying array that holds its elements. A slice therefore shares storage with its array and with other slices of the same array; by contrast, distinct arrays always represent distinct storage.

The array underlying a slice may extend past the end of the slice. The capacity is a measure of that extent: it is the sum of the length of the slice and the length of the array beyond the slice; a slice of length up to that capacity can be created by slicing a new one from the original slice. The capacity of a slice a can be discovered using the built-in function cap(a) .

A new, initialized slice value for a given element type T may be made using the built-in function make , which takes a slice type and parameters specifying the length and optionally the capacity. A slice created with make always allocates a new, hidden array to which the returned slice value refers. That is, executing

produces the same slice as allocating an array and slicing it, so these two expressions are equivalent:

Like arrays, slices are always one-dimensional but may be composed to construct higher-dimensional objects. With arrays of arrays, the inner arrays are, by construction, always the same length; however with slices of slices (or arrays of slices), the inner lengths may vary dynamically. Moreover, the inner slices must be initialized individually.

Struct types

A struct is a sequence of named elements, called fields, each of which has a name and a type. Field names may be specified explicitly (IdentifierList) or implicitly (EmbeddedField). Within a struct, non- blank field names must be unique .

A field declared with a type but no explicit field name is called an embedded field . An embedded field must be specified as a type name T or as a pointer to a non-interface type name *T , and T itself may not be a pointer type. The unqualified type name acts as the field name.

The following declaration is illegal because field names must be unique in a struct type:

A field or method f of an embedded field in a struct x is called promoted if x.f is a legal selector that denotes that field or method f .

Promoted fields act like ordinary fields of a struct except that they cannot be used as field names in composite literals of the struct.

Given a struct type S and a named type T , promoted methods are included in the method set of the struct as follows:

• If S contains an embedded field T , the method sets of S and *S both include promoted methods with receiver T . The method set of *S also includes promoted methods with receiver *T .
• If S contains an embedded field *T , the method sets of S and *S both include promoted methods with receiver T or *T .

A field declaration may be followed by an optional string literal tag , which becomes an attribute for all the fields in the corresponding field declaration. An empty tag string is equivalent to an absent tag. The tags are made visible through a reflection interface and take part in type identity for structs but are otherwise ignored.

A struct type T may not contain a field of type T , or of a type containing T as a component, directly or indirectly, if those containing types are only array or struct types.

Pointer types

A pointer type denotes the set of all pointers to variables of a given type, called the base type of the pointer. The value of an uninitialized pointer is nil .

Function types

A function type denotes the set of all functions with the same parameter and result types. The value of an uninitialized variable of function type is nil .

Within a list of parameters or results, the names (IdentifierList) must either all be present or all be absent. If present, each name stands for one item (parameter or result) of the specified type and all non- blank names in the signature must be unique . If absent, each type stands for one item of that type. Parameter and result lists are always parenthesized except that if there is exactly one unnamed result it may be written as an unparenthesized type.

The final incoming parameter in a function signature may have a type prefixed with ... . A function with such a parameter is called variadic and may be invoked with zero or more arguments for that parameter.

Interface types

An interface type defines a type set . A variable of interface type can store a value of any type that is in the type set of the interface. Such a type is said to implement the interface . The value of an uninitialized variable of interface type is nil .

An interface type is specified by a list of interface elements . An interface element is either a method or a type element , where a type element is a union of one or more type terms . A type term is either a single type or a single underlying type.

Basic interfaces

In its most basic form an interface specifies a (possibly empty) list of methods. The type set defined by such an interface is the set of types which implement all of those methods, and the corresponding method set consists exactly of the methods specified by the interface. Interfaces whose type sets can be defined entirely by a list of methods are called basic interfaces.

The name of each explicitly specified method must be unique and not blank .

More than one type may implement an interface. For instance, if two types S1 and S2 have the method set

(where T stands for either S1 or S2 ) then the File interface is implemented by both S1 and S2 , regardless of what other methods S1 and S2 may have or share.

Every type that is a member of the type set of an interface implements that interface. Any given type may implement several distinct interfaces. For instance, all types implement the empty interface which stands for the set of all (non-interface) types:

For convenience, the predeclared type any is an alias for the empty interface. [ Go 1.18 ]

Similarly, consider this interface specification, which appears within a type declaration to define an interface called Locker :

If S1 and S2 also implement

they implement the Locker interface as well as the File interface.

Embedded interfaces

In a slightly more general form an interface T may use a (possibly qualified) interface type name E as an interface element. This is called embedding interface E in T [ Go 1.14 ]. The type set of T is the intersection of the type sets defined by T 's explicitly declared methods and the type sets of T ’s embedded interfaces. In other words, the type set of T is the set of all types that implement all the explicitly declared methods of T and also all the methods of E [ Go 1.18 ].

When embedding interfaces, methods with the same names must have identical signatures.

General interfaces

In their most general form, an interface element may also be an arbitrary type term T , or a term of the form ~T specifying the underlying type T , or a union of terms t 1 |t 2 |…|t n [ Go 1.18 ]. Together with method specifications, these elements enable the precise definition of an interface's type set as follows:

• The type set of the empty interface is the set of all non-interface types.
• The type set of a non-empty interface is the intersection of the type sets of its interface elements.
• The type set of a method specification is the set of all non-interface types whose method sets include that method.
• The type set of a non-interface type term is the set consisting of just that type.
• The type set of a term of the form ~T is the set of all types whose underlying type is T .
• The type set of a union of terms t 1 |t 2 |…|t n is the union of the type sets of the terms.

The quantification "the set of all non-interface types" refers not just to all (non-interface) types declared in the program at hand, but all possible types in all possible programs, and hence is infinite. Similarly, given the set of all non-interface types that implement a particular method, the intersection of the method sets of those types will contain exactly that method, even if all types in the program at hand always pair that method with another method.

By construction, an interface's type set never contains an interface type.

In a term of the form ~T , the underlying type of T must be itself, and T cannot be an interface.

Union elements denote unions of type sets:

The type T in a term of the form T or ~T cannot be a type parameter , and the type sets of all non-interface terms must be pairwise disjoint (the pairwise intersection of the type sets must be empty). Given a type parameter P :

Implementation restriction: A union (with more than one term) cannot contain the predeclared identifier comparable or interfaces that specify methods, or embed comparable or interfaces that specify methods.

Interfaces that are not basic may only be used as type constraints, or as elements of other interfaces used as constraints. They cannot be the types of values or variables, or components of other, non-interface types.

An interface type T may not embed a type element that is, contains, or embeds T , directly or indirectly.

Implementing an interface

A type T implements an interface I if

• T is not an interface and is an element of the type set of I ; or
• T is an interface and the type set of T is a subset of the type set of I .

A value of type T implements an interface if T implements the interface.

A map is an unordered group of elements of one type, called the element type, indexed by a set of unique keys of another type, called the key type. The value of an uninitialized map is nil .

The comparison operators == and != must be fully defined for operands of the key type; thus the key type must not be a function, map, or slice. If the key type is an interface type, these comparison operators must be defined for the dynamic key values; failure will cause a run-time panic .

The number of map elements is called its length. For a map m , it can be discovered using the built-in function len and may change during execution. Elements may be added during execution using assignments and retrieved with index expressions ; they may be removed with the delete and clear built-in function.

A new, empty map value is made using the built-in function make , which takes the map type and an optional capacity hint as arguments:

Channel types

A channel provides a mechanism for concurrently executing functions to communicate by sending and receiving values of a specified element type. The value of an uninitialized channel is nil .

The optional <- operator specifies the channel direction , send or receive . If a direction is given, the channel is directional , otherwise it is bidirectional . A channel may be constrained only to send or only to receive by assignment or explicit conversion .

The <- operator associates with the leftmost chan possible:

A new, initialized channel value can be made using the built-in function make , which takes the channel type and an optional capacity as arguments:

The capacity, in number of elements, sets the size of the buffer in the channel. If the capacity is zero or absent, the channel is unbuffered and communication succeeds only when both a sender and receiver are ready. Otherwise, the channel is buffered and communication succeeds without blocking if the buffer is not full (sends) or not empty (receives). A nil channel is never ready for communication.

A channel may be closed with the built-in function close . The multi-valued assignment form of the receive operator reports whether a received value was sent before the channel was closed.

A single channel may be used in send statements , receive operations , and calls to the built-in functions cap and len by any number of goroutines without further synchronization. Channels act as first-in-first-out queues. For example, if one goroutine sends values on a channel and a second goroutine receives them, the values are received in the order sent.

Properties of types and values

Underlying types.

Each type T has an underlying type : If T is one of the predeclared boolean, numeric, or string types, or a type literal, the corresponding underlying type is T itself. Otherwise, T 's underlying type is the underlying type of the type to which T refers in its declaration. For a type parameter that is the underlying type of its type constraint , which is always an interface.

The underlying type of string , A1 , A2 , B1 , and B2 is string . The underlying type of []B1 , B3 , and B4 is []B1 . The underlying type of P is interface{} .

Each non-interface type T has a core type , which is the same as the underlying type of T .

An interface T has a core type if one of the following conditions is satisfied:

• There is a single type U which is the underlying type of all types in the type set of T ; or
• the type set of T contains only channel types with identical element type E , and all directional channels have the same direction.

No other interfaces have a core type.

The core type of an interface is, depending on the condition that is satisfied, either:

• the type U ; or
• the type chan E if T contains only bidirectional channels, or the type chan<- E or <-chan E depending on the direction of the directional channels present.

By definition, a core type is never a defined type , type parameter , or interface type .

Examples of interfaces with core types:

Examples of interfaces without core types:

Some operations ( slice expressions , append and copy ) rely on a slightly more loose form of core types which accept byte slices and strings. Specifically, if there are exactly two types, []byte and string , which are the underlying types of all types in the type set of interface T , the core type of T is called bytestring .

Examples of interfaces with bytestring core types:

Note that bytestring is not a real type; it cannot be used to declare variables or compose other types. It exists solely to describe the behavior of some operations that read from a sequence of bytes, which may be a byte slice or a string.

Type identity

Two types are either identical or different .

A named type is always different from any other type. Otherwise, two types are identical if their underlying type literals are structurally equivalent; that is, they have the same literal structure and corresponding components have identical types. In detail:

• Two array types are identical if they have identical element types and the same array length.
• Two slice types are identical if they have identical element types.
• Two struct types are identical if they have the same sequence of fields, and if corresponding fields have the same names, and identical types, and identical tags. Non-exported field names from different packages are always different.
• Two pointer types are identical if they have identical base types.
• Two function types are identical if they have the same number of parameters and result values, corresponding parameter and result types are identical, and either both functions are variadic or neither is. Parameter and result names are not required to match.
• Two interface types are identical if they define the same type set.
• Two map types are identical if they have identical key and element types.
• Two channel types are identical if they have identical element types and the same direction.
• Two instantiated types are identical if their defined types and all type arguments are identical.

Given the declarations

these types are identical:

B0 and B1 are different because they are new types created by distinct type definitions ; func(int, float64) *B0 and func(x int, y float64) *[]string are different because B0 is different from []string ; and P1 and P2 are different because they are different type parameters. D0[int, string] and struct{ x int; y string } are different because the former is an instantiated defined type while the latter is a type literal (but they are still assignable ).

Assignability

A value x of type V is assignable to a variable of type T (" x is assignable to T ") if one of the following conditions applies:

• V and T are identical.
• V and T have identical underlying types but are not type parameters and at least one of V or T is not a named type .
• V and T are channel types with identical element types, V is a bidirectional channel, and at least one of V or T is not a named type .
• T is an interface type, but not a type parameter, and x implements T .
• x is the predeclared identifier nil and T is a pointer, function, slice, map, channel, or interface type, but not a type parameter.
• x is an untyped constant representable by a value of type T .

Additionally, if x 's type V or T are type parameters, x is assignable to a variable of type T if one of the following conditions applies:

• x is the predeclared identifier nil , T is a type parameter, and x is assignable to each type in T 's type set.
• V is not a named type , T is a type parameter, and x is assignable to each type in T 's type set.
• V is a type parameter and T is not a named type, and values of each type in V 's type set are assignable to T .

Representability

A constant x is representable by a value of type T , where T is not a type parameter , if one of the following conditions applies:

• x is in the set of values determined by T .
• T is a floating-point type and x can be rounded to T 's precision without overflow. Rounding uses IEEE 754 round-to-even rules but with an IEEE negative zero further simplified to an unsigned zero. Note that constant values never result in an IEEE negative zero, NaN, or infinity.
• T is a complex type, and x 's components real(x) and imag(x) are representable by values of T 's component type ( float32 or float64 ).

If T is a type parameter, x is representable by a value of type T if x is representable by a value of each type in T 's type set.

Method sets

The method set of a type determines the methods that can be called on an operand of that type. Every type has a (possibly empty) method set associated with it:

• The method set of a defined type T consists of all methods declared with receiver type T .
• The method set of a pointer to a defined type T (where T is neither a pointer nor an interface) is the set of all methods declared with receiver *T or T .
• The method set of an interface type is the intersection of the method sets of each type in the interface's type set (the resulting method set is usually just the set of declared methods in the interface).

Further rules apply to structs (and pointer to structs) containing embedded fields, as described in the section on struct types . Any other type has an empty method set.

In a method set, each method must have a unique non- blank method name .

A block is a possibly empty sequence of declarations and statements within matching brace brackets.

In addition to explicit blocks in the source code, there are implicit blocks:

• The universe block encompasses all Go source text.
• Each package has a package block containing all Go source text for that package.
• Each file has a file block containing all Go source text in that file.
• Each "if" , "for" , and "switch" statement is considered to be in its own implicit block.
• Each clause in a "switch" or "select" statement acts as an implicit block.

Blocks nest and influence scoping .

Declarations and scope

A declaration binds a non- blank identifier to a constant , type , type parameter , variable , function , label , or package . Every identifier in a program must be declared. No identifier may be declared twice in the same block, and no identifier may be declared in both the file and package block.

The blank identifier may be used like any other identifier in a declaration, but it does not introduce a binding and thus is not declared. In the package block, the identifier init may only be used for init function declarations, and like the blank identifier it does not introduce a new binding.

The scope of a declared identifier is the extent of source text in which the identifier denotes the specified constant, type, variable, function, label, or package.

Go is lexically scoped using blocks :

• The scope of a predeclared identifier is the universe block.
• The scope of an identifier denoting a constant, type, variable, or function (but not method) declared at top level (outside any function) is the package block.
• The scope of the package name of an imported package is the file block of the file containing the import declaration.
• The scope of an identifier denoting a method receiver, function parameter, or result variable is the function body.
• The scope of an identifier denoting a type parameter of a function or declared by a method receiver begins after the name of the function and ends at the end of the function body.
• The scope of an identifier denoting a type parameter of a type begins after the name of the type and ends at the end of the TypeSpec.
• The scope of a constant or variable identifier declared inside a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl for short variable declarations) and ends at the end of the innermost containing block.
• The scope of a type identifier declared inside a function begins at the identifier in the TypeSpec and ends at the end of the innermost containing block.

An identifier declared in a block may be redeclared in an inner block. While the identifier of the inner declaration is in scope, it denotes the entity declared by the inner declaration.

The package clause is not a declaration; the package name does not appear in any scope. Its purpose is to identify the files belonging to the same package and to specify the default package name for import declarations.

Label scopes

Labels are declared by labeled statements and are used in the "break" , "continue" , and "goto" statements. It is illegal to define a label that is never used. In contrast to other identifiers, labels are not block scoped and do not conflict with identifiers that are not labels. The scope of a label is the body of the function in which it is declared and excludes the body of any nested function.

Blank identifier

The blank identifier is represented by the underscore character _ . It serves as an anonymous placeholder instead of a regular (non-blank) identifier and has special meaning in declarations , as an operand , and in assignment statements .

Predeclared identifiers

The following identifiers are implicitly declared in the universe block [ Go 1.18 ] [ Go 1.21 ]:

Exported identifiers

An identifier may be exported to permit access to it from another package. An identifier is exported if both:

• the first character of the identifier's name is a Unicode uppercase letter (Unicode character category Lu); and
• the identifier is declared in the package block or it is a field name or method name .

All other identifiers are not exported.

Uniqueness of identifiers

Given a set of identifiers, an identifier is called unique if it is different from every other in the set. Two identifiers are different if they are spelled differently, or if they appear in different packages and are not exported . Otherwise, they are the same.

Constant declarations

A constant declaration binds a list of identifiers (the names of the constants) to the values of a list of constant expressions . The number of identifiers must be equal to the number of expressions, and the n th identifier on the left is bound to the value of the n th expression on the right.

If the type is present, all constants take the type specified, and the expressions must be assignable to that type, which must not be a type parameter. If the type is omitted, the constants take the individual types of the corresponding expressions. If the expression values are untyped constants , the declared constants remain untyped and the constant identifiers denote the constant values. For instance, if the expression is a floating-point literal, the constant identifier denotes a floating-point constant, even if the literal's fractional part is zero.

Within a parenthesized const declaration list the expression list may be omitted from any but the first ConstSpec. Such an empty list is equivalent to the textual substitution of the first preceding non-empty expression list and its type if any. Omitting the list of expressions is therefore equivalent to repeating the previous list. The number of identifiers must be equal to the number of expressions in the previous list. Together with the iota constant generator this mechanism permits light-weight declaration of sequential values:

Within a constant declaration , the predeclared identifier iota represents successive untyped integer constants . Its value is the index of the respective ConstSpec in that constant declaration, starting at zero. It can be used to construct a set of related constants:

By definition, multiple uses of iota in the same ConstSpec all have the same value:

This last example exploits the implicit repetition of the last non-empty expression list.

Type declarations

A type declaration binds an identifier, the type name , to a type . Type declarations come in two forms: alias declarations and type definitions.

Alias declarations

An alias declaration binds an identifier to the given type [ Go 1.9 ].

Within the scope of the identifier, it serves as an alias for the type.

Type definitions

A type definition creates a new, distinct type with the same underlying type and operations as the given type and binds an identifier, the type name , to it.

The new type is called a defined type . It is different from any other type, including the type it is created from.

A defined type may have methods associated with it. It does not inherit any methods bound to the given type, but the method set of an interface type or of elements of a composite type remains unchanged:

Type definitions may be used to define different boolean, numeric, or string types and associate methods with them:

If the type definition specifies type parameters , the type name denotes a generic type . Generic types must be instantiated when they are used.

In a type definition the given type cannot be a type parameter.

A generic type may also have methods associated with it. In this case, the method receivers must declare the same number of type parameters as present in the generic type definition.

Type parameter declarations

A type parameter list declares the type parameters of a generic function or type declaration. The type parameter list looks like an ordinary function parameter list except that the type parameter names must all be present and the list is enclosed in square brackets rather than parentheses [ Go 1.18 ].

All non-blank names in the list must be unique. Each name declares a type parameter, which is a new and different named type that acts as a placeholder for an (as of yet) unknown type in the declaration. The type parameter is replaced with a type argument upon instantiation of the generic function or type.

Just as each ordinary function parameter has a parameter type, each type parameter has a corresponding (meta-)type which is called its type constraint .

A parsing ambiguity arises when the type parameter list for a generic type declares a single type parameter P with a constraint C such that the text P C forms a valid expression:

In these rare cases, the type parameter list is indistinguishable from an expression and the type declaration is parsed as an array type declaration. To resolve the ambiguity, embed the constraint in an interface or use a trailing comma:

Type parameters may also be declared by the receiver specification of a method declaration associated with a generic type.

Within a type parameter list of a generic type T , a type constraint may not (directly, or indirectly through the type parameter list of another generic type) refer to T .

Type constraints

A type constraint is an interface that defines the set of permissible type arguments for the respective type parameter and controls the operations supported by values of that type parameter [ Go 1.18 ].

If the constraint is an interface literal of the form interface{E} where E is an embedded type element (not a method), in a type parameter list the enclosing interface{ … } may be omitted for convenience:

The predeclared interface type comparable denotes the set of all non-interface types that are strictly comparable [ Go 1.18 ].

Even though interfaces that are not type parameters are comparable , they are not strictly comparable and therefore they do not implement comparable . However, they satisfy comparable .

The comparable interface and interfaces that (directly or indirectly) embed comparable may only be used as type constraints. They cannot be the types of values or variables, or components of other, non-interface types.

Satisfying a type constraint

A type argument T satisfies a type constraint C if T is an element of the type set defined by C ; i.e., if T implements C . As an exception, a strictly comparable type constraint may also be satisfied by a comparable (not necessarily strictly comparable) type argument [ Go 1.20 ]. More precisely:

A type T satisfies a constraint C if

• T implements C ; or
• C can be written in the form interface{ comparable; E } , where E is a basic interface and T is comparable and implements E .

Because of the exception in the constraint satisfaction rule, comparing operands of type parameter type may panic at run-time (even though comparable type parameters are always strictly comparable).

Variable declarations

A variable declaration creates one or more variables , binds corresponding identifiers to them, and gives each a type and an initial value.

If a list of expressions is given, the variables are initialized with the expressions following the rules for assignment statements . Otherwise, each variable is initialized to its zero value .

If a type is present, each variable is given that type. Otherwise, each variable is given the type of the corresponding initialization value in the assignment. If that value is an untyped constant, it is first implicitly converted to its default type ; if it is an untyped boolean value, it is first implicitly converted to type bool . The predeclared value nil cannot be used to initialize a variable with no explicit type.

Implementation restriction: A compiler may make it illegal to declare a variable inside a function body if the variable is never used.

Short variable declarations

A short variable declaration uses the syntax:

It is shorthand for a regular variable declaration with initializer expressions but no types:

Unlike regular variable declarations, a short variable declaration may redeclare variables provided they were originally declared earlier in the same block (or the parameter lists if the block is the function body) with the same type, and at least one of the non- blank variables is new. As a consequence, redeclaration can only appear in a multi-variable short declaration. Redeclaration does not introduce a new variable; it just assigns a new value to the original. The non-blank variable names on the left side of := must be unique .

Short variable declarations may appear only inside functions. In some contexts such as the initializers for "if" , "for" , or "switch" statements, they can be used to declare local temporary variables.

Function declarations

A function declaration binds an identifier, the function name , to a function.

If the function's signature declares result parameters, the function body's statement list must end in a terminating statement .

If the function declaration specifies type parameters , the function name denotes a generic function . A generic function must be instantiated before it can be called or used as a value.

A function declaration without type parameters may omit the body. Such a declaration provides the signature for a function implemented outside Go, such as an assembly routine.

Method declarations

A method is a function with a receiver . A method declaration binds an identifier, the method name , to a method, and associates the method with the receiver's base type .

The receiver is specified via an extra parameter section preceding the method name. That parameter section must declare a single non-variadic parameter, the receiver. Its type must be a defined type T or a pointer to a defined type T , possibly followed by a list of type parameter names [P1, P2, …] enclosed in square brackets. T is called the receiver base type . A receiver base type cannot be a pointer or interface type and it must be defined in the same package as the method. The method is said to be bound to its receiver base type and the method name is visible only within selectors for type T or *T .

A non- blank receiver identifier must be unique in the method signature. If the receiver's value is not referenced inside the body of the method, its identifier may be omitted in the declaration. The same applies in general to parameters of functions and methods.

For a base type, the non-blank names of methods bound to it must be unique. If the base type is a struct type , the non-blank method and field names must be distinct.

Given defined type Point the declarations

bind the methods Length and Scale , with receiver type *Point , to the base type Point .

If the receiver base type is a generic type , the receiver specification must declare corresponding type parameters for the method to use. This makes the receiver type parameters available to the method. Syntactically, this type parameter declaration looks like an instantiation of the receiver base type: the type arguments must be identifiers denoting the type parameters being declared, one for each type parameter of the receiver base type. The type parameter names do not need to match their corresponding parameter names in the receiver base type definition, and all non-blank parameter names must be unique in the receiver parameter section and the method signature. The receiver type parameter constraints are implied by the receiver base type definition: corresponding type parameters have corresponding constraints.

Expressions

An expression specifies the computation of a value by applying operators and functions to operands.

Operands denote the elementary values in an expression. An operand may be a literal, a (possibly qualified ) non- blank identifier denoting a constant , variable , or function , or a parenthesized expression.

An operand name denoting a generic function may be followed by a list of type arguments ; the resulting operand is an instantiated function.

The blank identifier may appear as an operand only on the left-hand side of an assignment statement .

Implementation restriction: A compiler need not report an error if an operand's type is a type parameter with an empty type set . Functions with such type parameters cannot be instantiated ; any attempt will lead to an error at the instantiation site.

Qualified identifiers

A qualified identifier is an identifier qualified with a package name prefix. Both the package name and the identifier must not be blank .

A qualified identifier accesses an identifier in a different package, which must be imported . The identifier must be exported and declared in the package block of that package.

Composite literals

Composite literals construct new composite values each time they are evaluated. They consist of the type of the literal followed by a brace-bound list of elements. Each element may optionally be preceded by a corresponding key.

The LiteralType's core type T must be a struct, array, slice, or map type (the syntax enforces this constraint except when the type is given as a TypeName). The types of the elements and keys must be assignable to the respective field, element, and key types of type T ; there is no additional conversion. The key is interpreted as a field name for struct literals, an index for array and slice literals, and a key for map literals. For map literals, all elements must have a key. It is an error to specify multiple elements with the same field name or constant key value. For non-constant map keys, see the section on evaluation order .

For struct literals the following rules apply:

• A key must be a field name declared in the struct type.
• An element list that does not contain any keys must list an element for each struct field in the order in which the fields are declared.
• If any element has a key, every element must have a key.
• An element list that contains keys does not need to have an element for each struct field. Omitted fields get the zero value for that field.
• A literal may omit the element list; such a literal evaluates to the zero value for its type.
• It is an error to specify an element for a non-exported field of a struct belonging to a different package.

one may write

For array and slice literals the following rules apply:

• Each element has an associated integer index marking its position in the array.
• An element with a key uses the key as its index. The key must be a non-negative constant representable by a value of type int ; and if it is typed it must be of integer type .
• An element without a key uses the previous element's index plus one. If the first element has no key, its index is zero.

Taking the address of a composite literal generates a pointer to a unique variable initialized with the literal's value.

Note that the zero value for a slice or map type is not the same as an initialized but empty value of the same type. Consequently, taking the address of an empty slice or map composite literal does not have the same effect as allocating a new slice or map value with new .

The length of an array literal is the length specified in the literal type. If fewer elements than the length are provided in the literal, the missing elements are set to the zero value for the array element type. It is an error to provide elements with index values outside the index range of the array. The notation ... specifies an array length equal to the maximum element index plus one.

A slice literal describes the entire underlying array literal. Thus the length and capacity of a slice literal are the maximum element index plus one. A slice literal has the form

and is shorthand for a slice operation applied to an array:

Within a composite literal of array, slice, or map type T , elements or map keys that are themselves composite literals may elide the respective literal type if it is identical to the element or key type of T . Similarly, elements or keys that are addresses of composite literals may elide the &T when the element or key type is *T .

A parsing ambiguity arises when a composite literal using the TypeName form of the LiteralType appears as an operand between the keyword and the opening brace of the block of an "if", "for", or "switch" statement, and the composite literal is not enclosed in parentheses, square brackets, or curly braces. In this rare case, the opening brace of the literal is erroneously parsed as the one introducing the block of statements. To resolve the ambiguity, the composite literal must appear within parentheses.

Examples of valid array, slice, and map literals:

Function literals

A function literal represents an anonymous function . Function literals cannot declare type parameters.

A function literal can be assigned to a variable or invoked directly.

Function literals are closures : they may refer to variables defined in a surrounding function. Those variables are then shared between the surrounding function and the function literal, and they survive as long as they are accessible.

Primary expressions

Primary expressions are the operands for unary and binary expressions.

For a primary expression x that is not a package name , the selector expression

denotes the field or method f of the value x (or sometimes *x ; see below). The identifier f is called the (field or method) selector ; it must not be the blank identifier . The type of the selector expression is the type of f . If x is a package name, see the section on qualified identifiers .

A selector f may denote a field or method f of a type T , or it may refer to a field or method f of a nested embedded field of T . The number of embedded fields traversed to reach f is called its depth in T . The depth of a field or method f declared in T is zero. The depth of a field or method f declared in an embedded field A in T is the depth of f in A plus one.

The following rules apply to selectors:

• For a value x of type T or *T where T is not a pointer or interface type, x.f denotes the field or method at the shallowest depth in T where there is such an f . If there is not exactly one f with shallowest depth, the selector expression is illegal.
• For a value x of type I where I is an interface type, x.f denotes the actual method with name f of the dynamic value of x . If there is no method with name f in the method set of I , the selector expression is illegal.
• As an exception, if the type of x is a defined pointer type and (*x).f is a valid selector expression denoting a field (but not a method), x.f is shorthand for (*x).f .
• In all other cases, x.f is illegal.
• If x is of pointer type and has the value nil and x.f denotes a struct field, assigning to or evaluating x.f causes a run-time panic .
• If x is of interface type and has the value nil , calling or evaluating the method x.f causes a run-time panic .

For example, given the declarations:

one may write:

but the following is invalid:

Method expressions

If M is in the method set of type T , T.M is a function that is callable as a regular function with the same arguments as M prefixed by an additional argument that is the receiver of the method.

Consider a struct type T with two methods, Mv , whose receiver is of type T , and Mp , whose receiver is of type *T .

The expression

yields a function equivalent to Mv but with an explicit receiver as its first argument; it has signature

That function may be called normally with an explicit receiver, so these five invocations are equivalent:

Similarly, the expression

yields a function value representing Mp with signature

For a method with a value receiver, one can derive a function with an explicit pointer receiver, so

yields a function value representing Mv with signature

Such a function indirects through the receiver to create a value to pass as the receiver to the underlying method; the method does not overwrite the value whose address is passed in the function call.

The final case, a value-receiver function for a pointer-receiver method, is illegal because pointer-receiver methods are not in the method set of the value type.

Function values derived from methods are called with function call syntax; the receiver is provided as the first argument to the call. That is, given f := T.Mv , f is invoked as f(t, 7) not t.f(7) . To construct a function that binds the receiver, use a function literal or method value .

It is legal to derive a function value from a method of an interface type. The resulting function takes an explicit receiver of that interface type.

Method values

If the expression x has static type T and M is in the method set of type T , x.M is called a method value . The method value x.M is a function value that is callable with the same arguments as a method call of x.M . The expression x is evaluated and saved during the evaluation of the method value; the saved copy is then used as the receiver in any calls, which may be executed later.

The type T may be an interface or non-interface type.

As in the discussion of method expressions above, consider a struct type T with two methods, Mv , whose receiver is of type T , and Mp , whose receiver is of type *T .

yields a function value of type

These two invocations are equivalent:

As with selectors , a reference to a non-interface method with a value receiver using a pointer will automatically dereference that pointer: pt.Mv is equivalent to (*pt).Mv .

As with method calls , a reference to a non-interface method with a pointer receiver using an addressable value will automatically take the address of that value: t.Mp is equivalent to (&t).Mp .

Although the examples above use non-interface types, it is also legal to create a method value from a value of interface type.

Index expressions

A primary expression of the form

denotes the element of the array, pointer to array, slice, string or map a indexed by x . The value x is called the index or map key , respectively. The following rules apply:

If a is neither a map nor a type parameter:

• the index x must be an untyped constant or its core type must be an integer
• a constant index must be non-negative and representable by a value of type int
• a constant index that is untyped is given type int
• the index x is in range if 0 <= x < len(a) , otherwise it is out of range

For a of array type A :

• a constant index must be in range
• if x is out of range at run time, a run-time panic occurs
• a[x] is the array element at index x and the type of a[x] is the element type of A

For a of pointer to array type:

• a[x] is shorthand for (*a)[x]

For a of slice type S :

• a[x] is the slice element at index x and the type of a[x] is the element type of S

For a of string type :

• a constant index must be in range if the string a is also constant
• a[x] is the non-constant byte value at index x and the type of a[x] is byte
• a[x] may not be assigned to

For a of map type M :

• x 's type must be assignable to the key type of M
• if the map contains an entry with key x , a[x] is the map element with key x and the type of a[x] is the element type of M
• if the map is nil or does not contain such an entry, a[x] is the zero value for the element type of M

For a of type parameter type P :

• The index expression a[x] must be valid for values of all types in P 's type set.
• The element types of all types in P 's type set must be identical. In this context, the element type of a string type is byte .
• If there is a map type in the type set of P , all types in that type set must be map types, and the respective key types must be all identical.
• a[x] is the array, slice, or string element at index x , or the map element with key x of the type argument that P is instantiated with, and the type of a[x] is the type of the (identical) element types.
• a[x] may not be assigned to if P 's type set includes string types.

Otherwise a[x] is illegal.

An index expression on a map a of type map[K]V used in an assignment statement or initialization of the special form

yields an additional untyped boolean value. The value of ok is true if the key x is present in the map, and false otherwise.

Assigning to an element of a nil map causes a run-time panic .

Slice expressions

Slice expressions construct a substring or slice from a string, array, pointer to array, or slice. There are two variants: a simple form that specifies a low and high bound, and a full form that also specifies a bound on the capacity.

Simple slice expressions

The primary expression

constructs a substring or slice. The core type of a must be a string, array, pointer to array, slice, or a bytestring . The indices low and high select which elements of operand a appear in the result. The result has indices starting at 0 and length equal to high  -  low . After slicing the array a

the slice s has type []int , length 3, capacity 4, and elements

For convenience, any of the indices may be omitted. A missing low index defaults to zero; a missing high index defaults to the length of the sliced operand:

If a is a pointer to an array, a[low : high] is shorthand for (*a)[low : high] .

For arrays or strings, the indices are in range if 0 <= low <= high <= len(a) , otherwise they are out of range . For slices, the upper index bound is the slice capacity cap(a) rather than the length. A constant index must be non-negative and representable by a value of type int ; for arrays or constant strings, constant indices must also be in range. If both indices are constant, they must satisfy low <= high . If the indices are out of range at run time, a run-time panic occurs.

Except for untyped strings , if the sliced operand is a string or slice, the result of the slice operation is a non-constant value of the same type as the operand. For untyped string operands the result is a non-constant value of type string . If the sliced operand is an array, it must be addressable and the result of the slice operation is a slice with the same element type as the array.

If the sliced operand of a valid slice expression is a nil slice, the result is a nil slice. Otherwise, if the result is a slice, it shares its underlying array with the operand.

Full slice expressions

constructs a slice of the same type, and with the same length and elements as the simple slice expression a[low : high] . Additionally, it controls the resulting slice's capacity by setting it to max - low . Only the first index may be omitted; it defaults to 0. The core type of a must be an array, pointer to array, or slice (but not a string). After slicing the array a

the slice t has type []int , length 2, capacity 4, and elements

As for simple slice expressions, if a is a pointer to an array, a[low : high : max] is shorthand for (*a)[low : high : max] . If the sliced operand is an array, it must be addressable .

The indices are in range if 0 <= low <= high <= max <= cap(a) , otherwise they are out of range . A constant index must be non-negative and representable by a value of type int ; for arrays, constant indices must also be in range. If multiple indices are constant, the constants that are present must be in range relative to each other. If the indices are out of range at run time, a run-time panic occurs.

Type assertions

For an expression x of interface type , but not a type parameter , and a type T , the primary expression

asserts that x is not nil and that the value stored in x is of type T . The notation x.(T) is called a type assertion .

More precisely, if T is not an interface type, x.(T) asserts that the dynamic type of x is identical to the type T . In this case, T must implement the (interface) type of x ; otherwise the type assertion is invalid since it is not possible for x to store a value of type T . If T is an interface type, x.(T) asserts that the dynamic type of x implements the interface T .

If the type assertion holds, the value of the expression is the value stored in x and its type is T . If the type assertion is false, a run-time panic occurs. In other words, even though the dynamic type of x is known only at run time, the type of x.(T) is known to be T in a correct program.

A type assertion used in an assignment statement or initialization of the special form

yields an additional untyped boolean value. The value of ok is true if the assertion holds. Otherwise it is false and the value of v is the zero value for type T . No run-time panic occurs in this case.

Given an expression f with a core type F of function type ,

calls f with arguments a1, a2, … an . Except for one special case, arguments must be single-valued expressions assignable to the parameter types of F and are evaluated before the function is called. The type of the expression is the result type of F . A method invocation is similar but the method itself is specified as a selector upon a value of the receiver type for the method.

If f denotes a generic function, it must be instantiated before it can be called or used as a function value.

In a function call, the function value and arguments are evaluated in the usual order . After they are evaluated, the parameters of the call are passed by value to the function and the called function begins execution. The return parameters of the function are passed by value back to the caller when the function returns.

Calling a nil function value causes a run-time panic .

As a special case, if the return values of a function or method g are equal in number and individually assignable to the parameters of another function or method f , then the call f(g( parameters_of_g )) will invoke f after binding the return values of g to the parameters of f in order. The call of f must contain no parameters other than the call of g , and g must have at least one return value. If f has a final ... parameter, it is assigned the return values of g that remain after assignment of regular parameters.

A method call x.m() is valid if the method set of (the type of) x contains m and the argument list can be assigned to the parameter list of m . If x is addressable and &x 's method set contains m , x.m() is shorthand for (&x).m() :

There is no distinct method type and there are no method literals.

Passing arguments to ... parameters

If f is variadic with a final parameter p of type ...T , then within f the type of p is equivalent to type []T . If f is invoked with no actual arguments for p , the value passed to p is nil . Otherwise, the value passed is a new slice of type []T with a new underlying array whose successive elements are the actual arguments, which all must be assignable to T . The length and capacity of the slice is therefore the number of arguments bound to p and may differ for each call site.

Given the function and calls

within Greeting , who will have the value nil in the first call, and []string{"Joe", "Anna", "Eileen"} in the second.

If the final argument is assignable to a slice type []T and is followed by ... , it is passed unchanged as the value for a ...T parameter. In this case no new slice is created.

Given the slice s and call

within Greeting , who will have the same value as s with the same underlying array.

Instantiations

A generic function or type is instantiated by substituting type arguments for the type parameters [ Go 1.18 ]. Instantiation proceeds in two steps:

• Each type argument is substituted for its corresponding type parameter in the generic declaration. This substitution happens across the entire function or type declaration, including the type parameter list itself and any types in that list.
• After substitution, each type argument must satisfy the constraint (instantiated, if necessary) of the corresponding type parameter. Otherwise instantiation fails.

Instantiating a type results in a new non-generic named type ; instantiating a function produces a new non-generic function.

When using a generic function, type arguments may be provided explicitly, or they may be partially or completely inferred from the context in which the function is used. Provided that they can be inferred, type argument lists may be omitted entirely if the function is:

• called with ordinary arguments,
• assigned to a variable with a known type
• passed as an argument to another function, or
• returned as a result .

In all other cases, a (possibly partial) type argument list must be present. If a type argument list is absent or partial, all missing type arguments must be inferrable from the context in which the function is used.

A partial type argument list cannot be empty; at least the first argument must be present. The list is a prefix of the full list of type arguments, leaving the remaining arguments to be inferred. Loosely speaking, type arguments may be omitted from "right to left".

For a generic type, all type arguments must always be provided explicitly.

Type inference

A use of a generic function may omit some or all type arguments if they can be inferred from the context within which the function is used, including the constraints of the function's type parameters. Type inference succeeds if it can infer the missing type arguments and instantiation succeeds with the inferred type arguments. Otherwise, type inference fails and the program is invalid.

Type inference uses the type relationships between pairs of types for inference: For instance, a function argument must be assignable to its respective function parameter; this establishes a relationship between the type of the argument and the type of the parameter. If either of these two types contains type parameters, type inference looks for the type arguments to substitute the type parameters with such that the assignability relationship is satisfied. Similarly, type inference uses the fact that a type argument must satisfy the constraint of its respective type parameter.

Each such pair of matched types corresponds to a type equation containing one or multiple type parameters, from one or possibly multiple generic functions. Inferring the missing type arguments means solving the resulting set of type equations for the respective type parameters.

For example, given

the variable s of type Slice must be assignable to the function parameter type S for the program to be valid. To reduce complexity, type inference ignores the directionality of assignments, so the type relationship between Slice and S can be expressed via the (symmetric) type equation Slice ≡ A S (or S ≡ A Slice for that matter), where the A in ≡ A indicates that the LHS and RHS types must match per assignability rules (see the section on type unification for details). Similarly, the type parameter S must satisfy its constraint ~[]E . This can be expressed as S ≡ C ~[]E where X ≡ C Y stands for " X satisfies constraint Y ". These observations lead to a set of two equations

which now can be solved for the type parameters S and E . From (1) a compiler can infer that the type argument for S is Slice . Similarly, because the underlying type of Slice is []int and []int must match []E of the constraint, a compiler can infer that E must be int . Thus, for these two equations, type inference infers

Given a set of type equations, the type parameters to solve for are the type parameters of the functions that need to be instantiated and for which no explicit type arguments is provided. These type parameters are called bound type parameters. For instance, in the dedup example above, the type parameters S and E are bound to dedup . An argument to a generic function call may be a generic function itself. The type parameters of that function are included in the set of bound type parameters. The types of function arguments may contain type parameters from other functions (such as a generic function enclosing a function call). Those type parameters may also appear in type equations but they are not bound in that context. Type equations are always solved for the bound type parameters only.

Type inference supports calls of generic functions and assignments of generic functions to (explicitly function-typed) variables. This includes passing generic functions as arguments to other (possibly also generic) functions, and returning generic functions as results. Type inference operates on a set of equations specific to each of these cases. The equations are as follows (type argument lists are omitted for clarity):

For a function call f(a 0 , a 1 , …) where f or a function argument a i is a generic function: Each pair (a i , p i ) of corresponding function arguments and parameters where a i is not an untyped constant yields an equation typeof(p i ) ≡ A typeof(a i ) . If a i is an untyped constant c j , and typeof(p i ) is a bound type parameter P k , the pair (c j , P k ) is collected separately from the type equations.

For an assignment v = f of a generic function f to a (non-generic) variable v of function type: typeof(v) ≡ A typeof(f) .

For a return statement return …, f, … where f is a generic function returned as a result to a (non-generic) result variable r of function type: typeof(r) ≡ A typeof(f) .

Additionally, each type parameter P k and corresponding type constraint C k yields the type equation P k ≡ C C k .

Type inference gives precedence to type information obtained from typed operands before considering untyped constants. Therefore, inference proceeds in two phases:

The type equations are solved for the bound type parameters using type unification . If unification fails, type inference fails.

For each bound type parameter P k for which no type argument has been inferred yet and for which one or more pairs (c j , P k ) with that same type parameter were collected, determine the constant kind of the constants c j in all those pairs the same way as for constant expressions . The type argument for P k is the default type for the determined constant kind. If a constant kind cannot be determined due to conflicting constant kinds, type inference fails.

If not all type arguments have been found after these two phases, type inference fails.

If the two phases are successful, type inference determined a type argument for each bound type parameter:

A type argument A k may be a composite type, containing other bound type parameters P k as element types (or even be just another bound type parameter). In a process of repeated simplification, the bound type parameters in each type argument are substituted with the respective type arguments for those type parameters until each type argument is free of bound type parameters.

If type arguments contain cyclic references to themselves through bound type parameters, simplification and thus type inference fails. Otherwise, type inference succeeds.

Type unification

Type inference solves type equations through type unification . Type unification recursively compares the LHS and RHS types of an equation, where either or both types may be or contain bound type parameters, and looks for type arguments for those type parameters such that the LHS and RHS match (become identical or assignment-compatible, depending on context). To that effect, type inference maintains a map of bound type parameters to inferred type arguments; this map is consulted and updated during type unification. Initially, the bound type parameters are known but the map is empty. During type unification, if a new type argument A is inferred, the respective mapping P ➞ A from type parameter to argument is added to the map. Conversely, when comparing types, a known type argument (a type argument for which a map entry already exists) takes the place of its corresponding type parameter. As type inference progresses, the map is populated more and more until all equations have been considered, or until unification fails. Type inference succeeds if no unification step fails and the map has an entry for each type parameter.

For example, given the type equation with the bound type parameter P

type inference starts with an empty map. Unification first compares the top-level structure of the LHS and RHS types. Both are arrays of the same length; they unify if the element types unify. Both element types are structs; they unify if they have the same number of fields with the same names and if the field types unify. The type argument for P is not known yet (there is no map entry), so unifying P with string adds the mapping P ➞ string to the map. Unifying the types of the list field requires unifying []P and []string and thus P and string . Since the type argument for P is known at this point (there is a map entry for P ), its type argument string takes the place of P . And since string is identical to string , this unification step succeeds as well. Unification of the LHS and RHS of the equation is now finished. Type inference succeeds because there is only one type equation, no unification step failed, and the map is fully populated.

Unification uses a combination of exact and loose unification depending on whether two types have to be identical , assignment-compatible , or only structurally equal. The respective type unification rules are spelled out in detail in the Appendix .

For an equation of the form X ≡ A Y , where X and Y are types involved in an assignment (including parameter passing and return statements), the top-level type structures may unify loosely but element types must unify exactly, matching the rules for assignments.

For an equation of the form P ≡ C C , where P is a type parameter and C its corresponding constraint, the unification rules are bit more complicated:

• If C has a core type core(C) and P has a known type argument A , core(C) and A must unify loosely. If P does not have a known type argument and C contains exactly one type term T that is not an underlying (tilde) type, unification adds the mapping P ➞ T to the map.
• If C does not have a core type and P has a known type argument A , A must have all methods of C , if any, and corresponding method types must unify exactly.

When solving type equations from type constraints, solving one equation may infer additional type arguments, which in turn may enable solving other equations that depend on those type arguments. Type inference repeats type unification as long as new type arguments are inferred.

Operators combine operands into expressions.

Comparisons are discussed elsewhere . For other binary operators, the operand types must be identical unless the operation involves shifts or untyped constants . For operations involving constants only, see the section on constant expressions .

Except for shift operations, if one operand is an untyped constant and the other operand is not, the constant is implicitly converted to the type of the other operand.

The right operand in a shift expression must have integer type [ Go 1.13 ] or be an untyped constant representable by a value of type uint . If the left operand of a non-constant shift expression is an untyped constant, it is first implicitly converted to the type it would assume if the shift expression were replaced by its left operand alone.

Operator precedence

Unary operators have the highest precedence. As the ++ and -- operators form statements, not expressions, they fall outside the operator hierarchy. As a consequence, statement *p++ is the same as (*p)++ .

There are five precedence levels for binary operators. Multiplication operators bind strongest, followed by addition operators, comparison operators, && (logical AND), and finally || (logical OR):

Binary operators of the same precedence associate from left to right. For instance, x / y * z is the same as (x / y) * z .

Arithmetic operators

Arithmetic operators apply to numeric values and yield a result of the same type as the first operand. The four standard arithmetic operators ( + , - , * , / ) apply to integer , floating-point , and complex types; + also applies to strings . The bitwise logical and shift operators apply to integers only.

If the operand type is a type parameter , the operator must apply to each type in that type set. The operands are represented as values of the type argument that the type parameter is instantiated with, and the operation is computed with the precision of that type argument. For example, given the function:

the product x * y and the addition s += x * y are computed with float32 or float64 precision, respectively, depending on the type argument for F .

Integer operators

For two integer values x and y , the integer quotient q = x / y and remainder r = x % y satisfy the following relationships:

with x / y truncated towards zero ( "truncated division" ).

The one exception to this rule is that if the dividend x is the most negative value for the int type of x , the quotient q = x / -1 is equal to x (and r = 0 ) due to two's-complement integer overflow :

If the divisor is a constant , it must not be zero. If the divisor is zero at run time, a run-time panic occurs. If the dividend is non-negative and the divisor is a constant power of 2, the division may be replaced by a right shift, and computing the remainder may be replaced by a bitwise AND operation:

The shift operators shift the left operand by the shift count specified by the right operand, which must be non-negative. If the shift count is negative at run time, a run-time panic occurs. The shift operators implement arithmetic shifts if the left operand is a signed integer and logical shifts if it is an unsigned integer. There is no upper limit on the shift count. Shifts behave as if the left operand is shifted n times by 1 for a shift count of n . As a result, x << 1 is the same as x*2 and x >> 1 is the same as x/2 but truncated towards negative infinity.

For integer operands, the unary operators + , - , and ^ are defined as follows:

Integer overflow

For unsigned integer values, the operations + , - , * , and << are computed modulo 2 n , where n is the bit width of the unsigned integer's type. Loosely speaking, these unsigned integer operations discard high bits upon overflow, and programs may rely on "wrap around".

For signed integers, the operations + , - , * , / , and << may legally overflow and the resulting value exists and is deterministically defined by the signed integer representation, the operation, and its operands. Overflow does not cause a run-time panic . A compiler may not optimize code under the assumption that overflow does not occur. For instance, it may not assume that x < x + 1 is always true.

Floating-point operators

For floating-point and complex numbers, +x is the same as x , while -x is the negation of x . The result of a floating-point or complex division by zero is not specified beyond the IEEE-754 standard; whether a run-time panic occurs is implementation-specific.

An implementation may combine multiple floating-point operations into a single fused operation, possibly across statements, and produce a result that differs from the value obtained by executing and rounding the instructions individually. An explicit floating-point type conversion rounds to the precision of the target type, preventing fusion that would discard that rounding.

For instance, some architectures provide a "fused multiply and add" (FMA) instruction that computes x*y + z without rounding the intermediate result x*y . These examples show when a Go implementation can use that instruction:

String concatenation

Strings can be concatenated using the + operator or the += assignment operator:

String addition creates a new string by concatenating the operands.

Comparison operators

Comparison operators compare two operands and yield an untyped boolean value.

In any comparison, the first operand must be assignable to the type of the second operand, or vice versa.

The equality operators == and != apply to operands of comparable types. The ordering operators < , <= , > , and >= apply to operands of ordered types. These terms and the result of the comparisons are defined as follows:

• Boolean types are comparable. Two boolean values are equal if they are either both true or both false .
• Integer types are comparable and ordered. Two integer values are compared in the usual way.
• Floating-point types are comparable and ordered. Two floating-point values are compared as defined by the IEEE-754 standard.
• Complex types are comparable. Two complex values u and v are equal if both real(u) == real(v) and imag(u) == imag(v) .
• String types are comparable and ordered. Two string values are compared lexically byte-wise.
• Pointer types are comparable. Two pointer values are equal if they point to the same variable or if both have value nil . Pointers to distinct zero-size variables may or may not be equal.
• Channel types are comparable. Two channel values are equal if they were created by the same call to make or if both have value nil .
• Interface types that are not type parameters are comparable. Two interface values are equal if they have identical dynamic types and equal dynamic values or if both have value nil .
• A value x of non-interface type X and a value t of interface type T can be compared if type X is comparable and X implements T . They are equal if t 's dynamic type is identical to X and t 's dynamic value is equal to x .
• Struct types are comparable if all their field types are comparable. Two struct values are equal if their corresponding non- blank field values are equal. The fields are compared in source order, and comparison stops as soon as two field values differ (or all fields have been compared).
• Array types are comparable if their array element types are comparable. Two array values are equal if their corresponding element values are equal. The elements are compared in ascending index order, and comparison stops as soon as two element values differ (or all elements have been compared).
• Type parameters are comparable if they are strictly comparable (see below).

A comparison of two interface values with identical dynamic types causes a run-time panic if that type is not comparable. This behavior applies not only to direct interface value comparisons but also when comparing arrays of interface values or structs with interface-valued fields.

Slice, map, and function types are not comparable. However, as a special case, a slice, map, or function value may be compared to the predeclared identifier nil . Comparison of pointer, channel, and interface values to nil is also allowed and follows from the general rules above.

A type is strictly comparable if it is comparable and not an interface type nor composed of interface types. Specifically:

• Boolean, numeric, string, pointer, and channel types are strictly comparable.
• Struct types are strictly comparable if all their field types are strictly comparable.
• Array types are strictly comparable if their array element types are strictly comparable.
• Type parameters are strictly comparable if all types in their type set are strictly comparable.

Logical operators

Logical operators apply to boolean values and yield a result of the same type as the operands. The left operand is evaluated, and then the right if the condition requires it.

Address operators

For an operand x of type T , the address operation &x generates a pointer of type *T to x . The operand must be addressable , that is, either a variable, pointer indirection, or slice indexing operation; or a field selector of an addressable struct operand; or an array indexing operation of an addressable array. As an exception to the addressability requirement, x may also be a (possibly parenthesized) composite literal . If the evaluation of x would cause a run-time panic , then the evaluation of &x does too.

For an operand x of pointer type *T , the pointer indirection *x denotes the variable of type T pointed to by x . If x is nil , an attempt to evaluate *x will cause a run-time panic .

Receive operator

For an operand ch whose core type is a channel , the value of the receive operation <-ch is the value received from the channel ch . The channel direction must permit receive operations, and the type of the receive operation is the element type of the channel. The expression blocks until a value is available. Receiving from a nil channel blocks forever. A receive operation on a closed channel can always proceed immediately, yielding the element type's zero value after any previously sent values have been received.

A receive expression used in an assignment statement or initialization of the special form

yields an additional untyped boolean result reporting whether the communication succeeded. The value of ok is true if the value received was delivered by a successful send operation to the channel, or false if it is a zero value generated because the channel is closed and empty.

Conversions

A conversion changes the type of an expression to the type specified by the conversion. A conversion may appear literally in the source, or it may be implied by the context in which an expression appears.

An explicit conversion is an expression of the form T(x) where T is a type and x is an expression that can be converted to type T .

If the type starts with the operator * or <- , or if the type starts with the keyword func and has no result list, it must be parenthesized when necessary to avoid ambiguity:

A constant value x can be converted to type T if x is representable by a value of T . As a special case, an integer constant x can be explicitly converted to a string type using the same rule as for non-constant x .

Converting a constant to a type that is not a type parameter yields a typed constant.

Converting a constant to a type parameter yields a non-constant value of that type, with the value represented as a value of the type argument that the type parameter is instantiated with. For example, given the function:

the conversion P(1.1) results in a non-constant value of type P and the value 1.1 is represented as a float32 or a float64 depending on the type argument for f . Accordingly, if f is instantiated with a float32 type, the numeric value of the expression P(1.1) + 1.2 will be computed with the same precision as the corresponding non-constant float32 addition.

A non-constant value x can be converted to type T in any of these cases:

• x is assignable to T .
• ignoring struct tags (see below), x 's type and T are not type parameters but have identical underlying types .
• ignoring struct tags (see below), x 's type and T are pointer types that are not named types , and their pointer base types are not type parameters but have identical underlying types.
• x 's type and T are both integer or floating point types.
• x 's type and T are both complex types.
• x is an integer or a slice of bytes or runes and T is a string type.
• x is a string and T is a slice of bytes or runes.
• x is a slice, T is an array [ Go 1.20 ] or a pointer to an array [ Go 1.17 ], and the slice and array types have identical element types.

Additionally, if T or x 's type V are type parameters, x can also be converted to type T if one of the following conditions applies:

• Both V and T are type parameters and a value of each type in V 's type set can be converted to each type in T 's type set.
• Only V is a type parameter and a value of each type in V 's type set can be converted to T .
• Only T is a type parameter and x can be converted to each type in T 's type set.

Struct tags are ignored when comparing struct types for identity for the purpose of conversion:

Specific rules apply to (non-constant) conversions between numeric types or to and from a string type. These conversions may change the representation of x and incur a run-time cost. All other conversions only change the type but not the representation of x .

There is no linguistic mechanism to convert between pointers and integers. The package unsafe implements this functionality under restricted circumstances.

Conversions between numeric types

For the conversion of non-constant numeric values, the following rules apply:

• When converting between integer types , if the value is a signed integer, it is sign extended to implicit infinite precision; otherwise it is zero extended. It is then truncated to fit in the result type's size. For example, if v := uint16(0x10F0) , then uint32(int8(v)) == 0xFFFFFFF0 . The conversion always yields a valid value; there is no indication of overflow.
• When converting a floating-point number to an integer, the fraction is discarded (truncation towards zero).
• When converting an integer or floating-point number to a floating-point type, or a complex number to another complex type, the result value is rounded to the precision specified by the destination type. For instance, the value of a variable x of type float32 may be stored using additional precision beyond that of an IEEE-754 32-bit number, but float32(x) represents the result of rounding x 's value to 32-bit precision. Similarly, x + 0.1 may use more than 32 bits of precision, but float32(x + 0.1) does not.

In all non-constant conversions involving floating-point or complex values, if the result type cannot represent the value the conversion succeeds but the result value is implementation-dependent.

Conversions to and from a string type

• Converting a slice of bytes to a string type yields a string whose successive bytes are the elements of the slice. string([]byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}) // "hellø" string([]byte{}) // "" string([]byte(nil)) // "" type bytes []byte string(bytes{'h', 'e', 'l', 'l', '\xc3', '\xb8'}) // "hellø" type myByte byte string([]myByte{'w', 'o', 'r', 'l', 'd', '!'}) // "world!" myString([]myByte{'\xf0', '\x9f', '\x8c', '\x8d'}) // "🌍"
• Converting a slice of runes to a string type yields a string that is the concatenation of the individual rune values converted to strings. string([]rune{0x767d, 0x9d6c, 0x7fd4}) // "\u767d\u9d6c\u7fd4" == "白鵬翔" string([]rune{}) // "" string([]rune(nil)) // "" type runes []rune string(runes{0x767d, 0x9d6c, 0x7fd4}) // "\u767d\u9d6c\u7fd4" == "白鵬翔" type myRune rune string([]myRune{0x266b, 0x266c}) // "\u266b\u266c" == "♫♬" myString([]myRune{0x1f30e}) // "\U0001f30e" == "🌎"
• Converting a value of a string type to a slice of bytes type yields a non-nil slice whose successive elements are the bytes of the string. []byte("hellø") // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'} []byte("") // []byte{} bytes("hellø") // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'} []myByte("world!") // []myByte{'w', 'o', 'r', 'l', 'd', '!'} []myByte(myString("🌏")) // []myByte{'\xf0', '\x9f', '\x8c', '\x8f'}
• Converting a value of a string type to a slice of runes type yields a slice containing the individual Unicode code points of the string. []rune(myString("白鵬翔")) // []rune{0x767d, 0x9d6c, 0x7fd4} []rune("") // []rune{} runes("白鵬翔") // []rune{0x767d, 0x9d6c, 0x7fd4} []myRune("♫♬") // []myRune{0x266b, 0x266c} []myRune(myString("🌐")) // []myRune{0x1f310}
• Finally, for historical reasons, an integer value may be converted to a string type. This form of conversion yields a string containing the (possibly multi-byte) UTF-8 representation of the Unicode code point with the given integer value. Values outside the range of valid Unicode code points are converted to "\uFFFD" . string('a') // "a" string(65) // "A" string('\xf8') // "\u00f8" == "ø" == "\xc3\xb8" string(-1) // "\ufffd" == "\xef\xbf\xbd" type myString string myString('\u65e5') // "\u65e5" == "日" == "\xe6\x97\xa5" Note: This form of conversion may eventually be removed from the language. The go vet tool flags certain integer-to-string conversions as potential errors. Library functions such as utf8.AppendRune or utf8.EncodeRune should be used instead.

Conversions from slice to array or array pointer

Converting a slice to an array yields an array containing the elements of the underlying array of the slice. Similarly, converting a slice to an array pointer yields a pointer to the underlying array of the slice. In both cases, if the length of the slice is less than the length of the array, a run-time panic occurs.

Constant expressions

Constant expressions may contain only constant operands and are evaluated at compile time.

Untyped boolean, numeric, and string constants may be used as operands wherever it is legal to use an operand of boolean, numeric, or string type, respectively.

A constant comparison always yields an untyped boolean constant. If the left operand of a constant shift expression is an untyped constant, the result is an integer constant; otherwise it is a constant of the same type as the left operand, which must be of integer type .

Any other operation on untyped constants results in an untyped constant of the same kind; that is, a boolean, integer, floating-point, complex, or string constant. If the untyped operands of a binary operation (other than a shift) are of different kinds, the result is of the operand's kind that appears later in this list: integer, rune, floating-point, complex. For example, an untyped integer constant divided by an untyped complex constant yields an untyped complex constant.

Applying the built-in function complex to untyped integer, rune, or floating-point constants yields an untyped complex constant.

Constant expressions are always evaluated exactly; intermediate values and the constants themselves may require precision significantly larger than supported by any predeclared type in the language. The following are legal declarations:

The divisor of a constant division or remainder operation must not be zero:

The values of typed constants must always be accurately representable by values of the constant type. The following constant expressions are illegal:

The mask used by the unary bitwise complement operator ^ matches the rule for non-constants: the mask is all 1s for unsigned constants and -1 for signed and untyped constants.

Implementation restriction: A compiler may use rounding while computing untyped floating-point or complex constant expressions; see the implementation restriction in the section on constants . This rounding may cause a floating-point constant expression to be invalid in an integer context, even if it would be integral when calculated using infinite precision, and vice versa.

Order of evaluation

At package level, initialization dependencies determine the evaluation order of individual initialization expressions in variable declarations . Otherwise, when evaluating the operands of an expression, assignment, or return statement , all function calls, method calls, receive operations , and binary logical operations are evaluated in lexical left-to-right order.

For example, in the (function-local) assignment

the function calls and communication happen in the order f() , h() (if z evaluates to false), i() , j() , <-c , g() , and k() . However, the order of those events compared to the evaluation and indexing of x and the evaluation of y and z is not specified, except as required lexically. For instance, g cannot be called before its arguments are evaluated.

At package level, initialization dependencies override the left-to-right rule for individual initialization expressions, but not for operands within each expression:

The function calls happen in the order u() , sqr() , v() , f() , v() , and g() .

Floating-point operations within a single expression are evaluated according to the associativity of the operators. Explicit parentheses affect the evaluation by overriding the default associativity. In the expression x + (y + z) the addition y + z is performed before adding x .

Statements control execution.

Terminating statements

A terminating statement interrupts the regular flow of control in a block . The following statements are terminating:

• A "return" or "goto" statement.
• A call to the built-in function panic .
• A block in which the statement list ends in a terminating statement.
• the "else" branch is present, and
• both branches are terminating statements.
• there are no "break" statements referring to the "for" statement, and
• the loop condition is absent, and
• the "for" statement does not use a range clause.
• there are no "break" statements referring to the "switch" statement,
• there is a default case, and
• the statement lists in each case, including the default, end in a terminating statement, or a possibly labeled "fallthrough" statement .
• there are no "break" statements referring to the "select" statement, and
• the statement lists in each case, including the default if present, end in a terminating statement.
• A labeled statement labeling a terminating statement.

All other statements are not terminating.

A statement list ends in a terminating statement if the list is not empty and its final non-empty statement is terminating.

Empty statements

The empty statement does nothing.

Labeled statements

A labeled statement may be the target of a goto , break or continue statement.

Expression statements

With the exception of specific built-in functions, function and method calls and receive operations can appear in statement context. Such statements may be parenthesized.

The following built-in functions are not permitted in statement context:

Send statements

A send statement sends a value on a channel. The channel expression's core type must be a channel , the channel direction must permit send operations, and the type of the value to be sent must be assignable to the channel's element type.

Both the channel and the value expression are evaluated before communication begins. Communication blocks until the send can proceed. A send on an unbuffered channel can proceed if a receiver is ready. A send on a buffered channel can proceed if there is room in the buffer. A send on a closed channel proceeds by causing a run-time panic . A send on a nil channel blocks forever.

IncDec statements

The "++" and "--" statements increment or decrement their operands by the untyped constant 1 . As with an assignment, the operand must be addressable or a map index expression.

The following assignment statements are semantically equivalent:

Assignment statements

An assignment replaces the current value stored in a variable with a new value specified by an expression . An assignment statement may assign a single value to a single variable, or multiple values to a matching number of variables.

Each left-hand side operand must be addressable , a map index expression, or (for = assignments only) the blank identifier . Operands may be parenthesized.

An assignment operation x op = y where op is a binary arithmetic operator is equivalent to x = x op (y) but evaluates x only once. The op = construct is a single token. In assignment operations, both the left- and right-hand expression lists must contain exactly one single-valued expression, and the left-hand expression must not be the blank identifier.

A tuple assignment assigns the individual elements of a multi-valued operation to a list of variables. There are two forms. In the first, the right hand operand is a single multi-valued expression such as a function call, a channel or map operation, or a type assertion . The number of operands on the left hand side must match the number of values. For instance, if f is a function returning two values,

assigns the first value to x and the second to y . In the second form, the number of operands on the left must equal the number of expressions on the right, each of which must be single-valued, and the n th expression on the right is assigned to the n th operand on the left:

The blank identifier provides a way to ignore right-hand side values in an assignment:

The assignment proceeds in two phases. First, the operands of index expressions and pointer indirections (including implicit pointer indirections in selectors ) on the left and the expressions on the right are all evaluated in the usual order . Second, the assignments are carried out in left-to-right order.

In assignments, each value must be assignable to the type of the operand to which it is assigned, with the following special cases:

• Any typed value may be assigned to the blank identifier.
• If an untyped constant is assigned to a variable of interface type or the blank identifier, the constant is first implicitly converted to its default type .
• If an untyped boolean value is assigned to a variable of interface type or the blank identifier, it is first implicitly converted to type bool .

If statements

"If" statements specify the conditional execution of two branches according to the value of a boolean expression. If the expression evaluates to true, the "if" branch is executed, otherwise, if present, the "else" branch is executed.

The expression may be preceded by a simple statement, which executes before the expression is evaluated.

Switch statements

"Switch" statements provide multi-way execution. An expression or type is compared to the "cases" inside the "switch" to determine which branch to execute.

There are two forms: expression switches and type switches. In an expression switch, the cases contain expressions that are compared against the value of the switch expression. In a type switch, the cases contain types that are compared against the type of a specially annotated switch expression. The switch expression is evaluated exactly once in a switch statement.

Expression switches

In an expression switch, the switch expression is evaluated and the case expressions, which need not be constants, are evaluated left-to-right and top-to-bottom; the first one that equals the switch expression triggers execution of the statements of the associated case; the other cases are skipped. If no case matches and there is a "default" case, its statements are executed. There can be at most one default case and it may appear anywhere in the "switch" statement. A missing switch expression is equivalent to the boolean value true .

If the switch expression evaluates to an untyped constant, it is first implicitly converted to its default type . The predeclared untyped value nil cannot be used as a switch expression. The switch expression type must be comparable .

If a case expression is untyped, it is first implicitly converted to the type of the switch expression. For each (possibly converted) case expression x and the value t of the switch expression, x == t must be a valid comparison .

In other words, the switch expression is treated as if it were used to declare and initialize a temporary variable t without explicit type; it is that value of t against which each case expression x is tested for equality.

In a case or default clause, the last non-empty statement may be a (possibly labeled ) "fallthrough" statement to indicate that control should flow from the end of this clause to the first statement of the next clause. Otherwise control flows to the end of the "switch" statement. A "fallthrough" statement may appear as the last statement of all but the last clause of an expression switch.

The switch expression may be preceded by a simple statement, which executes before the expression is evaluated.

Implementation restriction: A compiler may disallow multiple case expressions evaluating to the same constant. For instance, the current compilers disallow duplicate integer, floating point, or string constants in case expressions.

Type switches

A type switch compares types rather than values. It is otherwise similar to an expression switch. It is marked by a special switch expression that has the form of a type assertion using the keyword type rather than an actual type:

Cases then match actual types T against the dynamic type of the expression x . As with type assertions, x must be of interface type , but not a type parameter , and each non-interface type T listed in a case must implement the type of x . The types listed in the cases of a type switch must all be different .

The TypeSwitchGuard may include a short variable declaration . When that form is used, the variable is declared at the end of the TypeSwitchCase in the implicit block of each clause. In clauses with a case listing exactly one type, the variable has that type; otherwise, the variable has the type of the expression in the TypeSwitchGuard.

Instead of a type, a case may use the predeclared identifier nil ; that case is selected when the expression in the TypeSwitchGuard is a nil interface value. There may be at most one nil case.

Given an expression x of type interface{} , the following type switch:

could be rewritten:

A type parameter or a generic type may be used as a type in a case. If upon instantiation that type turns out to duplicate another entry in the switch, the first matching case is chosen.

The type switch guard may be preceded by a simple statement, which executes before the guard is evaluated.

The "fallthrough" statement is not permitted in a type switch.

For statements

A "for" statement specifies repeated execution of a block. There are three forms: The iteration may be controlled by a single condition, a "for" clause, or a "range" clause.

For statements with single condition

In its simplest form, a "for" statement specifies the repeated execution of a block as long as a boolean condition evaluates to true. The condition is evaluated before each iteration. If the condition is absent, it is equivalent to the boolean value true .

For statements with for clause

A "for" statement with a ForClause is also controlled by its condition, but additionally it may specify an init and a post statement, such as an assignment, an increment or decrement statement. The init statement may be a short variable declaration , but the post statement must not.

If non-empty, the init statement is executed once before evaluating the condition for the first iteration; the post statement is executed after each execution of the block (and only if the block was executed). Any element of the ForClause may be empty but the semicolons are required unless there is only a condition. If the condition is absent, it is equivalent to the boolean value true .

Each iteration has its own separate declared variable (or variables) [ Go 1.22 ]. The variable used by the first iteration is declared by the init statement. The variable used by each subsequent iteration is declared implicitly before executing the post statement and initialized to the value of the previous iteration's variable at that moment.

Prior to [ Go 1.22 ], iterations share one set of variables instead of having their own separate variables. In that case, the example above prints

For statements with range clause

A "for" statement with a "range" clause iterates through all entries of an array, slice, string or map, values received on a channel, or integer values from zero to an upper limit [ Go 1.22 ]. For each entry it assigns iteration values to corresponding iteration variables if present and then executes the block.

The expression on the right in the "range" clause is called the range expression , its core type must be an array, pointer to an array, slice, string, map, channel permitting receive operations , or an integer. As with an assignment, if present the operands on the left must be addressable or map index expressions; they denote the iteration variables. If the range expression is a channel or integer, at most one iteration variable is permitted, otherwise there may be up to two. If the last iteration variable is the blank identifier , the range clause is equivalent to the same clause without that identifier.

The range expression x is evaluated once before beginning the loop, with one exception: if at most one iteration variable is present and len(x) is constant , the range expression is not evaluated.

Function calls on the left are evaluated once per iteration. For each iteration, iteration values are produced as follows if the respective iteration variables are present:

• For an array, pointer to array, or slice value a , the index iteration values are produced in increasing order, starting at element index 0. If at most one iteration variable is present, the range loop produces iteration values from 0 up to len(a)-1 and does not index into the array or slice itself. For a nil slice, the number of iterations is 0.
• For a string value, the "range" clause iterates over the Unicode code points in the string starting at byte index 0. On successive iterations, the index value will be the index of the first byte of successive UTF-8-encoded code points in the string, and the second value, of type rune , will be the value of the corresponding code point. If the iteration encounters an invalid UTF-8 sequence, the second value will be 0xFFFD , the Unicode replacement character, and the next iteration will advance a single byte in the string.
• The iteration order over maps is not specified and is not guaranteed to be the same from one iteration to the next. If a map entry that has not yet been reached is removed during iteration, the corresponding iteration value will not be produced. If a map entry is created during iteration, that entry may be produced during the iteration or may be skipped. The choice may vary for each entry created and from one iteration to the next. If the map is nil , the number of iterations is 0.
• For channels, the iteration values produced are the successive values sent on the channel until the channel is closed . If the channel is nil , the range expression blocks forever.
• For an integer value n , the iteration values 0 through n-1 are produced in increasing order. If n <= 0, the loop does not run any iterations.

The iteration variables may be declared by the "range" clause using a form of short variable declaration ( := ). In this case their scope is the block of the "for" statement and each iteration has its own new variables [ Go 1.22 ] (see also "for" statements with a ForClause ). If the range expression is a (possibly untyped) integer expression n , the variable has the same type as if it was declared with initialization expression n . Otherwise, the variables have the types of their respective iteration values.

If the iteration variables are not explicitly declared by the "range" clause, they must be preexisting. In this case, the iteration values are assigned to the respective variables as in an assignment statement . If the range expression is a (possibly untyped) integer expression n , n too must be assignable to the iteration variable; if there is no iteration variable, n must be assignable to int .

Go statements

A "go" statement starts the execution of a function call as an independent concurrent thread of control, or goroutine , within the same address space.

The expression must be a function or method call; it cannot be parenthesized. Calls of built-in functions are restricted as for expression statements .

The function value and parameters are evaluated as usual in the calling goroutine, but unlike with a regular call, program execution does not wait for the invoked function to complete. Instead, the function begins executing independently in a new goroutine. When the function terminates, its goroutine also terminates. If the function has any return values, they are discarded when the function completes.

Select statements

A "select" statement chooses which of a set of possible send or receive operations will proceed. It looks similar to a "switch" statement but with the cases all referring to communication operations.

A case with a RecvStmt may assign the result of a RecvExpr to one or two variables, which may be declared using a short variable declaration . The RecvExpr must be a (possibly parenthesized) receive operation. There can be at most one default case and it may appear anywhere in the list of cases.

Execution of a "select" statement proceeds in several steps:

• For all the cases in the statement, the channel operands of receive operations and the channel and right-hand-side expressions of send statements are evaluated exactly once, in source order, upon entering the "select" statement. The result is a set of channels to receive from or send to, and the corresponding values to send. Any side effects in that evaluation will occur irrespective of which (if any) communication operation is selected to proceed. Expressions on the left-hand side of a RecvStmt with a short variable declaration or assignment are not yet evaluated.
• If one or more of the communications can proceed, a single one that can proceed is chosen via a uniform pseudo-random selection. Otherwise, if there is a default case, that case is chosen. If there is no default case, the "select" statement blocks until at least one of the communications can proceed.
• Unless the selected case is the default case, the respective communication operation is executed.
• If the selected case is a RecvStmt with a short variable declaration or an assignment, the left-hand side expressions are evaluated and the received value (or values) are assigned.
• The statement list of the selected case is executed.

Since communication on nil channels can never proceed, a select with only nil channels and no default case blocks forever.

Return statements

A "return" statement in a function F terminates the execution of F , and optionally provides one or more result values. Any functions deferred by F are executed before F returns to its caller.

In a function without a result type, a "return" statement must not specify any result values.

There are three ways to return values from a function with a result type:

• The return value or values may be explicitly listed in the "return" statement. Each expression must be single-valued and assignable to the corresponding element of the function's result type. func simpleF() int { return 2 } func complexF1() (re float64, im float64) { return -7.0, -4.0 }
• The expression list in the "return" statement may be a single call to a multi-valued function. The effect is as if each value returned from that function were assigned to a temporary variable with the type of the respective value, followed by a "return" statement listing these variables, at which point the rules of the previous case apply. func complexF2() (re float64, im float64) { return complexF1() }
• The expression list may be empty if the function's result type specifies names for its result parameters . The result parameters act as ordinary local variables and the function may assign values to them as necessary. The "return" statement returns the values of these variables. func complexF3() (re float64, im float64) { re = 7.0 im = 4.0 return } func (devnull) Write(p []byte) (n int, _ error) { n = len(p) return }

Regardless of how they are declared, all the result values are initialized to the zero values for their type upon entry to the function. A "return" statement that specifies results sets the result parameters before any deferred functions are executed.

Implementation restriction: A compiler may disallow an empty expression list in a "return" statement if a different entity (constant, type, or variable) with the same name as a result parameter is in scope at the place of the return.

Break statements

A "break" statement terminates execution of the innermost "for" , "switch" , or "select" statement within the same function.

If there is a label, it must be that of an enclosing "for", "switch", or "select" statement, and that is the one whose execution terminates.

Continue statements

A "continue" statement begins the next iteration of the innermost enclosing "for" loop by advancing control to the end of the loop block. The "for" loop must be within the same function.

If there is a label, it must be that of an enclosing "for" statement, and that is the one whose execution advances.

Goto statements

A "goto" statement transfers control to the statement with the corresponding label within the same function.

Executing the "goto" statement must not cause any variables to come into scope that were not already in scope at the point of the goto. For instance, this example:

is erroneous because the jump to label L skips the creation of v .

A "goto" statement outside a block cannot jump to a label inside that block. For instance, this example:

is erroneous because the label L1 is inside the "for" statement's block but the goto is not.

Fallthrough statements

A "fallthrough" statement transfers control to the first statement of the next case clause in an expression "switch" statement . It may be used only as the final non-empty statement in such a clause.

Defer statements

A "defer" statement invokes a function whose execution is deferred to the moment the surrounding function returns, either because the surrounding function executed a return statement , reached the end of its function body , or because the corresponding goroutine is panicking .

Each time a "defer" statement executes, the function value and parameters to the call are evaluated as usual and saved anew but the actual function is not invoked. Instead, deferred functions are invoked immediately before the surrounding function returns, in the reverse order they were deferred. That is, if the surrounding function returns through an explicit return statement , deferred functions are executed after any result parameters are set by that return statement but before the function returns to its caller. If a deferred function value evaluates to nil , execution panics when the function is invoked, not when the "defer" statement is executed.

For instance, if the deferred function is a function literal and the surrounding function has named result parameters that are in scope within the literal, the deferred function may access and modify the result parameters before they are returned. If the deferred function has any return values, they are discarded when the function completes. (See also the section on handling panics .)

Built-in functions

Built-in functions are predeclared . They are called like any other function but some of them accept a type instead of an expression as the first argument.

The built-in functions do not have standard Go types, so they can only appear in call expressions ; they cannot be used as function values.

Appending to and copying slices

The built-in functions append and copy assist in common slice operations. For both functions, the result is independent of whether the memory referenced by the arguments overlaps.

The variadic function append appends zero or more values x to a slice s and returns the resulting slice of the same type as s . The core type of s must be a slice of type []E . The values x are passed to a parameter of type ...E and the respective parameter passing rules apply. As a special case, if the core type of s is []byte , append also accepts a second argument with core type bytestring followed by ... . This form appends the bytes of the byte slice or string.

If the capacity of s is not large enough to fit the additional values, append allocates a new, sufficiently large underlying array that fits both the existing slice elements and the additional values. Otherwise, append re-uses the underlying array.

The function copy copies slice elements from a source src to a destination dst and returns the number of elements copied. The core types of both arguments must be slices with identical element type. The number of elements copied is the minimum of len(src) and len(dst) . As a special case, if the destination's core type is []byte , copy also accepts a source argument with core type bytestring . This form copies the bytes from the byte slice or string into the byte slice.

The built-in function clear takes an argument of map , slice , or type parameter type, and deletes or zeroes out all elements [ Go 1.21 ].

If the type of the argument to clear is a type parameter , all types in its type set must be maps or slices, and clear performs the operation corresponding to the actual type argument.

If the map or slice is nil , clear is a no-op.

For an argument ch with a core type that is a channel , the built-in function close records that no more values will be sent on the channel. It is an error if ch is a receive-only channel. Sending to or closing a closed channel causes a run-time panic . Closing the nil channel also causes a run-time panic . After calling close , and after any previously sent values have been received, receive operations will return the zero value for the channel's type without blocking. The multi-valued receive operation returns a received value along with an indication of whether the channel is closed.

Manipulating complex numbers

Three functions assemble and disassemble complex numbers. The built-in function complex constructs a complex value from a floating-point real and imaginary part, while real and imag extract the real and imaginary parts of a complex value.

The type of the arguments and return value correspond. For complex , the two arguments must be of the same floating-point type and the return type is the complex type with the corresponding floating-point constituents: complex64 for float32 arguments, and complex128 for float64 arguments. If one of the arguments evaluates to an untyped constant, it is first implicitly converted to the type of the other argument. If both arguments evaluate to untyped constants, they must be non-complex numbers or their imaginary parts must be zero, and the return value of the function is an untyped complex constant.

For real and imag , the argument must be of complex type, and the return type is the corresponding floating-point type: float32 for a complex64 argument, and float64 for a complex128 argument. If the argument evaluates to an untyped constant, it must be a number, and the return value of the function is an untyped floating-point constant.

The real and imag functions together form the inverse of complex , so for a value z of a complex type Z , z == Z(complex(real(z), imag(z))) .

If the operands of these functions are all constants, the return value is a constant.

Arguments of type parameter type are not permitted.

Deletion of map elements

The built-in function delete removes the element with key k from a map m . The value k must be assignable to the key type of m .

If the type of m is a type parameter , all types in that type set must be maps, and they must all have identical key types.

If the map m is nil or the element m[k] does not exist, delete is a no-op.

Length and capacity

The built-in functions len and cap take arguments of various types and return a result of type int . The implementation guarantees that the result always fits into an int .

If the argument type is a type parameter P , the call len(e) (or cap(e) respectively) must be valid for each type in P 's type set. The result is the length (or capacity, respectively) of the argument whose type corresponds to the type argument with which P was instantiated .

The capacity of a slice is the number of elements for which there is space allocated in the underlying array. At any time the following relationship holds:

The length of a nil slice, map or channel is 0. The capacity of a nil slice or channel is 0.

The expression len(s) is constant if s is a string constant. The expressions len(s) and cap(s) are constants if the type of s is an array or pointer to an array and the expression s does not contain channel receives or (non-constant) function calls ; in this case s is not evaluated. Otherwise, invocations of len and cap are not constant and s is evaluated.

Making slices, maps and channels

The built-in function make takes a type T , optionally followed by a type-specific list of expressions. The core type of T must be a slice, map or channel. It returns a value of type T (not *T ). The memory is initialized as described in the section on initial values .

Each of the size arguments n and m must be of integer type , have a type set containing only integer types, or be an untyped constant . A constant size argument must be non-negative and representable by a value of type int ; if it is an untyped constant it is given type int . If both n and m are provided and are constant, then n must be no larger than m . For slices and channels, if n is negative or larger than m at run time, a run-time panic occurs.

Calling make with a map type and size hint n will create a map with initial space to hold n map elements. The precise behavior is implementation-dependent.

Min and max

The built-in functions min and max compute the smallest—or largest, respectively—value of a fixed number of arguments of ordered types . There must be at least one argument [ Go 1.21 ].

The same type rules as for operators apply: for ordered arguments x and y , min(x, y) is valid if x + y is valid, and the type of min(x, y) is the type of x + y (and similarly for max ). If all arguments are constant, the result is constant.

For numeric arguments, assuming all NaNs are equal, min and max are commutative and associative:

For floating-point arguments negative zero, NaN, and infinity the following rules apply:

For string arguments the result for min is the first argument with the smallest (or for max , largest) value, compared lexically byte-wise:

The built-in function new takes a type T , allocates storage for a variable of that type at run time, and returns a value of type *T pointing to it. The variable is initialized as described in the section on initial values .

For instance

allocates storage for a variable of type S , initializes it ( a=0 , b=0.0 ), and returns a value of type *S containing the address of the location.

Handling panics

Two built-in functions, panic and recover , assist in reporting and handling run-time panics and program-defined error conditions.

While executing a function F , an explicit call to panic or a run-time panic terminates the execution of F . Any functions deferred by F are then executed as usual. Next, any deferred functions run by F 's caller are run, and so on up to any deferred by the top-level function in the executing goroutine. At that point, the program is terminated and the error condition is reported, including the value of the argument to panic . This termination sequence is called panicking .

The recover function allows a program to manage behavior of a panicking goroutine. Suppose a function G defers a function D that calls recover and a panic occurs in a function on the same goroutine in which G is executing. When the running of deferred functions reaches D , the return value of D 's call to recover will be the value passed to the call of panic . If D returns normally, without starting a new panic , the panicking sequence stops. In that case, the state of functions called between G and the call to panic is discarded, and normal execution resumes. Any functions deferred by G before D are then run and G 's execution terminates by returning to its caller.

The return value of recover is nil when the goroutine is not panicking or recover was not called directly by a deferred function. Conversely, if a goroutine is panicking and recover was called directly by a deferred function, the return value of recover is guaranteed not to be nil . To ensure this, calling panic with a nil interface value (or an untyped nil ) causes a run-time panic .

The protect function in the example below invokes the function argument g and protects callers from run-time panics raised by g .

Bootstrapping

Current implementations provide several built-in functions useful during bootstrapping. These functions are documented for completeness but are not guaranteed to stay in the language. They do not return a result.

Implementation restriction: print and println need not accept arbitrary argument types, but printing of boolean, numeric, and string types must be supported.

Go programs are constructed by linking together packages . A package in turn is constructed from one or more source files that together declare constants, types, variables and functions belonging to the package and which are accessible in all files of the same package. Those elements may be exported and used in another package.

Source file organization

Each source file consists of a package clause defining the package to which it belongs, followed by a possibly empty set of import declarations that declare packages whose contents it wishes to use, followed by a possibly empty set of declarations of functions, types, variables, and constants.

Package clause

A package clause begins each source file and defines the package to which the file belongs.

The PackageName must not be the blank identifier .

A set of files sharing the same PackageName form the implementation of a package. An implementation may require that all source files for a package inhabit the same directory.

Import declarations

An import declaration states that the source file containing the declaration depends on functionality of the imported package ( §Program initialization and execution ) and enables access to exported identifiers of that package. The import names an identifier (PackageName) to be used for access and an ImportPath that specifies the package to be imported.

The PackageName is used in qualified identifiers to access exported identifiers of the package within the importing source file. It is declared in the file block . If the PackageName is omitted, it defaults to the identifier specified in the package clause of the imported package. If an explicit period ( . ) appears instead of a name, all the package's exported identifiers declared in that package's package block will be declared in the importing source file's file block and must be accessed without a qualifier.

The interpretation of the ImportPath is implementation-dependent but it is typically a substring of the full file name of the compiled package and may be relative to a repository of installed packages.

Implementation restriction: A compiler may restrict ImportPaths to non-empty strings using only characters belonging to Unicode's L, M, N, P, and S general categories (the Graphic characters without spaces) and may also exclude the characters !"#$%&'()*,:;<=>?[\]^`{|} and the Unicode replacement character U+FFFD.

Consider a compiled a package containing the package clause package math , which exports function Sin , and installed the compiled package in the file identified by "lib/math" . This table illustrates how Sin is accessed in files that import the package after the various types of import declaration.

An import declaration declares a dependency relation between the importing and imported package. It is illegal for a package to import itself, directly or indirectly, or to directly import a package without referring to any of its exported identifiers. To import a package solely for its side-effects (initialization), use the blank identifier as explicit package name:

An example package

Here is a complete Go package that implements a concurrent prime sieve.

Program initialization and execution

The zero value.

When storage is allocated for a variable , either through a declaration or a call of new , or when a new value is created, either through a composite literal or a call of make , and no explicit initialization is provided, the variable or value is given a default value. Each element of such a variable or value is set to the zero value for its type: false for booleans, 0 for numeric types, "" for strings, and nil for pointers, functions, interfaces, slices, channels, and maps. This initialization is done recursively, so for instance each element of an array of structs will have its fields zeroed if no value is specified.

These two simple declarations are equivalent:

the following holds:

The same would also be true after

Package initialization

Within a package, package-level variable initialization proceeds stepwise, with each step selecting the variable earliest in declaration order which has no dependencies on uninitialized variables.

More precisely, a package-level variable is considered ready for initialization if it is not yet initialized and either has no initialization expression or its initialization expression has no dependencies on uninitialized variables. Initialization proceeds by repeatedly initializing the next package-level variable that is earliest in declaration order and ready for initialization, until there are no variables ready for initialization.

If any variables are still uninitialized when this process ends, those variables are part of one or more initialization cycles, and the program is not valid.

Multiple variables on the left-hand side of a variable declaration initialized by single (multi-valued) expression on the right-hand side are initialized together: If any of the variables on the left-hand side is initialized, all those variables are initialized in the same step.

For the purpose of package initialization, blank variables are treated like any other variables in declarations.

The declaration order of variables declared in multiple files is determined by the order in which the files are presented to the compiler: Variables declared in the first file are declared before any of the variables declared in the second file, and so on. To ensure reproducible initialization behavior, build systems are encouraged to present multiple files belonging to the same package in lexical file name order to a compiler.

Dependency analysis does not rely on the actual values of the variables, only on lexical references to them in the source, analyzed transitively. For instance, if a variable x 's initialization expression refers to a function whose body refers to variable y then x depends on y . Specifically:

• A reference to a variable or function is an identifier denoting that variable or function.
• A reference to a method m is a method value or method expression of the form t.m , where the (static) type of t is not an interface type, and the method m is in the method set of t . It is immaterial whether the resulting function value t.m is invoked.
• A variable, function, or method x depends on a variable y if x 's initialization expression or body (for functions and methods) contains a reference to y or to a function or method that depends on y .

For example, given the declarations

the initialization order is d , b , c , a . Note that the order of subexpressions in initialization expressions is irrelevant: a = c + b and a = b + c result in the same initialization order in this example.

Dependency analysis is performed per package; only references referring to variables, functions, and (non-interface) methods declared in the current package are considered. If other, hidden, data dependencies exists between variables, the initialization order between those variables is unspecified.

For instance, given the declarations

the variable a will be initialized after b but whether x is initialized before b , between b and a , or after a , and thus also the moment at which sideEffect() is called (before or after x is initialized) is not specified.

Variables may also be initialized using functions named init declared in the package block, with no arguments and no result parameters.

Multiple such functions may be defined per package, even within a single source file. In the package block, the init identifier can be used only to declare init functions, yet the identifier itself is not declared . Thus init functions cannot be referred to from anywhere in a program.

The entire package is initialized by assigning initial values to all its package-level variables followed by calling all init functions in the order they appear in the source, possibly in multiple files, as presented to the compiler.

Program initialization

The packages of a complete program are initialized stepwise, one package at a time. If a package has imports, the imported packages are initialized before initializing the package itself. If multiple packages import a package, the imported package will be initialized only once. The importing of packages, by construction, guarantees that there can be no cyclic initialization dependencies. More precisely:

Given the list of all packages, sorted by import path, in each step the first uninitialized package in the list for which all imported packages (if any) are already initialized is initialized . This step is repeated until all packages are initialized.

Package initialization—variable initialization and the invocation of init functions—happens in a single goroutine, sequentially, one package at a time. An init function may launch other goroutines, which can run concurrently with the initialization code. However, initialization always sequences the init functions: it will not invoke the next one until the previous one has returned.

Program execution

A complete program is created by linking a single, unimported package called the main package with all the packages it imports, transitively. The main package must have package name main and declare a function main that takes no arguments and returns no value.

Program execution begins by initializing the program and then invoking the function main in package main . When that function invocation returns, the program exits. It does not wait for other (non- main ) goroutines to complete.

The predeclared type error is defined as

It is the conventional interface for representing an error condition, with the nil value representing no error. For instance, a function to read data from a file might be defined:

Run-time panics

Execution errors such as attempting to index an array out of bounds trigger a run-time panic equivalent to a call of the built-in function panic with a value of the implementation-defined interface type runtime.Error . That type satisfies the predeclared interface type error . The exact error values that represent distinct run-time error conditions are unspecified.

System considerations

Package unsafe.

The built-in package unsafe , known to the compiler and accessible through the import path "unsafe" , provides facilities for low-level programming including operations that violate the type system. A package using unsafe must be vetted manually for type safety and may not be portable. The package provides the following interface:

A Pointer is a pointer type but a Pointer value may not be dereferenced . Any pointer or value of core type uintptr can be converted to a type of core type Pointer and vice versa. The effect of converting between Pointer and uintptr is implementation-defined.

The functions Alignof and Sizeof take an expression x of any type and return the alignment or size, respectively, of a hypothetical variable v as if v was declared via var v = x .

The function Offsetof takes a (possibly parenthesized) selector s.f , denoting a field f of the struct denoted by s or *s , and returns the field offset in bytes relative to the struct's address. If f is an embedded field , it must be reachable without pointer indirections through fields of the struct. For a struct s with field f :

Computer architectures may require memory addresses to be aligned ; that is, for addresses of a variable to be a multiple of a factor, the variable's type's alignment . The function Alignof takes an expression denoting a variable of any type and returns the alignment of the (type of the) variable in bytes. For a variable x :

A (variable of) type T has variable size if T is a type parameter , or if it is an array or struct type containing elements or fields of variable size. Otherwise the size is constant . Calls to Alignof , Offsetof , and Sizeof are compile-time constant expressions of type uintptr if their arguments (or the struct s in the selector expression s.f for Offsetof ) are types of constant size.

The function Add adds len to ptr and returns the updated pointer unsafe.Pointer(uintptr(ptr) + uintptr(len)) [ Go 1.17 ]. The len argument must be of integer type or an untyped constant . A constant len argument must be representable by a value of type int ; if it is an untyped constant it is given type int . The rules for valid uses of Pointer still apply.

The function Slice returns a slice whose underlying array starts at ptr and whose length and capacity are len . Slice(ptr, len) is equivalent to

except that, as a special case, if ptr is nil and len is zero, Slice returns nil [ Go 1.17 ].

The len argument must be of integer type or an untyped constant . A constant len argument must be non-negative and representable by a value of type int ; if it is an untyped constant it is given type int . At run time, if len is negative, or if ptr is nil and len is not zero, a run-time panic occurs [ Go 1.17 ].

The function SliceData returns a pointer to the underlying array of the slice argument. If the slice's capacity cap(slice) is not zero, that pointer is &slice[:1][0] . If slice is nil , the result is nil . Otherwise it is a non- nil pointer to an unspecified memory address [ Go 1.20 ].

The function String returns a string value whose underlying bytes start at ptr and whose length is len . The same requirements apply to the ptr and len argument as in the function Slice . If len is zero, the result is the empty string "" . Since Go strings are immutable, the bytes passed to String must not be modified afterwards. [ Go 1.20 ]

The function StringData returns a pointer to the underlying bytes of the str argument. For an empty string the return value is unspecified, and may be nil . Since Go strings are immutable, the bytes returned by StringData must not be modified [ Go 1.20 ].

Size and alignment guarantees

For the numeric types , the following sizes are guaranteed:

The following minimal alignment properties are guaranteed:

• For a variable x of any type: unsafe.Alignof(x) is at least 1.
• For a variable x of struct type: unsafe.Alignof(x) is the largest of all the values unsafe.Alignof(x.f) for each field f of x , but at least 1.
• For a variable x of array type: unsafe.Alignof(x) is the same as the alignment of a variable of the array's element type.

A struct or array type has size zero if it contains no fields (or elements, respectively) that have a size greater than zero. Two distinct zero-size variables may have the same address in memory.

Language versions

The Go 1 compatibility guarantee ensures that programs written to the Go 1 specification will continue to compile and run correctly, unchanged, over the lifetime of that specification. More generally, as adjustments are made and features added to the language, the compatibility guarantee ensures that a Go program that works with a specific Go language version will continue to work with any subsequent version.

For instance, the ability to use the prefix 0b for binary integer literals was introduced with Go 1.13, indicated by [ Go 1.13 ] in the section on integer literals . Source code containing an integer literal such as 0b1011 will be rejected if the implied or required language version used by the compiler is older than Go 1.13.

The following table describes the minimum language version required for features introduced after Go 1.

• An alias declaration may be used to declare an alias name for a type.
• Integer literals may use the prefixes 0b , 0B , 0o , and 0O for binary, and octal literals, respectively.
• Hexadecimal floating-point literals may be written using the prefixes 0x and 0X .
• The imaginary suffix i may be used with any (binary, decimal, hexadecimal) integer or floating-point literal, not just decimal literals.
• The digits of any number literal may be separated (grouped) using underscores _ .
• The shift count in a shift operation may be a signed integer type.
• Emdedding a method more than once through different embedded interfaces is not an error.
• A slice may be converted to an array pointer if the slice and array element types match, and the array is not longer than the slice.
• The built-in package unsafe includes the new functions Add and Slice .

The 1.18 release adds polymorphic functions and types ("generics") to the language. Specifically:

• The set of operators and punctuation includes the new token ~ .
• Function and type declarations may declare type parameters .
• Interface types may embed arbitrary types (not just type names of interfaces) as well as union and ~T type elements.
• The set of predeclared types includes the new types any and comparable .
• A slice may be converted to an array if the slice and array element types match and the array is not longer than the slice.
• The built-in package unsafe includes the new functions SliceData , String , and StringData .
• Comparable types (such as ordinary interfaces) may satisfy comparable constraints, even if the type arguments are not strictly comparable.
• The set of predeclared functions includes the new functions min , max , and clear .
• Type inference uses the types of interface methods for inference. It also infers type arguments for generic functions assigned to variables or passed as arguments to other (possibly generic) functions.
• In a "for" statement , each iteration has its own set of iteration variables rather than sharing the same variables in each iteration.
• A "for" statement with "range" clause may iterate over integer values from zero to an upper limit.

Type unification rules

The type unification rules describe if and how two types unify. The precise details are relevant for Go implementations, affect the specifics of error messages (such as whether a compiler reports a type inference or other error), and may explain why type inference fails in unusual code situations. But by and large these rules can be ignored when writing Go code: type inference is designed to mostly "work as expected", and the unification rules are fine-tuned accordingly.

Type unification is controlled by a matching mode , which may be exact or loose . As unification recursively descends a composite type structure, the matching mode used for elements of the type, the element matching mode , remains the same as the matching mode except when two types are unified for assignability ( ≡ A ): in this case, the matching mode is loose at the top level but then changes to exact for element types, reflecting the fact that types don't have to be identical to be assignable.

Two types that are not bound type parameters unify exactly if any of following conditions is true:

• Both types are identical .
• Both types have identical structure and their element types unify exactly.
• Exactly one type is an unbound type parameter with a core type , and that core type unifies with the other type per the unification rules for ≡ A (loose unification at the top level and exact unification for element types).

If both types are bound type parameters, they unify per the given matching modes if:

• Both type parameters are identical.
• At most one of the type parameters has a known type argument. In this case, the type parameters are joined : they both stand for the same type argument. If neither type parameter has a known type argument yet, a future type argument inferred for one the type parameters is simultaneously inferred for both of them.
• Both type parameters have a known type argument and the type arguments unify per the given matching modes.

A single bound type parameter P and another type T unify per the given matching modes if:

• P doesn't have a known type argument. In this case, T is inferred as the type argument for P .
• Both A and T are interface types: In this case, if both A and T are also defined types, they must be identical . Otherwise, if neither of them is a defined type, they must have the same number of methods (unification of A and T already established that the methods match).
• Neither A nor T are interface types: In this case, if T is a defined type, T replaces A as the inferred type argument for P .

Finally, two types that are not bound type parameters unify loosely (and per the element matching mode) if:

• Both types unify exactly.
• One type is a defined type , the other type is a type literal, but not an interface, and their underlying types unify per the element matching mode.
• Both types are interfaces (but not type parameters) with identical type terms , both or neither embed the predeclared type comparable , corresponding method types unify exactly, and the method set of one of the interfaces is a subset of the method set of the other interface.
• Only one type is an interface (but not a type parameter), corresponding methods of the two types unify per the element matching mode, and the method set of the interface is a subset of the method set of the other type.
• Both types have the same structure and their element types unify per the element matching mode.

Should you give job applicants an assignment during the interview process? Be thoughtful about the ask

Hiring is a time-consuming and expensive endeavor. Companies need candidates who offer the right skills and experience for a given role, and who align with their organization’s vision and mission.

To find the best fit, many companies still lean on a strategy that continues to generate debate : the assignment. Some candidates believe their experience and interviews should give prospective employers enough information to determine whether they will fit the role. Employers have to ask themselves whether they are willing to turn off a strong candidate by asking them to do additional work.

Is the assignment valuable enough to the evaluation process that they cannot move someone forward without it? Sometimes it is—sometimes they help an employer decide between two strong candidates. And if they are necessary, how can employers make assignments fair and equitable for the candidate or candidates?

When done right, assignments help assess practical skills and problem-solving abilities, giving a clearer picture of a candidate beyond what their resume or interview reveals. But employers should be thoughtful about the ask. While it may make sense for roles that require specific technical expertise or creative thinking, it isn’t appropriate for all roles—so assignments should always be given with a clear reason for why they are needed.

Plus, they don’t just benefit the employer. For job seekers, an assignment during the interview process might also help them stand out from the competition. It can also offer a window into what their day-to-day in the new role might entail. Remember that the candidate should be interviewing the company, too. Having a test run of the work they’d be asked to do is a great way to see whether they believe the role is a fit.

However, there is a rift in how people perceive the assignment as part of the interview process. Workers today span many generations, each with unique values and expectations. Whereas older workers often prioritize stability and loyalty, younger millennials and Gen Zers are more focused on flexibility and work well-being, Indeed data shows .

This mindset impacts the amount of time and energy a candidate is willing to devote to each application. After multiple rounds of interviews and prep, taking on an in-depth assignment may feel like a bridge too far—especially if the expectations for the assignment are not clearly communicated ahead of time.

Some candidates are wary of providing free labor to a company that may use their work and not hire them. Hiring managers should be clear about how the work will be used. They may also consider offering compensation if the assignment requires more than a couple hours of someone’s time, or if they plan to use the work without hiring the candidate.

The key for early career candidates in particular is to ensure their time and efforts are respected. This is a win-win for employers: By providing clarity and transparency, they not only elicit the additional information they want from candidates, but they demonstrate that the organization is transparent and fair.

Equity is also imperative: Which candidates are being asked to complete assignments? Is the hiring team consistent in giving out assignments across ages, experience levels, and roles? There should always be a process and clear evaluation criteria in place to ensure fairness.

As we adapt to the rapidly evolving world of work, we must continue to think critically about each step in the hiring process. Candidate assignments can be a valuable tool, but only with appropriate respect for job seekers’ time and contributions.

With the right strategy, we can bridge the gap between generations in the workplace and build a hiring culture that values efficiency, talent, and integrity.

Eoin Driver is the global vice president of talent at Indeed.

More must-read commentary:

• Fannie Mae  CEO: Beyoncé is right. Climate change has already hit the housing market—and  homeowners aren’t prepared

Congress could soon spell the end of employment arbitration—but it’s not all good news for American workers

• Outdated laws prevent gig economy workers from getting benefits. This pilot program shows the path forward
• No, combustion engines won’t be supplanted by electric vehicles—and they’re  critical for sustainable transport

The opinions expressed in Fortune.com commentary pieces are solely the views of their authors and do not necessarily reflect the opinions and beliefs of  Fortune .

Latest in Commentary

Birthing mothers’ near-death experience rates are 100 times higher than maternal mortality—and we don’t even know exactly why

Shark Tank entrepreneur: E-commerce giants are eating my sister’s lunch—and destroying the American Dream

I’m the CTO of Canada’s biggest airport. AI isn’t destroying jobs in aviation—it’s giving us superpowers to improve air travel

Ask Andy: I’m a founder struggling with mental-health issues. How can I step away from my startup?

Most popular.

Meet the boomers who’d rather spend $100k to renovate their homes than risk the frozen housing market: ‘It would be too hard to purchase anything else’

Hedge fund billionaire Ken Griffin says college protests are the result of a ‘cultural revolution’ and Harvard should ’embrace our Western values’

‘Housing has hit rock bottom’: Top real estate CEO says high home prices are shutting people out of the market

Apple cofounder Steve Wozniak was expelled from the school where he just delivered his commencement speech—’be leaders, not followers’

China’s economy is headed for a ‘dead-end,’ and Beijing won’t do anything to stop it, scholar says

Apple is finalizing a deal with OpenAI to put ChatGPT on the iPhone, while talks with Google to use Gemini are ongoing

• Sports Betting
• Sports Entertainment
• New York Yankees
• New York Mets
• Transactions

Recommended

Jasson dominguez starting rehab assignment to set up ‘tough’ yankees decision.

• View Author Archive
• Email the Author
• Get author RSS feed

Contact The Author

Thanks for contacting us. We've received your submission.

Thanks for contacting us. We've received your submission.

ST. PETERSBURG, Fla. — The countdown to the Yankees’ decision on Jasson Dominguez is about to begin.

Dominguez is scheduled to start a rehab assignment on Tuesday or Wednesday with Single-A Tampa, manager Aaron Boone said Saturday.

The 21-year-old outfielder, who has been sidelined since September by Tommy John surgery , will DH for the first two weeks of rehab games before playing in the field.

Once Dominguez starts his rehab assignment, it will officially begin a 20-day clock — assuming he remains healthy and has no setbacks — after which the Yankees will have to either add him to the active roster or option him to the minor leagues.

The Yankees’ starting outfield is currently locked in with Aaron Judge, Juan Soto and Alex Verdugo, while DH Giancarlo Stanton has provided solid production through the first six weeks of the season.

If they all stay healthy over the next month, it would not be surprising to see the Yankees send Dominguez to Triple-A once his rehab assignment is up.

“Hopefully it is a tough decision at that point, because good things are happening here,” manager Aaron Boone said Saturday before the Yankees’ 7-2 loss to the Rays at Tropicana Field. “We’ll cross that bridge when we get there.”

Dominguez crushed his September call-up last season, but it lasted only eight games before he landed on the injured list with a UCL tear that required surgery after posting a .980 OPS with four home runs while starting all eight games in center field.

Before his MLB debut, the top prospect had played just nine career games at Triple-A.

“I always feel like I’ve been one of the high guys on Jasson,” Boone said. “Going back to last spring, I’m like, this guy’s a big-leaguer. There’s no doubt in my mind he’s going to have a really good major league career. … Now, when does that happen? When does he really take off and pop and all that? That always is an unknown and remains to be seen. Everyone’s trajectory is different. But I am confident in the person and the talent.”

Go beyond the box score with the Bombers

Sign up for Inside the Yankees by Greg Joyce, exclusively on Sports+.

Please provide a valid email address.

By clicking above you agree to the Terms of Use and Privacy Policy .

Enjoy this Post Sports+ exclusive newsletter!

Plenty of things could happen before the Yankees have to make a call on Dominguez that could change their plans.

For now, they are just happy that the rehab process to this point has gone as well as could have been expected.

Boone even said that Dominguez is “ready to go” defensively — he was expected to throw to bases for the first time on Saturday at the club’s player development complex — but the Yankees are easing him into action.

“It seems like there’s been very few hiccups along the way,” Boone said. “It’s been smooth, he hasn’t been rushed.”

Share this article:

• Matt Brash Undergoes Tommy John Surgery
• Angels Acquire Luis Guillorme, Transfer Anthony Rendon To 60-Day IL
• Pirates To Promote Paul Skenes
• Shohei Ohtani’s Former Interpreter Pleading Guilty To Multiple Charges
• Reds Re-Sign Mike Ford To Major League Deal
• Rangers Acquire Robbie Grossman, Designate Kolton Ingram
• Hoops Rumors
• Pro Football Rumors
• Pro Hockey Rumors

MLB Trade Rumors

Giants Designate Daulton Jefferies For Assignment

By Steve Adams | May 6, 2024 at 12:00pm CDT

The Giants announced Monday that they’ve designated right-hander Daulton Jefferies for assignment. His spot on the 40-man roster will go to right-handed pitching prospect Mason Black , whose previously reported promotion from Triple-A Sacramento is now official.

Jefferies, 28, went through two years of painstaking rehab to get back to the big leagues after undergoing both Tommy John surgery and thoracic outlet surgery. The former No. 37 overall draft pick’s Giants debut at the end of March was his first MLB appearance since May 2022 with the A’s.

Jefferies shined in spring training this year (2.57 ERA, 16-to-3 K/BB ratio in 14 innings) and has pitched quite well in four Triple-A appearances this season. In 18 1/3 frames with Sacramento, he’s notched a tidy 3.44 ERA while fanning 22.7% of his opponents against a sharp 6.7% walk rate.

However, in a pair of big league appearances, he’s lasted just 4 2/3 innings overall and been tagged for 13 runs (nine earned) on the strength of 14 hits (two homers) and a pair of walks. Jefferies has only fanned four of the 31 men he’s faced. He’s seen more than half the balls in play against him land for hits, which certainly hasn’t helped his cause, but he’s also paid the price for plenty of mistakes over the plate; in addition to the pair of homers, he’s surrendered six doubles and a triple.

Jefferies has had a fair bit of minor league success, but he’s yet to carry it over to the big leagues in a quartet of seasons where he’s seen mostly fleeting action. In 61 MLB frames, he carries an unsightly 6.64 earned run average, although his overall mark in six minor league seasons is nearly half that number, sitting at 3.88. Injuries have played no small part in his struggles; the previously mentioned Tommy John surgery in 2022 was actually the second of his career, and he battled nerve issues in his elbow for nearly a year before finally being diagnosed with thoracic outlet syndrome and undergoing that surgery.

The Giants will have a week to trade Jefferies, attempt to pass him through outright waivers, or release him. He’s in his final minor league option season, so any team that acquires him would be able to send him to Triple-A without needing to expose him to waivers. Jefferies has been outrighted once in the past, so even if he goes unclaimed on waivers, that prior outright assignment grants him the right to reject another outright assignment in favor of free agency.

33 Comments

Good thing they gave up Bart to make room for Jefferies.

Giants don’t need Bart when Reetz is OPSing 5.000 🙂

Bart was a lost cause in SF. He might well still be; time will tell.

He is hitting .200, so he appears to still be lost

Yeah, but .200 on the Pirates will get you a lot of playing time… and to be fair, 3 of his 7 hits are homers.

They were never going to carry three catchers full time

Whoa! didn’t see that coming….Jefferies had a solid 17.36 ERA.and FIP was only 8.30 it shows he played better than ERA suggests.

Someone should take a chance on this guy

Ummm, you mean kinda like the Giants just did? At some point, you are who the back of your baseball card says you are unfortunately.

I got the Blue Jays claiming him

I feel bad for the guy after all he’s been through. Two Tommy John surgeries, plus thoracic outlet surgery. Players seem to have a much lower rate of success after TOS.

@Jean Matrac I think any pitcher who even has TOS surgery is just ending their career. Better off taking a year off of pitching than have a rib removed. Find any other alternative!

Same surgery that doomed Matt Harvey

Wonder if he was named for Dutch Daulton or Dalton from Roadhouse?

Or maybe John Dalton, that guy was pretty cool too….

Don’t know, but I also didn’t know before today that his uncle is former big league reliever Blas Minor.

“The name…. is Dalton”

Now, it’s decision time for the Giants and the rest of the league. Will Jefferies find a new home? Will he be sent to Triple-A purgatory? Or will he take the path less traveled and explore free agency?

Stay tuned for the next episode of “Baseball’s Got Talent” as we witness the highs, lows, and curveballs of the MLB roster game. ⚾

Astros? Can’t be worse than Brown/Abreu/Hader/Pressly/Bielak/France/Urquidy

The next ones to be sent packing should be: Slater Flores Yaz Chapman Ahmed Murphy Hjelle Zaidi

Yaz and Chapman still have value, albeit replacement value and not much more. It feels too early to call it on Chapman, though, who is better than he has played so far.

I notice you didn’t include Soler on your list. His performance has been pretty underwhelming, too, especially given his salary. I hope he can start hitting dingers when there are guys on base.

Oops, just forgot Soler. He should be the 2nd one gone after Slater.

Flores has value especially at his price point of 6.5M (and player opt-out in 2025 option) his previous years show decent numbers with power potential more than Yaz.

Yaz is a declining value last few years, he has 1 more ARB year but he is getting 7.9M this year, and is not living up to it. since 2021 Yaz is sloping downwards and teams know this so there will be very little in return for him, he is more valuable to Giants than any other team.

All others on the list have little value in trade unless added as a complementary item.

Chapman is going no where. Murphy has nice track record and injured now, he has possibility to turn it around. inexpensive player – there is no C in system that could replace – Sabol is nice but Murphy is more value than him.

Datashark, Yastrzemski is one of the few Giants’ players that has been producing. As I responded to @TellItGoodbye, Yaz has a .927 OPS over the last 14 games.

sure right now, but lets look at bigger picture.

Yes, the bigger picture needs to be looked at, and things might look differently a few months from now. But these posts seem to be all about what these guys have done this season.

The season so far is still a small sample. So if someone is in favor of cutting loose guys like Flores and Yastrzemski, based on a small sample, then it has to cut both ways. And so far all we have is small samples.

But it’s not a small sample. Yaz has been going downhill and getting injured. I love Wilmer, and he’s cheap, I just wish we could find more exciting players who can actually steal a base.

The Giants have played 36 games. That is a small sample.

This is exactly what I’m talking about. Flores has value. Murphy has a good track record. Chapman is better than this. On and on. Meanwhile we’re sinking fast. All those players are past their prime and slow. Maybe Chapman just doesn’t have it anymore. The game has sped up. It was so painfully obvious playing the Phillies. We were like an over-50 men’s league compared to them. It’s not just age, it’s excitement for the game. Compare Brandon Marsh to Wilmer or Yaz. It’s like our guys are just going through the motions. We need speed and youth. There’s exactly one exciting position player on our team – Jung Hoo Lee, and he’s still adjusting.

Trade values on all those players listed is in the Sell low point, but outside of Murphy, and Flores they are pretty much going to stay around this point.

Chapman is untradeable so that is not even a question to send packing.

The question is WHEN would be the best time to ship those players off or cut bait — being the farm system is still not showing players that can make an impact they are stuck and have been for many years now. Sure they have had diamonds or even cubic zirconia’s but other teams are doing laps around them.

Webb is the best player on team but I have seen him on the mound being more frustrated than previous years..

@Tellit Wow! That kind of managerial acumen is going to be the death of your lemonade stand!

Hey, I’m allowed to be grumpy after that series in Philly!! Go Giants!!

Was time to DFA Jefferies. Hopefully Black can add a much needed spark.

Zaidi is reaching a critical point where tough decisions have to be made to turn the Giants season around. Giants must have a winning record each month to have any chance of making the playoffs.

Giants not making playoffs will surely be Zaidi’s demise

TellItGoodbye, Since 4/18, 14 games, Yastrzemski has a .927 OPS. Yet Conforto isn’t on your list, and over that same span he has a .585 OPS. What a brilliant roster management suggestion.

Why pick from that arbitrary date? On the season Conforto is 100 pts better OPS.

It’s not arbitrary. It’s the last 2 weeks worth of games, and it illustrates how players are trending. Yastrzemski is trending up, Conforto is trending down. Looking at the season’s numbers doesn’t tell you much. Especially if one player gets off to a slow start, and the other a hot one.

Conforto only has better numbers on the season because he got off to a hot start. one week into the season he had a 1.192 OPS. Now it’s .737, a drop of 455 points. Yaz went from .273 to .630, a rise of 357 points.

Leave a Reply Cancel reply

Please login to leave a reply.

Log in Register

• Feeds by Team
• Commenting Policy
• Privacy Policy

MLB Trade Rumors is not affiliated with Major League Baseball, MLB or MLB.com

Username or Email Address

Remember Me

To please Putin, universities purge liberals and embrace patriots

Russian university leaders are imbuing the country’s education system with patriotism to favor Putin, quashing Western influences and dissent.

Two weeks before the start of his 25th year as Russia’s supreme political leader, Vladimir Putin made a sweeping proclamation: “Wars are won by teachers.”

The remark, which Putin repeated twice during his year-end news conference in December, shed light on a campaign he is waging that has received little attention outside wartime Russia: to imbue the country’s education system with patriotism, purge universities of Western influences, and quash any dissent among professors and students on campuses that are often hotbeds of political activism.

At St. Petersburg State University, this meant dismantling a prestigious humanities program called the Faculty of Liberal Arts and Sciences. For more than a decade, until May 2022, the faculty — or college — was led by Alexei Kudrin, a liberal economist and former finance minister who had been a close associate of Putin’s since the early 1990s, when they were deputy mayors together in St. Petersburg.

“We had many classes on U.S. history, American political life, democracy and political thought, as well as courses on Russian history and political science, history of U.S.-Russian relations, and even a course titled ‘The ABCs of War: Causes, Effects, Consequences,’” said a student at the faculty, also known as Smolny College. “They are all gone now,” the student said, speaking on the condition of anonymity for fear of retribution.

About this series

In a radical reshaping of Russia’s education system, curriculums are being redrawn to stress patriotism and textbooks rewritten to belittle Ukraine, glorify Russia and whitewash the totalitarian Soviet past. These changes — the most sweeping to schooling in Russia since the 1930s — are a core part of Putin’s effort to harness the war in Ukraine to remaster his country as a regressive, militarized state.

Since the February 2022 invasion of Ukraine, leaders of Russian universities, which are overwhelmingly funded by the state, have zealously adopted the Kremlin’s intolerance of any dissent or self-organization, according to an extensive examination by The Washington Post of events on campuses across Russia, including interviews with students and professors both still in the country and in exile.

Professors who spoke out against the war, or allowed safe spaces for students to question it, have been fired. Students who picketed or posted on social media for peace were expelled.

Meanwhile, those who volunteer to fight in Ukraine have been celebrated in line with Putin’s promises that war heroes and their descendants will become the new Russian elite, with enhanced social benefits, including special preference for children seeking to enter top academic programs. Normally, such programs require near-perfect grades and high scores on competitive exams — uniform standards that applicants from all societal backgrounds have relied on for decades.

And the most fundamental precept of academic life — the freedom to think independently, to challenge conventional assumptions and pursue new, bold ideas — has been eroded by edicts that classrooms become echo chambers of the authoritarian nativism and historical distortions that Putin uses to justify his war and his will.

As a result, a system of higher learning that once was a beacon for students across the developing world is now shutting itself off from peer academies in the West, severing one of the few ties that had survived years of political turbulence. Freedom of thought is being trampled, if not eradicated. Eminent scholars have fled for positions abroad, while others said in interviews that they are planning to do so.

At the Russian State University for the Humanities in Moscow, officials last July created the Ivan Ilyin Higher Political School, which is now being led by Alexander Dugin, a fervent pro-Putin and Orthodox Christian ideologue who was tasked with “revising domestic scientific and educational paradigms and bringing them into line with our traditional Russian spiritual and moral values.”

“There has been a catastrophic degradation in Western humanitarian history,” Dugin said at a January seminar on transforming Russian humanities education. “This is evidenced by gender problems, postmodernism and ultraliberalism. We can study the West, but not as the ultimate universal truth. We need to focus on our own Russian development model.”

How we reported ‘Russia, Remastered’

Last month, students pushed an online petition to protest the naming of the school after Ilyin, a philosopher who defended Hitler and Mussolini in World War II and advocated for the return of czarist autocracy in Russia. In a statement to Tass, the state-controlled news service, the university denounced the petition as “part of the information war of the West and its supporters against Russia” and asserted, without providing evidence, that the group behind it had no connection to students at the school.

Programs specializing in the liberal arts and sciences are primary targets because they are viewed as breeding grounds for dissent. Major universities have cut the hours spent studying Western governments, human rights and international law, and even the English language.

“We were destroyed,” said Denis Skopin, a philosophy professor at Smolny College who was fired for criticizing the war. “Because the last thing people who run universities need are unreliable actors who do the ‘wrong’ thing, think in a different way, and teach their students to do the same.”

The demise of

Smolny College

The demise of Smolny College

St. Petersburg State University, commonly known as SPbU, has long been one of Russia’s premier academies of higher learning. It is the alma mater of both Putin, who graduated with a degree in law in 1975, and former president Dmitry Medvedev, who received his law degree 12 years later and now routinely threatens nuclear strikes on the West as deputy chairman of Russia’s national security council.

In many ways, the university has become the leader in reprisals against students and staff not loyal to the Kremlin, with one newspaper dubbing it the “repressions champion” of Russian education. Its halls have become a microcosm of modern Russia in which conservatives in power are pushing out the few remaining Western-oriented liberals.

Like other aspects of Putin’s remastering of Russia — such as patriotic mandates in the arts and the redrawing of the role of women to focus on childbearing — the shift in education started well before the invasion of Ukraine. In 2021, Russia ended a more than 20-year-old exchange program between Smolny College and Bard College in New York state by designating the private American liberal arts school an “undesirable” organization.

Jonathan Becker, Bard’s vice president for academic affairs and a professor of political studies, said the demise of Smolny was emblematic of a wider shift in Russia as well as a new intolerance of the West.

“A huge number of faculty have been let go, several departments closed, core liberal arts programs which focus on critical thinking have been eliminated,” Becker said. “All of that has happened, and it’s not just happened at Smolny — it has happened elsewhere. But we were doubly problematic because we both represent critical thinking and partnership with the West. And neither of those are acceptable in present-day Russia.”

In October 2022, in a scene captured on video and posted on social media, dozens of students gathered in a courtyard to bid a tearful goodbye to Skopin, Smolny’s cherished philosophy professor who was fired for an “immoral act” — protesting Putin’s announcement of a partial military mobilization to replenish his depleted forces in Ukraine.

The month before, according to court records and interviews, Skopin was arrested at an antiwar rally. He ended up sharing a jail cell with another professor, Artem Kalmykov, a young mathematician who had recently finished his PhD at the University of Zurich.

That fall, the university launched an overhaul that all but shut Smolny College and replaced the curriculum with a thoroughly revamped arts and humanities program.

The dismantling of Smolny marked the resolution of a years-long feud between Kudrin, the liberal-economist dean, and Nikolai Kropachev, the university rector, whom tutors and students described as a volatile character with a passion for building ties in the highest echelons of the government.

It’s hard to describe the insane level of anxiety the students felt at the start of the invasion, and I’d say 99 percent of them were against it.”

Denis Skopin

Former philosophy professor at Smolny College

It’s hard to describe the insane level of anxiety the students felt at the start of the invasion, and I’d say

99 percent of them were against it.”

It’s hard to describe the insane level

of anxiety the students felt at the start

of the invasion, and I’d say 99 percent

of them were against it.”

It’s hard to describe the insane level of anxiety

the students felt at the start of the invasion,

and I’d say 99 percent of them were against it.”

In February, Sergei Naryshkin, the head of Russia’s Foreign Intelligence Service, sent a heartfelt birthday message to Kropachev, thanking him for his “civic and political activity” and for “comprehensive assistance in replenishing personnel.”

One student described how Kropachev once interrupted a meeting with students and hinted that he needed to take a call from Putin, in what the student viewed as a boast of his direct access to the Russian leader. Both St. Petersburg State University and Moscow State University were assigned a special status in 2009, under which their rectors are appointed personally by the president.

Skopin, who earned his PhD in France, and his cellmate, Kalmykov, were perfect examples of the type of academic that Russia aspired to attract from the early 2000s to the mid-2010s — enticed after studying abroad to bring knowledge home amid booming investment in higher education. But by 2022, the system seemed to have no need for them.

Video of the gathering in the courtyard shows students erupting in sustained applause, and one student coming forward to hug Skopin.

“It’s hard to describe the insane level of anxiety the students felt at the start of the invasion, and I’d say 99 percent of them were against it,” Skopin said.

After his dismissal, some students tried to fight the administration’s plan to dismantle the Smolny program.

“At one point we found ourselves in a situation where out of 30 original faculty staff, we had just three tutors left,” said Polina Ulanovskaya, a sociology student and activist who led the student union. “And the quality of education definitely suffered, especially all of the politics-related classes.”

Ulanovskaya said that on the political science track, only two professors have stayed, and many classes were eliminated, including a human rights course. There are now just two courses offered in English, down from 21.

With every new professor, Ulanovskaya said, she felt a need to test the waters. Would the word “gender” trigger them? Could she say something opposition-leaning? What would be a red flag?

Ulanovskaya opted out of writing a thesis on her main research topic — Russian social movements, politicization of workers and historic-preservation activists — out of fear that it would be blacklisted. Instead, she wrote about Uruguay.

“The main problem at the faculty now is that there is no freedom and especially no sense of security,” she said. “I guess there is no such thing anywhere in Russia now ... you can’t trust anyone in any university.”

A few weeks after The Post interviewed Ulanovskaya last fall, she was expelled, formally for failing an exam, but she and Skopin said they believe it was retaliation for her activism.

Another student, Yelizaveta Antonova, was supposed to get her bachelor’s degree in journalism just days after legendary Novaya Gazeta newspaper reporter Yelena Milashina was brutally beaten in Chechnya, the small Muslim-majority republic in southern Russia under the dictatorial rule of Ramzan Kadyrov.

Antonova, who interned at Novaya Gazeta and looked up to Milashina, felt she could not accept her diploma without showing support for her colleague. She and a roommate printed a photo of Milashina, depicting the reporter’s shaved head and bandaged hands, to stage a demonstration at their graduation ceremony — much to the dismay of other classmates, who sought to block the protest.

“They essentially prevented us from going on stage,” Antonova said. “So we did it outside of the law school, and we felt it was extra symbolic because Putin and Medvedev studied in these halls.”

They held up the poster for about half an hour, until another student threatened them by saying riot police were on the way to arrest them. Antonova believes the protest cost her a spot in graduate school, where she hoped to continue her research comparing Russia’s media landscape before and after the invasion.

Eight months after the graduation ceremony, authorities launched a case against Antonova and her roommate for staging an unauthorized demonstration — an administrative offense that is punishable by a fine and puts people on law enforcement’s radar. Antonova left the country to continue her studies abroad.

Ideological divides

The history college at St. Petersburg State has long been a battleground for various ideologies, with cliques ranging from conservatives and Kremlin loyalists to unyielding opposition-minded liberals, according to interviews with students and professors.

The February 2022 invasion of Ukraine caused a deeper split. Some students and professors openly praised Putin’s “special military operation,” as the Kremlin called the war, while others joined rallies against it.

“The war gave them carte blanche,” said Michael Martin, 22, a former star at the college — to which he was automatically admitted after winning two nationwide academic competitions and where he earned straight A’s.

Martin was a leader of the student council, which on the day of the invasion issued an antiwar manifesto quickly drafted in a cafe.

Another history student, Fedor Solomonov, took the opposite view and praised the special military operation on social media. When Solomonov was called up as part of the mobilization, he declined to take a student deferral and went to fight. He died on the front on April 1, 2023.

Soon after Solomonov’s death, screenshots from internal chats where students often debated history and politics were leaked and went viral on pro-war Telegram channels. In some, Martin and other classmates expressed antiwar sentiments, while another showed a message — allegedly written by an assistant professor, Mikhail Belousov — vaguely describing events in Ukraine as “Rashism,” a wordplay combining “Russia” and “fascism.”

In an aggressive online campaign, pro-war activists demanded that Belousov, who denied writing the message, be fired and that the antiwar students, whom they labeled “a pro-Ukrainian organized crime group,” be expelled.

“A cell of anti-Russian students led by a Russophobe associate professor is operating at the history faculty,” read posts on Readovka, a radical outlet with 2.5 million followers. “They are rabid liberals who hate their country.” Belousov was dismissed and seven students, including Martin, were accused of desecrating Solomonov’s memory and expelled.

Belousov has gone underground and could not be reached for comment.

“They essentially tried to make me do the Sieg Heil,” Martin said, recalling the expulsion hearing, where he said the committee repeatedly asked leading questions trying to get him to say the war was justified. The committee also asked him repeatedly about Solomonov.

“I said he was for the war and I was against it — we could argue about that,” Martin said. “I didn’t find anything funny or interesting in this — I’m truly sorry for what happened to him, but at the same time, I don’t think that he did something good or great by going to war.”

Martin said that as the war raged on, the university began “glorifying death” and praising alumni who had joined the military.

This narrative also warped the curriculum.

A few weeks into the invasion, the school introduced a class on modern Ukrainian history, with a course description asserting that Ukrainian statehood is based “on a certain mythology.”

They essentially tried to make me do the Sieg Heil.”

Michael Martin

Former student at St. Petersburg State University

Belousov, the former assistant professor, criticized a course titled “The Great Patriotic War: No Statute of Limitations,” taught by an instructor with a degree in library science. The key message of the course is that the Soviet Union had no role in the start of World War II — a denial of Russia’s joint invasion of Poland with Nazi Germany in 1939.

According to a government document reviewed by The Post, Russia’s Higher Education Ministry plans to introduce this course at other universities to ensure the “civic-patriotic and spiritual-moral education of youth,” specifically future lawyers, teachers and historians, and to “correct false ideas.”

“These are obviously propaganda courses that are aimed at turning historians into court apologists,” Martin said.

Martin was expelled days before he was supposed to defend his thesis. He quickly left the country after warnings that he and his classmates could be charged with discrediting the army, a crime punishable by up to 15 years in prison. A criminal case was initiated against Belousov on charges of rehabilitating Nazism.

“This is all very reminiscent of the Stalinist 1930s purges,” Martin said. “The limit of tolerated protest now is to sit silently and say nothing. There is despair at the faculty and a feeling that they have crushed everything.”

New Russian elite

To lure more Russian men to fight in Ukraine, the government has promised their families various sweeteners, including cheap mortgages, large life insurance payments and education benefits for their children.

In 2022, Putin approved changes to education laws to grant children of soldiers who fought in Ukraine admissions preferences at Russia’s best universities — schools that normally accept only students with near-perfect exam scores and impressive high school records.

Now, at least 10 percent of all fully funded university spots must be allocated to students eligible for the military preference. Those whose fathers were killed or wounded do not need to pass entry exams.

The new law solidified a previous Putin decree that gave special preferences to soldiers and their children. In the 2023-24 academic year, about 8,500 students were enrolled based on these preferences, government officials said. According to an investigation by the Russian-language outlet Important Stories, nearly 900 students were admitted to 13 top universities through war quotas, with most failing to meet the normal exam score threshold.

In areas of Ukraine captured by Russian forces since February 2022, a different takeover of the education system is underway, with Moscow imposing its curriculum and standards just as it did after invading and illegally annexing Crimea in 2014.

For the 2023-24 academic year, according to the Russian prime minister’s office, more than 5 percent of fully state-financed tuition stipends — roughly 37,000 out of 626,000 — were allocated for students at universities in Donetsk, Luhansk, Kherson or Zaporizhzhia, the four occupied or partly occupied areas of Ukraine that Putin has claimed to be annexed.

The relatively large allocation of tuition aid in occupied areas shows how financial assistance and education are central to Putin’s effort to seize lands in southeast Ukraine and absorb its population into Russia in violation of international law.

Deans of several leading Russian universities have made highly publicized trips to occupied Ukraine to urge students there to enroll into Russian schools, part of a multipronged effort to bring residents into Moscow’s orbit.

The Moscow-based Higher School of Economics, once considered Russia’s most liberal university, recently established patronage over universities in Luhansk, with Rector Nikita Anisimov often traveling there.

An inward turn

A few weeks after the invasion started, Moscow abandoned the Bologna Process , a pan-European effort to align higher education standards, as Russia’s deans and rectors strove to show they weren’t susceptible to foreign influence.

Higher Education Minister Valery Falkov said Russian universities would undergo significant changes in the next half-decade, overseen by the national program “Priority 2030,” which envisions curriculums that ensure “formation of a patriotic worldview in young people.”

Soon after Russia quit the Bologna Process, Smolny College was targeted for overhaul.

“The decision was an expected but distinct shift from the more liberal model of Russian higher education policy that emerged after the collapse of the Soviet Union,” said Victoria Pardini, a program associate at the Kennan Institute, a Washington think tank focused on Russia.

Another prestigious school, the Russian Presidential Academy of National Economy and Public Administration, canceled its liberal arts program in 2022 after authorities accused it of “destroying national values.”

In mid-October 2023, the Higher Education Ministry ordered universities to avoid open discussion of “negative political, economic and social trends,” according to a publicly disclosed report by British intelligence. “In the longer term, this will likely further the trend of Russian policymaking taking place in an echo-chamber,” the report concluded.

Russia’s position among

countries by number of

scholarly papers published

Source: Institute for Statistical Studies and Economics

of Knowledge

Russia’s position among countries by

number of scholarly papers published

Source: Institute for Statistical Studies and Economics of Knowledge

Russia’s position among countries by number of

Many international exchange programs have been canceled — some because Russian students now have difficulty obtaining visas. Still, a heavy brain drain is underway. “All those who could — they left the country,” Skopin said of his students. “Those who can’t are thrashing around as if they are in a cage.”

Martin is among those who got out — he was recently accepted into a prestigious master’s program abroad and plans to continue his research into 19th-century Australian federalism.

Skopin now teaches in Berlin and is a member of Smolny Beyond Borders, an education program that seeks funding to cover the tuition of students who leave Russia because of their political views. As of late 2023, an estimated 700 students were enrolled.

• Help Center
• Assignments
• Privacy Policy
• Terms of Service
• Submit feedback

Open an assignment

You open an assignment link from your learning management system (LMS).

• Go to your LMS.

• Click the assignment link. 

Need more help?

Try these next steps:.

This is a site about the books and other writing by James Rodgers, author of Assignment Moscow: Reporting on Russia From Lenin to Putin ( new edition 2023 ; first published July 2020); Headlines from the Holy Land (2015 and 2017); No Road Home: Fighting for Land and Faith in Gaza (2013); Reporting Conflict (2012). My work looks at how stories of international affairs, especially armed conflict, are told to the world.

I am an author and journalist. During two decades of covering international news, I reported on the end of the Soviet Union; the wars in Chechnya; the coming to power of Vladimir Putin; 9/11; the Israeli-Palestinian conflict; the 2003 war in Iraq; Russia’s war with Georgia in 2008. I completed correspondent postings for the BBC in Moscow, Brussels, and Gaza. I now teach in the Journalism Department at City, University of London.

Now Out: Assignment Moscow ‘Beautifully written, fascinating throughout’

MY NEW BOOK , Assignment Moscow: Reporting on Russia from Lenin to Putin has now been published in the U.S. and the U.K.

You can order copies, and read more about the book, here for the U.K, edition ( here for the U.S. edition).

These are the reviews so far

“Reporting from Russia has never been easy; Rodgers vividly captures the changing fortunes of Moscow correspondents over the past hundred years, as they penetrated the mysteries of life in Russia and brought them to our newspapers and screens. Some were duped, some were fellow-travellers or spies; most battled against censors and blank-faced politicians; all have helped to shape our understanding of the world’s biggest country.” –  Angus Roxburgh, former Moscow correspondent for the BBC, Sunday Times and Economist

“Writing about journalism in Russia since the revolution, James Rodgers rightly emphasises that to understand Russia you have to talk to people of all kinds. But he argues that even correspondents who knew the language and the history found it hard to report dispassionately because of official obstruction and their own emotional involvement.” –  Rodric Braithwaite

“A highly original, engrossing and accessible book, Assignment Moscow stands out among journalistic accounts of Russia for its subtlety, humility and historic scope. It tells the story of British and American journalists who aimed to throw light on Russia from Lenin to Putin, and in the process illuminated the West itself.” –  Arkady Ostrovsky, Author of The Invention of Russia: The Rise of Putin and the age of Fake News, Winner of the 2016 Orwell Prize

“It is hard to believe that in the torrent of books published on Russia each year, that one could come along as original and valuable as Assignment Moscow. One comes to appreciate the service of our reporting men and women in Moscow. For all their fallibilities, without their dedication, we wouldn’t have half the understanding of Russia that we have today, imperfect as it will always be. We therefore owe them – and especially Rodgers as journalist, teacher, analyst and cataloguer – a huge debt.” –  James Nixey, Chatham House

I was also delighted to get this endorsement on Twitter from Peter Frankopan, Professor of Global History at the University of Oxford, and author of The Silk Roads and The New Silk Roads .

Beautifully written, fascinating throughout – and very timely. Happy publication day ⁦ @jmacrodgers ⁩ ! #AssignmentMoscow pic.twitter.com/WY4xlYL6ZR — Peter Frankopan (@peterfrankopan) July 23, 2020

I will be talking about the book at a number of events planned for September onwards. I will share details here when they are available.

I am very happy to talk at book festivals, to universities, think tanks, conferences etc. Please get in touch if you are interested–contact details below, or via the publisher, I.B. Tauris, part of Bloomsbury .

Share this:

• SI SWIMSUIT
• SI SPORTSBOOK

Mets Surprisingly Claim Hard-Throwing Righty After Recently Letting Him Go

Patrick mcavoy | may 7, 2024.

• New York Mets

The New York Mets certainly have been extremely busy this season.

New York has had an up-and-down start to the 2024 season, to say the least. The Mets were 0-5 to begin the season but then turned things around and were red-hot for a stretch. While this is the case, New York has cooled down of late.

The Mets already have been busy while taking a look at the roster although the 2024 season still is somewhat fresh. New York even has been linked to multiple players as possible trade options later this summer.

It seems like the Mets aren't waiting around and are willing to alter the roster in real-time and made yet another move on Monday as the club surprisingly claimed pitcher Yohan Ramirez from the Baltimore Orioles after recently designating him for assignment, according to MLB Trade Rumors' Steve Adams.

"The Mets announced Monday that they’ve claimed right-hander Yohan Ramirez off waivers from the Orioles, who recently designated him for assignment," Deeds said. "In a corresponding move, the Mets designated right-hander Max Kranick for assignment. The move to claim Ramirez comes less than a month after the Mets themselves designated Ramirez for assignment and traded him to Baltimore in exchange for cash. Ramirez is out of minor league options, so he’ll head right to the big league bullpen."

Ramirez has appeared in three games so far this season with New York and allowed seven runs in 5 1/3 innings pitched. He appeared in six games with the Orioles and allowed four earned runs in six innings pitched.

He now will get another opportunity to get on track in New York.

More MLB: Mariners Floated As Possible Trade Option For Mets Star Pete Alonso By Insider

PATRICK MCAVOY

Tuesday, January 5, 2021

Tuple assignments in go.

Apart from the standard way to declare variables , Go offers another way known as tuple assignment. Tuple assignments allow declaring (and assigning) several variables at the same time with the caveat that the expressions on the right are evaluated before any of the variables are updated.

Since tuple assignments are very frequently used in Go, let's see some ways to use it effectively.

Quicker initialization

The first obvious use of tuple assignment is to declare and assign multiple variables at once. The benefits are more readability and less verbosiness. For example:

Variable Swap

Variable swaps are significantly clearer in Go due to this feature. For example, here's how one would swap the values of x an y in Go:

And you could also run operations as needed. For example:

Multiple returned values

Another common use is to capture values returned from a function that returns multiple results. For example, a call to  os.Open :

Similarly, you may be familiar with a similar pattern when using channels:

Or doing type assertion:

On this article we learned about  tuple assignments  in Go, which apart from the  standard way to declare variables , is a very common pattern used in the language .  Tuple assignments allow declaring (and assigning) several variables at the same time with the caveat that the expressions on the right are evaluated before any of the variables are updated.

• Why learn Go
• Your first program in Go
• The main keywords in a Go program
• Variables in Go
• Zero Value in Go
• Constants in Go
• The new function in Go
• Go Operators
• Declaring Types in Go
• Runes in Go

Featured Article

Pointers in go.

Understand all about declaring and using pointers in Go If you're coming from Python, Java, JavaScript, C# and others, tal...

Popular Posts

• Share full article

Advertisement

Supported by

News Analysis

Fresh Off Defeat in Speaker Fight, Greene Relishes the Chaos She Wrought

The hard-right congresswoman from Georgia failed spectacularly in her bid to depose Speaker Mike Johnson. But for a figure who sees her power in creating chaos, the loss was the point.

By Annie Karni

Reporting from the Capitol

As Republicans and Democrats booed her loudly Wednesday when she called a snap vote on the House floor to oust Speaker Mike Johnson, Representative Marjorie Taylor Greene, Republican of Georgia, paused briefly to narrate the drama to viewers back home.

“This is the uniparty, for the American people watching,” Ms. Greene sneered, peering over her glasses at her colleagues like a disappointed schoolteacher.

Ms. Greene went on to take her shot at Mr. Johnson and miss, an outcome that she knew was a certainty. The vote to kill her attempt to remove him was an overwhelming 359 to 43 — with all but 39 Democrats joining Republicans to block her and rescue the G.O.P. speaker.

The move buoyed Mr. Johnson, confirming his status as the leader of an unlikely bipartisan governing coalition in the House that Ms. Greene considers the ultimate enemy. And it isolated Ms. Greene on Capitol Hill, putting her back where she was when she arrived in Washington three years ago: a provocateur and subject of derision who appears to revel in causing huge headaches for her colleagues .

“Hopefully, this is the end of the personality politics and the frivolous character assassination that has defined the 118th Congress,” Mr. Johnson said after the vote.

The word “hopefully” was doing a lot of work.

If Ms. Greene’s goals in Congress were to chair a powerful committee or to build up political capital to drive major policy initiatives — or if she had to worry about drawing a political challenger — this all would constitute a major problem for her. But those have never been the incentives that have driven the gentle lady from Georgia, whose congressional career has been defined by delighting her base and stoking anger on the right more than legislative achievement or political pragmatism.

Ms. Greene hails from a blood-red district where 68 percent of voters supported former President Donald J. Trump in 2020, allowing her to operate with relative impunity in Congress, without fear of a challenge from the right or left. She has further insulated herself politically by donating vast sums to electing Republicans to the House, quietly backing her colleagues even as she picks fights many of them would rather avoid.

So even as it became clear over the last week that she would fail in her quest to depose the speaker, Ms. Greene saw an upside in insisting on the exercise. A vote would offer concrete proof that Mr. Johnson had made himself beholden to the Democrats — a dynamic that has been clear for months as he has partnered with them to pass a host of major bills , including one to send aid to Ukraine — and that many Republicans were going along with what she regarded as a betrayal of the party’s principles.

“I’m thrilled with the whole thing,” Ms. Greene said in an interview on Thursday, sounding upbeat after her spectacular defeat. “Even the booing from both sides — I fully expected it.”

Even if Ms. Greene felt defeated or isolated, she would be exceedingly unlikely to acknowledge it. Her power derives in large part from her irrepressible attitude and her Trumpian instinct to double down rather than retreat in the face of failure.

On Wednesday evening, center-leaning Republicans tried to create as much distance from her as they could, fearful that association with her theatrics would alienate voters in their districts turned off by the seemingly endless chaos in the House.

“All she wants is attention,” said Representative Carlos Gimenez, Republican of Florida. “Today, we shut her down. Our entire conference said, ‘Enough is enough — we don’t need to hear from her anymore.’”

Representative Mike Lawler, Republican of New York, referred repeatedly to Ms. Greene as “Moscow Marjorie” as she dangled her threat to oust the speaker. “Moscow Marjorie has clearly gone off the deep end,” he said on Wednesday.

But if Ms. Greene is now on an island in her party, she hasn’t been there long, and there’s likely a rescue boat en route to bring her back to the mainland. Shortly after arriving in Congress in 2021, she was stripped of her committee assignments by Democrats — 11 Republicans voted with them — and was treated like a pariah by many in Washington. But over the past two years, Ms. Greene has been elevated by her party’s leaders, valued as a top adviser by former Speaker Kevin McCarthy , leaned on as a helpful fund-raiser by vulnerable Republicans and publicly hailed as a dream teammate by center-leaning lawmakers in her party.

“Marjorie Taylor Greene, she is so kind,” Representative Jen Kiggans, a vulnerable Republican from Virginia, said at an event last year before the ouster attempt. “She has been very nice to me.” Of Ms. Greene and other bomb throwers in her party, she said, “I have nothing bad or, you know, different to say about any of these people. They’re on my team, right? They are my teammates. We all want the same things.”

Mr. Trump, who had privately prodded Ms. Greene to move on rather than pursue her vendetta against the speaker and maneuvered to save Mr. Johnson, made it clear she remains on his good side despite ignoring his advice. He waited until the House had turned back her ouster attempt on Wednesday night to post a message on social media urging Republicans to block it. And before he praised Mr. Johnson, he wrote: “I absolutely love Marjorie Taylor Greene. She’s got Spirit, she’s got Fight, and I believe she’ll be around, and on our side, for a long time to come.”

If that’s what abandonment by her party looks like, who needs an embrace?

“He’s not mad at me at all,” Ms. Greene said Thursday of the former president. “I talked to him plenty. He’s proud of me.”

Democrats, for their part, aren’t willing to let Republicans run away from Ms. Greene, the most famous Republican in the House, so quickly.

Missy Cotter Smasal, a Democrat challenging Ms. Kiggans in coastal Virginia, said that “when voters hear her comments calling Marjorie Taylor Greene a teammate, they are astounded and disgusted.”

Even though Ms. Kiggans voted to kill Ms. Greene’s effort on Wednesday night, Ms. Smasal moved quickly to try to use the mutiny attempt as a cudgel against her G.O.P. opponent.

“Jen Kiggans in office enables the chaos of Marjorie Taylor Greene,” she said on Thursday. A spokeswoman for Ms. Kiggans did not respond to a request for comment.

Justin Chermol, a spokesman for the Democratic Congressional Campaign Committee, said: “When the Republicans lose their majority in November, it will be because the so-called moderates let Marjorie Taylor Greene be their party mascot.”

And Representative Hakeem Jeffries, Democrat of New York and the minority leader, wasted little time in sending out a fund-raising email detailing how Ms. Greene “threatened to throw Congress further into chaos, crisis and confusion.”

Ms. Greene laughed off the idea that her actions would help elect Democrats this fall — the argument that everyone from Mr. Trump to Representative Jim Jordan, Republican of Ohio, had used as they tried to discourage her from moving to oust the speaker.

“Republicans will turn out in droves for Trump,” she said. Using an acronym for “Republican in name only,” she continued, “Then they’re going to move down and see that RINO Republican they’ve elected time and time again — who didn’t impeach Biden, who didn’t do anything on the border — they’re going to see that guy and they’re going to cuss him under their breath and skip his name.”

Ms. Greene said Thursday that she didn’t care much whether she was isolated or not.

“If I’m on an island,” she said, “I’m doing exactly what I came here for.”

“I’m very comfortable ebbing and flowing with my party,” she added. “I can be their biggest cheerleader, supporter, defender, donor. I’ve given something like half a million to the National Republican Campaign Committee. I am a team player.”

Over the past two election cycles, Ms. Greene has sent a total of $725,000 to the party’s campaign arm, according to the nonpartisan campaign finance research group Open Secrets, a vast sum for a rank-and-file member like Ms. Greene.

In 2023, Ms. Greene gave the maximum contribution in more than a dozen vulnerable House Republican races, including to colleagues who represent districts President Biden won in 2020, such as Representatives David Schweikert of Arizona and Mike Garcia of California.

On Thursday morning, Ms. Greene made it clear she wasn’t finished tormenting Mr. Johnson just yet.

“Speaker Johnson is the Uniparty Speaker of the House!” she crowed on social media.

Annie Karni is a congressional correspondent for The Times. She writes features and profiles, with a recent focus on House Republican leadership. More about Annie Karni

A Divided Congress: Latest News and Analysis

Marjorie Taylor Greene: The hard-right congresswoman from Georgia failed spectacularly in her bid to depose Speaker Mike Johnson. But for a figure who sees her power in creating chaos, the loss was the point .

Reauthorize FAA and Improve Air Travel: The Senate passed legislation to reauthorize federal aviation programs and put in place new safety measures and consumer protections, at a moment of intense uncertainty  and disruption in the air travel system.

Mike Johnson: The House speaker easily batted down an attempt  by Greene to oust him from his post, after Democrats linked arms with most Republicans  to block the motion.

Antisemitism Hearing: A Republican-led House committee turned its attention to three of the most politically liberal school districts  in the country, accusing them of tolerating antisemitism, but the district leaders pushed back forcefully .

Legalizing Marijuana: Senate Democrats reintroduced broad legislation to legalize cannabis on the federal level, a major policy shift with wide public support , but it is unlikely to be enacted this year ahead of November’s elections and in a divided government.