cxuu/golang-skills

go-functions

Use when organizing functions within a Go file, formatting function signatures, designing return values, or following Printf-style naming conventions.

Quelltext ansehen

Verwendung

  1. Installationsbefehl kopieren und das Quellpaket vor der Installation in der eigenen Agentenumgebung prüfen.
  2. Benötigte Werkzeuge, Zugangsdaten und Hosts im Original prüfen.
  3. Eingabe und gewünschtes Ergebnis beschreiben und die Ausgabe mit den Quellen abgleichen.
npx skills add https://github.com/cxuu/golang-skills --skill go-functions

Vor dem Start

  • Die Installation umfasst weder Modellabo noch API-Kontingent oder Dateizugriffsrechte.
  • Sterne und Installationen zeigen Aktivität, keine unabhängige Qualitäts- oder Sicherheitsprüfung.
Originales Skill-Dokument

Aus dem Quell-Repository gerendert; Überschriften, Beispiele, Code, Tabellen, Links und Bilder bleiben erhalten.

Go Function Design

Resource Routing

  • references/SIGNATURES.md - Read when designing parameters, return values, named results, or signature readability.
  • references/PRINTF-STRINGER.md - Read when using fmt verbs, Stringer, GoStringer, Formatter, or Printf-style function naming.
When this skill does NOT apply: For functional options constructors (WithTimeout, WithLogger), see go-functional-options. For error return conventions, see go-error-handling. For naming functions and methods, see go-naming.

Function Grouping and Ordering

Organize functions in a file by these rules:

  1. Functions sorted in rough call order
  2. Functions grouped by receiver
  3. Exported functions appear first, after struct/const/var definitions
  4. NewXxx/newXxx constructors appear right after the type definition
  5. Plain utility functions appear toward the end of the file
go
type something struct{ ... }

func newSomething() *something { return &something{} }

func (s *something) Cost() int { return calcCost(s.weights) }

func (s *something) Stop() { ... }

func calcCost(n []int) int { ... }

Function Signatures

Keep the signature on a single line when possible. When it must wrap, put all arguments on their own lines with a trailing comma:

go
func (r *SomeType) SomeLongFunctionName(
    foo1, foo2, foo3 string,
    foo4, foo5, foo6 int,
) {
    foo7 := bar(foo1)
}

Add /* name */ comments for ambiguous arguments, or better yet, replace naked bool parameters with custom types.


Pointers to Interfaces

You almost never need a pointer to an interface. Pass interfaces as values — the underlying data can still be a pointer.

go
// Bad: pointer to interface
func process(r *io.Reader) { ... }

// Good: pass the interface value
func process(r io.Reader) { ... }

Printf and Stringer

Printf-style Function Names

Functions that accept a format string should end in f for go vet support. Declare format strings as const when used outside Printf calls.

Prefer %q over %s with manual quoting when formatting strings for logging or error messages — it safely escapes special characters and wraps in quotes:

go
return fmt.Errorf("unknown key %q", key) // produces: unknown key "foo\nbar"

See go-functional-options when designing a constructor with 3+ optional parameters.


Quick Reference

TopicRule
File orderingType -> constructor -> exported -> unexported -> utils
Signature wrappingAll args on own lines with trailing comma
Naked parametersAdd /* name */ comments or use custom types
Pointers to interfacesAlmost never needed; pass interfaces by value
Printf function namesEnd with f for go vet support

Related Skills

  • Error returns: See go-error-handling when designing error return patterns or wrapping errors in multi-return functions
  • Naming conventions: See go-naming when naming functions, methods, or choosing getter/setter patterns
  • Functional options: See go-functional-options when designing a constructor with 3+ optional parameters
  • Formatting principles: See go-style-core when deciding line length, naked returns, or signature formatting

Verwandte Aufgaben

aus demselben Repository

Weitere Skills

Alle Skills
cxuu
Community

go-code-review

Use when reviewing Go code or checking code against community style standards. Also use proactively before submitting a Go PR or when reviewing any Go code changes, even if the user doesn't explicitly request a style review. Does not cover language-specific syntax — delegates to specialized skills.

Installationen / 1h
2
GitHub Stars
189
Aktualisiert
20. Juni
cxuu
Community

go-concurrency

Use when writing concurrent Go code — goroutines, channels, mutexes, or thread-safety guarantees. Also use when parallelizing work, fixing data races, or protecting shared state, even if the user doesn't explicitly mention concurrency primitives. Does not cover context.Context patterns (see go-context).

Installationen / 1h
2
GitHub Stars
189
Aktualisiert
20. Juni
cxuu
Community

go-context

Use when working with context.Context in Go — placement in signatures, propagating cancellation and deadlines, and storing values in context vs parameters. Also use when cancelling long-running operations, setting timeouts, or passing request-scoped data, even if they don't mention context.Context directly. Does not cover goroutine lifecycle or sync primitives (see go-concurrency).

Installationen / 1h
2
GitHub Stars
189
Aktualisiert
20. Juni
cxuu
Community

go-control-flow

Use when writing conditionals, loops, or switch statements in Go — including if with initialization, early returns, for loop forms, range, switch, type switches, and blank identifier patterns. Also use when writing a simple if/else or for loop, even if the user doesn't mention guard clauses or variable scoping. Does not cover error flow patterns (see go-error-handling).

Installationen / 1h
2
GitHub Stars
189
Aktualisiert
20. Juni