Type System

Accept interfaces return structs Go functions return interface types holding struct values, not structs directly from interfaces. Common Generics Gotchas and Limitations in Go Go generics require explicit type constraints and careful slice handling to avoid type errors and memory leaks. Common Standard Library Interfaces: io.Reader, io.Writer, fmt.Stringer io.Reader, io.Writer, and fmt.Stringer are standard Go interfaces for reading data, writing data, and custom string formatting. comparable constraint The comparable constraint limits generic type parameters to types that support equality comparison operators like == and !=. Generic data structures Go uses maps, slices, and the container package for data structures, allowing custom generic types via type parameters. Generic functions Generic functions in Go allow writing type-flexible code using type parameters and constraints like cmp.Ordered. Generics vs Interfaces in Go: When to Use Which Use interfaces to define behavior contracts and generics to create type-safe, reusable data structures in Go. Go Data Types Explained: int, float64, string, bool, and More Go data types like int, float64, string, and bool define the kind of value a variable holds and how it is stored in memory. Go Generics Best Practices and Common Patterns Use Go generics with type parameters and constraints to create reusable, type-safe functions and data structures without code duplication. How do generics work in Go Go generics allow writing reusable, type-safe code by defining type parameters that the compiler specializes at compile time. How do interfaces work in Go Go interfaces define method sets that types implicitly satisfy, enabling flexible and type-safe polymorphism. How Go Implements Interfaces Internally (itab) Go uses an `itab` structure to map interface methods to concrete type implementations for dynamic dispatch. How Interfaces Are Represented Internally in Go (iface and eface) Go uses `eface` for empty interfaces and `iface` for non-empty ones, differing by the presence of an `itab` for method resolution. How to Add Methods to Built-In Types in Go You cannot add methods directly to built-in types like `int`, `string`, or `bool` in Go because the language only allows method receivers on types defined within the same package. How to Check If a Value Implements an Interface in Go You cannot directly check if a specific value implements an interface at compile time, but you can verify it at runtime using a type assertion or by assigning the value to a variable of the interface type. How to check if value implements interface Use a type assertion or a type switch to check if a value implements an interface at runtime. How to Check the Type of a Variable in Go Use the built-in `fmt.Sprintf("%T", variable)` function or the `reflect` package to inspect a variable's type at runtime. How to Compose Interfaces in Go (Interface Embedding) Compose Go interfaces by embedding existing interfaces to inherit their methods and create new, combined contracts. How to Convert Between Types in Go (Type Casting) Go uses explicit type conversion syntax T(v) instead of casting, requiring compatible types and failing at compile time for incompatible conversions. How to Convert Float to Int in Go You convert a float to an int in Go using an explicit type conversion, such as `int(floatValue)`, which truncates the decimal part toward zero. How to Convert Int to String in Go Use the `strconv.Itoa()` function for standard integer-to-string conversion, or `fmt.Sprintf()` if you need more formatting control. How to Convert String to Float in Go Use the `strconv.ParseFloat` function from the standard library to convert a string to a float, specifying the bit size (32 or 64) and handling the returned error. How to Convert String to Int in Go Use `strconv.Atoi` for simple base-10 conversion or `strconv.ParseInt` when you need to specify the bit size or handle different bases. How to Create Your Own Type Constraints in Go Create Go type constraints by defining an interface with a union of types or underlying types using the ~ prefix, then apply it to generic function parameters. How to Define and Implement an Interface in Go Define a Go interface by listing method signatures and implement it by adding those methods to a type, which Go recognizes automatically. How to Define Custom Types with type in Go Define custom types in Go using the type keyword to create aliases or distinct named types for better code clarity and safety. How to Define Function Types in Go Define Go function types using the func keyword with parameter and return types to create variables or aliases for function signatures. How to Design Good Interfaces in Go (Accept Interfaces, Return Structs) Accept interfaces as function arguments to allow flexibility and return concrete structs as results to ensure clarity and testability in Go code. How to Implement the sort.Interface in Go Implement sort.Interface by defining Len, Less, and Swap methods on a type to enable custom sorting with sort.Sort. How to Use complex64 and complex128 in Go Use complex64 for float32 precision and complex128 for float64 precision when defining complex numbers in Go. How to Use Generics with Methods in Go (And the Limitations) Use type parameters in function signatures to create reusable, type-safe code in Go, noting constraints on instantiation and inference. How to Use Generics with Structs in Go Define type parameters in square brackets after the struct name to create reusable, type-safe data structures. How to Use the constraints Package in Go Import golang.org/x/exp/constraints to access generic type constraints like Ordered and Comparable for writing flexible Go functions. How to Use the encoding.TextMarshaler and encoding.TextUnmarshaler Interfaces Implement MarshalText and UnmarshalText methods on your type to control how it converts to and from text for JSON and other encoders. How to Use the go/types Package for Type Checking The `go/types` package performs static type checking on Go source code by analyzing the Abstract Syntax Tree (AST) to verify type correctness without compiling the program. It is primarily used by tools like IDEs, linters, and refactoring utilities to detect type errors at development time. How to Use the io.ReadWriter and io.ReadCloser Interfaces Use io.ReadWriter for bidirectional streams and io.ReadCloser for readable resources requiring explicit closure, often wrapped with bufio.NewReader for efficiency. How to Use Type Assertions in Go Use the value.(type) syntax to safely extract a concrete type from an interface value in Go. How to Use Type Constraints in Go Generics Define type constraints using interfaces or type sets to restrict generic type parameters to specific behaviors or types. How to Use Type Switches in Go Use a type switch to run specific code blocks based on the dynamic type of an interface value. How to Use Union Type Constraints in Go (~int | ~float64) Go lacks union types, so use interfaces or type switches to handle multiple types like int and float64. How to Write a Generic Cache in Go Implement a thread-safe generic cache in Go using sync.Map or a mutex-protected map with type parameters. How to Write a Generic Function in Go Define a generic function in Go by adding type parameters in square brackets after the function name to handle multiple types. How to Write a Generic Map/Filter/Reduce in Go Write generic Map, Filter, and Reduce functions in Go using type parameters and function arguments to process slices of any type. How to Write a Generic Result Type in Go Use a generic Result[T] struct with an interface constraint to create a unified return type for success and error states in Go. How to Write a Generic Slice Utility Function in Go Write a generic Go function using type parameters to slice any slice type safely and reuse the logic. How to Write a Generic Type in Go Go 1.18+ supports generics using type parameters, allowing you to write functions and types that work with any type satisfying specific constraints. Interface embedding Interface embedding in Go enables structs to inherit fields and methods from other types for efficient code composition. Limitations of Go generics Go generics cannot be used with C types in cgo, limiting their use to pure Go code only. the any constraint The `any` type is a predeclared alias for `interface{}` allowing variables to hold values of any type. The Biggest Interface Gotcha: Nil Interface vs Nil Pointer A nil interface is not nil because it contains a type descriptor, while a nil pointer does not; check the underlying value to detect nil pointers inside interfaces. The io Reader interface The io.Reader interface defines a standard Read method for streaming data from any source in Go. The Nil Interface Gotcha in Go (Non-Nil Interface Containing Nil Value) An interface is non-nil if it holds a type, even if that type's value is nil; check the underlying value with reflection or explicit type assertions. The Stringer interface The stringer tool generates String() methods for bitset types to convert integer flags into readable names. Type assertion in Go Type assertion in Go safely extracts a concrete value from an interface variable using the comma-ok idiom to prevent panics. Type constraints Type constraints in Go define the set of allowed types for generic parameters using interfaces or type unions. Type sets in generics Type sets in Go generics define the specific collection of types a type parameter can accept based on interface constraints. Type switch in Go A type switch in Go checks the dynamic type of an interface value and executes specific code blocks for each matched type. What Are Generics in Go and Why Were They Added Generics in Go, introduced in version 1.18, enable type-safe, reusable code by allowing functions and types to work with any data type without sacrificing performance. What Are Interfaces in Go and How Do They Work Go interfaces define method sets that concrete types implement to enable polymorphism and decoupled code design. What Are Typed vs Untyped Constants in Go Typed constants have a fixed type at declaration, while untyped constants infer their type based on usage context, offering greater flexibility. What Does the Tilde (~) Mean in Go Type Constraints The tilde (~) in Go type constraints matches any type with the specified underlying type or interface implementation. What Is a Nil Interface vs a Nil Concrete Value in Go A nil interface holds no type or value, while a nil concrete value is a specific type that is nil but still makes the interface non-nil. What Is a Type Alias in Go (type X = Y) A type alias in Go creates a new name for an existing type using the `type X = Y` syntax, allowing interchangeable use without defining a new distinct type. What Is Interface Pollution in Go and How to Avoid It Avoid interface pollution in Go by defining small, focused interfaces that only include the methods actually used by the consumer. What Is the any Constraint in Go Generics The `any` constraint is a type alias for `interface{}` that allows Go generics to accept values of any type without restrictions. What Is the byte Type in Go The `byte` type in Go is simply an alias for `uint8`, representing an unsigned 8-bit integer with a range from 0 to 255. What Is the comparable Constraint in Go The comparable constraint restricts generic type parameters to types that support equality comparison operators. What Is the Difference Between float32 and float64 in Go float32 is a 32-bit floating-point type for lower precision, while float64 is a 64-bit type offering higher precision and range. What Is the Difference Between interface{} and any in Go `any` is simply a predeclared alias for `interface{}` introduced in Go 1.18; they are functionally identical at runtime but `any` improves code readability by reducing visual noise. What Is the Difference Between int, int32, and int64 in Go int is platform-dependent, while int32 and int64 are fixed-width types ensuring consistent size across all systems. What Is the Difference Between type X Y and type X = Y in Go `type X Y` creates a new, distinct type that is compatible with `Y` but not interchangeable with it, whereas `type X = Y` creates an alias where `X` and `Y` are exactly the same type. What is the empty interface The empty interface is a Go type that accepts any value, enabling generic storage and flexible function parameters. What Is the Empty Interface (interface{} and any) in Go The empty interface interface{} (or any) holds values of any type by having no required methods. What Is the io.Reader Interface and Why Is It Everywhere The io.Reader interface defines a standard Read method for streaming data, enabling Go code to handle files, networks, and buffers uniformly. What Is the io.Writer Interface and How to Use It The io.Writer interface is a Go contract with a single Write method used to send byte data to any destination like files or networks. What Is the rune Type in Go The `rune` type in Go is simply an alias for `int32` that represents a Unicode code point, allowing you to handle individual characters from any language correctly. What Is the Zero Value in Go and Why It Matters The zero value in Go is the automatic default for uninitialized variables, ensuring safety and preventing undefined behavior. What Is uintptr in Go and When to Use It uintptr is an integer type holding a pointer's bit pattern, used for C interop but not for direct memory access. When to Use Interfaces vs Concrete Types in Go Use interfaces for flexibility and decoupling, and concrete types for performance and fixed implementations. Why Does Go Not Have Implicit Type Conversion Go omits implicit type conversions to prioritize code clarity, prevent subtle bugs, and ensure that type changes are always explicit and intentional. Why Go Interfaces Are Implicitly Satisfied (No implements Keyword) Go interfaces are implicitly satisfied when a type defines all required methods, eliminating the need for an explicit implements keyword.