[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7CWDGGYDFV85FPCFG1867MZ":3,"skill-same:01M7CWDGGYDFV85FPCFG1867MZ":64},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":37,"commitSha":38,"skillDirectory":39,"forksCount":40,"repositoryHtmlUrl":41,"repositoryHomepageUrl":6,"ownerHtmlUrl":42,"ownerBlogUrl":6,"ownerDescription":43,"updatedAt":44,"install":45,"resources":57},"01M7CWDGGYDFV85FPCFG1867MZ","golang-data-structures",null,"Golang data structures — slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container\u002Flist\u002Fheap\u002Fring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy semantics. Use when choosing or optimizing Go data structures, implementing generic containers, using container\u002F packages, unsafe or weak pointers, or questioning slice\u002Fmap internals.","om-scogo\u002Fskillsh-scraper","om-scogo","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F160466840?v=4","01M79AWB6DFVCQ7RK70CS34B96","Om Achrekar","01M79AWB6ZM9SKR8KDH1WSSM22",0,"MIT","https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper\u002Fblob\u002Fmain\u002Fdata\u002Fskills\u002Fsamber-cc-skills-golang\u002Fgolang-data-structures\u002FSkill.md",[],[],"2026-11-15 14:19:17",false,"---\nname: golang-data-structures\ndescription: \"Golang data structures — slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container\u002Flist\u002Fheap\u002Fring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy semantics. Use when choosing or optimizing Go data structures, implementing generic containers, using container\u002F packages, unsafe or weak pointers, or questioning slice\u002Fmap internals.\"\nuser-invocable: true\nlicense: MIT\ncompatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang.\nmetadata:\n  author: samber\n  version: \"1.1.6\"\n  openclaw:\n    emoji: \"🗃\"\n    homepage: https:\u002F\u002Fgithub.com\u002Fsamber\u002Fcc-skills-golang\n    requires:\n      bins:\n        - go\n    install: []\nallowed-tools: Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(git:*) Agent Bash(godig:*) Bash(gopls:*) LSP mcp__gopls__* mcp__context7__resolve-library-id mcp__context7__query-docs\n---\n\n**Persona:** You are a Go engineer who understands data structure internals. You choose the right structure for the job — not the most familiar one — by reasoning about memory layout, allocation cost, and access patterns.\n\n# Go Data Structures\n\nBuilt-in and standard library data structures: internals, correct usage, and selection guidance. For safety pitfalls (nil maps, append aliasing, defensive copies) see `samber\u002Fcc-skills-golang@golang-safety` skill. For channels and sync primitives see `samber\u002Fcc-skills-golang@golang-concurrency` skill. For string\u002Fbyte\u002Frune choice see `samber\u002Fcc-skills-golang@golang-design-patterns` skill.\n\n## Best Practices Summary\n\n1. **Preallocate slices and maps** with `make(T, 0, n)` \u002F `make(map[K]V, n)` when size is known or estimable — avoids repeated growth copies and rehashing\n2. **Arrays** SHOULD be preferred over slices only for fixed, compile-time-known sizes (hash digests, IPv4 addresses, matrix dimensions)\n3. **NEVER rely on slice capacity growth timing** — the growth algorithm changed between Go versions and may change again; your code should not depend on when a new backing array is allocated\n4. **Use `container\u002Fheap`** for priority queues, **`container\u002Flist`** only when frequent middle insertions are needed, **`container\u002Fring`** for fixed-size circular buffers\n5. **`strings.Builder`** MUST be preferred for building strings; **`bytes.Buffer`** MUST be preferred for bidirectional I\u002FO (implements both `io.Reader` and `io.Writer`)\n6. Generic data structures SHOULD use the **tightest constraint** possible — `comparable` for keys, custom interfaces for ordering\n7. **`unsafe.Pointer`** MUST only follow the 6 valid conversion patterns from the Go spec — NEVER store in a `uintptr` variable across statements\n8. **`weak.Pointer[T]`** (Go 1.24+) SHOULD be used for caches and canonicalization maps to allow GC to reclaim entries\n\n## Slice Internals\n\nA slice is a 3-word header: pointer, length, capacity. Multiple slices can share a backing array (→ see `samber\u002Fcc-skills-golang@golang-safety` for aliasing traps and the header diagram).\n\n### Capacity Growth\n\n- \u003C 256 elements: capacity doubles\n- > = 256 elements: grows by ~25% (`newcap += (newcap + 3*256) \u002F 4`)\n- Each growth copies the entire backing array — O(n)\n\n### Preallocation\n\n```go\n\u002F\u002F Exact size known\nusers := make([]User, 0, len(ids))\n\n\u002F\u002F Approximate size known\nresults := make([]Result, 0, estimatedCount)\n\n\u002F\u002F Pre-grow before bulk append (Go 1.21+)\ns = slices.Grow(s, additionalNeeded)\n```\n\n### `slices` Package (Go 1.21+)\n\nKey functions: `Sort`\u002F`SortFunc`, `BinarySearch`, `Contains`, `Compact`, `Grow`. For `Clone`, `Equal`, `DeleteFunc` → see `samber\u002Fcc-skills-golang@golang-safety` skill.\n\n**[Slice Internals Deep Dive](.\u002Freferences\u002Fslice-internals.md)** — Full `slices` package reference, growth mechanics, `len` vs `cap`, header copying, backing array aliasing.\n\n## Map Internals\n\nMaps are hash tables with 8-entry buckets and overflow chains. They are reference types — assigning a map copies the pointer, not the data.\n\n### Preallocation\n\n```go\nm := make(map[string]*User, len(users)) \u002F\u002F avoids rehashing during population\n```\n\n### `maps` Package Quick Reference (Go 1.21+)\n\n| Function          | Purpose                      |\n| ----------------- | ---------------------------- |\n| `Collect` (1.23+) | Build map from iterator      |\n| `Insert` (1.23+)  | Insert entries from iterator |\n| `All` (1.23+)     | Iterator over all entries    |\n| `Keys`, `Values`  | Iterators over keys\u002Fvalues   |\n\nFor `Clone`, `Equal`, sorted iteration → see `samber\u002Fcc-skills-golang@golang-safety` skill.\n\n**[Map Internals Deep Dive](.\u002Freferences\u002Fmap-internals.md)** — How Go maps store and hash data, bucket overflow chains, why maps never shrink (and what to do about it), comparing map performance to alternatives.\n\n## Arrays\n\nFixed-size, value types. Copied entirely on assignment. Use for compile-time-known sizes:\n\n```go\ntype Digest [32]byte           \u002F\u002F fixed-size, value type\nvar grid [3][3]int             \u002F\u002F multi-dimensional\ncache := map[[2]int]Result{}   \u002F\u002F arrays are comparable — usable as map keys\n```\n\nPrefer slices for everything else — arrays cannot grow and pass by value (expensive for large sizes).\n\n## container\u002F Standard Library\n\n| Package | Data Structure | Best For |\n| --- | --- | --- |\n| `container\u002Flist` | Doubly-linked list | LRU caches, frequent middle insertion\u002Fremoval |\n| `container\u002Fheap` | Min-heap (priority queue) | Top-K, scheduling, Dijkstra |\n| `container\u002Fring` | Circular buffer | Rolling windows, round-robin |\n| `bufio` | Buffered reader\u002Fwriter\u002Fscanner | Efficient I\u002FO with small reads\u002Fwrites |\n\nContainer types use `any` (no type safety) — consider generic wrappers. **[Container Patterns, bufio, and Examples](.\u002Freferences\u002Fcontainers.md)** — When to use each container type, generic wrappers to add type safety, and `bufio` patterns for efficient I\u002FO.\n\n## strings.Builder vs bytes.Buffer\n\nUse `strings.Builder` for pure string concatenation (avoids copy on `String()`), `bytes.Buffer` when you need `io.Reader` or byte manipulation. Both support `Grow(n)`. **[Details and comparison](.\u002Freferences\u002Fcontainers.md)**\n\n## Generic Collections (Go 1.18+)\n\nUse the tightest constraint possible. `comparable` for map keys, `cmp.Ordered` for sorting, custom interfaces for domain-specific ordering.\n\n```go\ntype Set[T comparable] map[T]struct{}\n\nfunc (s Set[T]) Add(v T)          { s[v] = struct{}{} }\nfunc (s Set[T]) Contains(v T) bool { _, ok := s[v]; return ok }\n```\n\n**[Writing Generic Data Structures](.\u002Freferences\u002Fgenerics.md)** — Using Go 1.18+ generics for type-safe containers, understanding constraint satisfaction, and building domain-specific generic types.\n\n## Pointer Types\n\n| Type | Use Case | Zero Value |\n| --- | --- | --- |\n| `*T` | Normal indirection, mutation, optional values | `nil` |\n| `unsafe.Pointer` | FFI, low-level memory layout (6 spec patterns only) | `nil` |\n| `weak.Pointer[T]` (1.24+) | Caches, canonicalization, weak references | N\u002FA |\n\n**[Pointer Types Deep Dive](.\u002Freferences\u002Fpointers.md)** — Normal pointers, `unsafe.Pointer` (the 6 valid spec patterns), and `weak.Pointer[T]` for GC-safe caches that don't prevent cleanup.\n\n## Copy Semantics Quick Reference\n\n| Type | Copy Behavior | Independence |\n| --- | --- | --- |\n| `int`, `float`, `bool`, `string` | Value (deep copy) | Fully independent |\n| `array`, `struct` | Value (deep copy) | Fully independent |\n| `slice` | Header copied, backing array shared | Use `slices.Clone` |\n| `map` | Reference copied | Use `maps.Clone` |\n| `channel` | Reference copied | Same channel |\n| `*T` (pointer) | Address copied | Same underlying value |\n| `interface` | Value copied (type + value pair) | Depends on held type |\n\n## Third-Party Libraries\n\nFor advanced data structures (trees, sets, queues, stacks) beyond the standard library:\n\n- **`emirpasic\u002Fgods`** — comprehensive collection library (trees, sets, lists, stacks, maps, queues)\n- **`deckarep\u002Fgolang-set`** — thread-safe and non-thread-safe set implementations\n- **`gammazero\u002Fdeque`** — fast double-ended queue\n\nWhen using third-party libraries, refer to their official documentation and code examples for current API signatures. For Go package docs, symbols, versions, importers, and known vulnerabilities, → See `samber\u002Fcc-skills-golang@golang-pkg-go-dev` skill (`godig`) — prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), → See `samber\u002Fcc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev.\n\n## Cross-References\n\n- → See `samber\u002Fcc-skills-golang@golang-performance` skill for struct field alignment, memory layout optimization, and cache locality\n- → See `samber\u002Fcc-skills-golang@golang-safety` skill for nil map\u002Fslice pitfalls, append aliasing, defensive copying, `slices.Clone`\u002F`Equal`\n- → See `samber\u002Fcc-skills-golang@golang-concurrency` skill for channels, `sync.Map`, `sync.Pool`, and all sync primitives\n- → See `samber\u002Fcc-skills-golang@golang-design-patterns` skill for `string` vs `[]byte` vs `[]rune`, iterators, streaming\n- → See `samber\u002Fcc-skills-golang@golang-structs-interfaces` skill for struct composition, embedding, and generics vs `any`\n- → See `samber\u002Fcc-skills-golang@golang-code-style` skill for slice\u002Fmap initialization style\n\n## Common Mistakes\n\n| Mistake | Fix |\n| --- | --- |\n| Growing a slice in a loop without preallocation | Each growth copies the entire backing array — O(n) per growth. Use `make([]T, 0, n)` or `slices.Grow` |\n| Using `container\u002Flist` when a slice would suffice | Linked lists have poor cache locality (each node is a separate heap allocation). Benchmark first |\n| `bytes.Buffer` for pure string building | Buffer's `String()` copies the underlying bytes. `strings.Builder` avoids this copy |\n| `unsafe.Pointer` stored as `uintptr` across statements | GC can move the object between statements — the `uintptr` becomes a dangling reference |\n| Large struct values in maps (copying overhead) | Map access copies the entire value. Use `map[K]*V` for large value types to avoid the copy |\n\n## References\n\n- [Go Data Structures (Russ Cox)](https:\u002F\u002Fresearch.swtch.com\u002Fgodata)\n- [The Go Memory Model](https:\u002F\u002Fgo.dev\u002Fref\u002Fmem)\n- [Effective Go](https:\u002F\u002Fgo.dev\u002Fdoc\u002Feffective_go)\n","**Persona:** You are a Go engineer who understands data structure internals. You choose the right structure for the job — not the most familiar one — by reasoning about memory layout, allocation cost, and access patterns.\n\n# Go Data Structures\n\nBuilt-in and standard library data structures: internals, correct usage, and selection guidance. For safety pitfalls (nil maps, append aliasing, defensive copies) see `samber\u002Fcc-skills-golang@golang-safety` skill. For channels and sync primitives see `samber\u002Fcc-skills-golang@golang-concurrency` skill. For string\u002Fbyte\u002Frune choice see `samber\u002Fcc-skills-golang@golang-design-patterns` skill.\n\n## Best Practices Summary\n\n1. **Preallocate slices and maps** with `make(T, 0, n)` \u002F `make(map[K]V, n)` when size is known or estimable — avoids repeated growth copies and rehashing\n2. **Arrays** SHOULD be preferred over slices only for fixed, compile-time-known sizes (hash digests, IPv4 addresses, matrix dimensions)\n3. **NEVER rely on slice capacity growth timing** — the growth algorithm changed between Go versions and may change again; your code should not depend on when a new backing array is allocated\n4. **Use `container\u002Fheap`** for priority queues, **`container\u002Flist`** only when frequent middle insertions are needed, **`container\u002Fring`** for fixed-size circular buffers\n5. **`strings.Builder`** MUST be preferred for building strings; **`bytes.Buffer`** MUST be preferred for bidirectional I\u002FO (implements both `io.Reader` and `io.Writer`)\n6. Generic data structures SHOULD use the **tightest constraint** possible — `comparable` for keys, custom interfaces for ordering\n7. **`unsafe.Pointer`** MUST only follow the 6 valid conversion patterns from the Go spec — NEVER store in a `uintptr` variable across statements\n8. **`weak.Pointer[T]`** (Go 1.24+) SHOULD be used for caches and canonicalization maps to allow GC to reclaim entries\n\n## Slice Internals\n\nA slice is a 3-word header: pointer, length, capacity. Multiple slices can share a backing array (→ see `samber\u002Fcc-skills-golang@golang-safety` for aliasing traps and the header diagram).\n\n### Capacity Growth\n\n- \u003C 256 elements: capacity doubles\n- > = 256 elements: grows by ~25% (`newcap += (newcap + 3*256) \u002F 4`)\n- Each growth copies the entire backing array — O(n)\n\n### Preallocation\n\n```go\n\u002F\u002F Exact size known\nusers := make([]User, 0, len(ids))\n\n\u002F\u002F Approximate size known\nresults := make([]Result, 0, estimatedCount)\n\n\u002F\u002F Pre-grow before bulk append (Go 1.21+)\ns = slices.Grow(s, additionalNeeded)\n```\n\n### `slices` Package (Go 1.21+)\n\nKey functions: `Sort`\u002F`SortFunc`, `BinarySearch`, `Contains`, `Compact`, `Grow`. For `Clone`, `Equal`, `DeleteFunc` → see `samber\u002Fcc-skills-golang@golang-safety` skill.\n\n**[Slice Internals Deep Dive](.\u002Freferences\u002Fslice-internals.md)** — Full `slices` package reference, growth mechanics, `len` vs `cap`, header copying, backing array aliasing.\n\n## Map Internals\n\nMaps are hash tables with 8-entry buckets and overflow chains. They are reference types — assigning a map copies the pointer, not the data.\n\n### Preallocation\n\n```go\nm := make(map[string]*User, len(users)) \u002F\u002F avoids rehashing during population\n```\n\n### `maps` Package Quick Reference (Go 1.21+)\n\n| Function          | Purpose                      |\n| ----------------- | ---------------------------- |\n| `Collect` (1.23+) | Build map from iterator      |\n| `Insert` (1.23+)  | Insert entries from iterator |\n| `All` (1.23+)     | Iterator over all entries    |\n| `Keys`, `Values`  | Iterators over keys\u002Fvalues   |\n\nFor `Clone`, `Equal`, sorted iteration → see `samber\u002Fcc-skills-golang@golang-safety` skill.\n\n**[Map Internals Deep Dive](.\u002Freferences\u002Fmap-internals.md)** — How Go maps store and hash data, bucket overflow chains, why maps never shrink (and what to do about it), comparing map performance to alternatives.\n\n## Arrays\n\nFixed-size, value types. Copied entirely on assignment. Use for compile-time-known sizes:\n\n```go\ntype Digest [32]byte           \u002F\u002F fixed-size, value type\nvar grid [3][3]int             \u002F\u002F multi-dimensional\ncache := map[[2]int]Result{}   \u002F\u002F arrays are comparable — usable as map keys\n```\n\nPrefer slices for everything else — arrays cannot grow and pass by value (expensive for large sizes).\n\n## container\u002F Standard Library\n\n| Package | Data Structure | Best For |\n| --- | --- | --- |\n| `container\u002Flist` | Doubly-linked list | LRU caches, frequent middle insertion\u002Fremoval |\n| `container\u002Fheap` | Min-heap (priority queue) | Top-K, scheduling, Dijkstra |\n| `container\u002Fring` | Circular buffer | Rolling windows, round-robin |\n| `bufio` | Buffered reader\u002Fwriter\u002Fscanner | Efficient I\u002FO with small reads\u002Fwrites |\n\nContainer types use `any` (no type safety) — consider generic wrappers. **[Container Patterns, bufio, and Examples](.\u002Freferences\u002Fcontainers.md)** — When to use each container type, generic wrappers to add type safety, and `bufio` patterns for efficient I\u002FO.\n\n## strings.Builder vs bytes.Buffer\n\nUse `strings.Builder` for pure string concatenation (avoids copy on `String()`), `bytes.Buffer` when you need `io.Reader` or byte manipulation. Both support `Grow(n)`. **[Details and comparison](.\u002Freferences\u002Fcontainers.md)**\n\n## Generic Collections (Go 1.18+)\n\nUse the tightest constraint possible. `comparable` for map keys, `cmp.Ordered` for sorting, custom interfaces for domain-specific ordering.\n\n```go\ntype Set[T comparable] map[T]struct{}\n\nfunc (s Set[T]) Add(v T)          { s[v] = struct{}{} }\nfunc (s Set[T]) Contains(v T) bool { _, ok := s[v]; return ok }\n```\n\n**[Writing Generic Data Structures](.\u002Freferences\u002Fgenerics.md)** — Using Go 1.18+ generics for type-safe containers, understanding constraint satisfaction, and building domain-specific generic types.\n\n## Pointer Types\n\n| Type | Use Case | Zero Value |\n| --- | --- | --- |\n| `*T` | Normal indirection, mutation, optional values | `nil` |\n| `unsafe.Pointer` | FFI, low-level memory layout (6 spec patterns only) | `nil` |\n| `weak.Pointer[T]` (1.24+) | Caches, canonicalization, weak references | N\u002FA |\n\n**[Pointer Types Deep Dive](.\u002Freferences\u002Fpointers.md)** — Normal pointers, `unsafe.Pointer` (the 6 valid spec patterns), and `weak.Pointer[T]` for GC-safe caches that don't prevent cleanup.\n\n## Copy Semantics Quick Reference\n\n| Type | Copy Behavior | Independence |\n| --- | --- | --- |\n| `int`, `float`, `bool`, `string` | Value (deep copy) | Fully independent |\n| `array`, `struct` | Value (deep copy) | Fully independent |\n| `slice` | Header copied, backing array shared | Use `slices.Clone` |\n| `map` | Reference copied | Use `maps.Clone` |\n| `channel` | Reference copied | Same channel |\n| `*T` (pointer) | Address copied | Same underlying value |\n| `interface` | Value copied (type + value pair) | Depends on held type |\n\n## Third-Party Libraries\n\nFor advanced data structures (trees, sets, queues, stacks) beyond the standard library:\n\n- **`emirpasic\u002Fgods`** — comprehensive collection library (trees, sets, lists, stacks, maps, queues)\n- **`deckarep\u002Fgolang-set`** — thread-safe and non-thread-safe set implementations\n- **`gammazero\u002Fdeque`** — fast double-ended queue\n\nWhen using third-party libraries, refer to their official documentation and code examples for current API signatures. For Go package docs, symbols, versions, importers, and known vulnerabilities, → See `samber\u002Fcc-skills-golang@golang-pkg-go-dev` skill (`godig`) — prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), → See `samber\u002Fcc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev.\n\n## Cross-References\n\n- → See `samber\u002Fcc-skills-golang@golang-performance` skill for struct field alignment, memory layout optimization, and cache locality\n- → See `samber\u002Fcc-skills-golang@golang-safety` skill for nil map\u002Fslice pitfalls, append aliasing, defensive copying, `slices.Clone`\u002F`Equal`\n- → See `samber\u002Fcc-skills-golang@golang-concurrency` skill for channels, `sync.Map`, `sync.Pool`, and all sync primitives\n- → See `samber\u002Fcc-skills-golang@golang-design-patterns` skill for `string` vs `[]byte` vs `[]rune`, iterators, streaming\n- → See `samber\u002Fcc-skills-golang@golang-structs-interfaces` skill for struct composition, embedding, and generics vs `any`\n- → See `samber\u002Fcc-skills-golang@golang-code-style` skill for slice\u002Fmap initialization style\n\n## Common Mistakes\n\n| Mistake | Fix |\n| --- | --- |\n| Growing a slice in a loop without preallocation | Each growth copies the entire backing array — O(n) per growth. Use `make([]T, 0, n)` or `slices.Grow` |\n| Using `container\u002Flist` when a slice would suffice | Linked lists have poor cache locality (each node is a separate heap allocation). Benchmark first |\n| `bytes.Buffer` for pure string building | Buffer's `String()` copies the underlying bytes. `strings.Builder` avoids this copy |\n| `unsafe.Pointer` stored as `uintptr` across statements | GC can move the object between statements — the `uintptr` becomes a dangling reference |\n| Large struct values in maps (copying overhead) | Map access copies the entire value. Use `map[K]*V` for large value types to avoid the copy |\n\n## References\n\n- [Go Data Structures (Russ Cox)](https:\u002F\u002Fresearch.swtch.com\u002Fgodata)\n- [The Go Memory Model](https:\u002F\u002Fgo.dev\u002Fref\u002Fmem)\n- [Effective Go](https:\u002F\u002Fgo.dev\u002Fdoc\u002Feffective_go)\n",{"name":5,"license":15,"metadata":24,"description":7,"allowed-tools":34,"compatibility":35,"user-invocable":36},{"author":25,"version":26,"openclaw":27},"samber","1.1.6",{"emoji":28,"install":29,"homepage":30,"requires":31},"🗃",[],"https:\u002F\u002Fgithub.com\u002Fsamber\u002Fcc-skills-golang",{"bins":32},[33],"go","Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(git:*) Agent Bash(godig:*) Bash(gopls:*) LSP mcp__gopls__* mcp__context7__resolve-library-id mcp__context7__query-docs","Designed for Claude Code or similar AI coding agents, and for projects using Golang.",true,"main","8859218955d9504cd18b59e7892100718039d3b4","data\u002Fskills\u002Fsamber-cc-skills-golang\u002Fgolang-data-structures",1,"https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper","https:\u002F\u002Fgithub.com\u002Fom-scogo","SDE-1 @ Scogo ","2026-07-18 12:22:46",{"source":8,"skillName":5,"commands":46,"prompt":56,"zipAvailable":36},[47,50,53],{"tool":48,"command":49},"npx","npx skills add om-scogo\u002Fskillsh-scraper --skill golang-data-structures",{"tool":51,"command":52},"bunx","bunx skills add om-scogo\u002Fskillsh-scraper --skill golang-data-structures",{"tool":54,"command":55},"pnpm","pnpm dlx skills add om-scogo\u002Fskillsh-scraper --skill golang-data-structures","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper\u002Fblob\u002Fmain\u002Fdata\u002Fskills\u002Fsamber-cc-skills-golang\u002Fgolang-data-structures\u002FSkill.md",[58],{"path":59,"resourceType":60,"resourceTypeDesc":61,"sizeBytes":62,"sourceHtmlUrl":63},"metadata.json","REFERENCE","参考文档",489,"https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper\u002Fblob\u002Fmain\u002Fdata\u002Fskills\u002Fsamber-cc-skills-golang\u002Fgolang-data-structures\u002Fmetadata.json",[65,72,77,84,89,96],{"skillNo":66,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":69,"categories":70,"keywords":71,"publishedAt":19},"01M7D6MC9FAAEV4CMNYX8W7JTG","arxiv-search","Search arXiv physics, math, and computer science preprints using natural language queries. Powered by Valyu semantic search.","https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper\u002Fblob\u002Fmain\u002Fdata\u002Fskills\u002Fyorkeccak-scientific-skills\u002Farxiv-search\u002Fskills\u002Farxiv-search\u002FSKILL.md",[],[],{"skillNo":73,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":76,"publishedAt":19},"01M7D6M85CKKN87TA98VCQV4H7","https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper\u002Fblob\u002Fmain\u002Fdata\u002Fskills\u002Fyorkeccak-scientific-skills\u002Farxiv-search\u002FSkill.md",[],[],{"skillNo":78,"name":79,"nameZh":6,"description":80,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":81,"categories":82,"keywords":83,"publishedAt":19},"01M7D4ZTCS4DR3CE4JY06X84T2","working-with-legacy-code","Safely change and test untested codebases using Feathers' \"Working Effectively with Legacy Code\". Use when the user mentions \"legacy code\", \"no tests\", \"untested codebase\", \"how do I test this\", \"seams\", \"characterization tests\", \"golden master\", \"sprout method\", \"afraid to change this code\", \"monster method\", \"dependency breaking\", or \"inherited a messy codebase\". Also trigger when changing code without tests safely, getting a class under test when constructors, statics, or singletons block it, adding features to tangled modules, or planning incremental test coverage for an old codebase. Covers the legacy-code change algorithm, seams, characterization tests, sprout\u002Fwrap, and dependency-breaking techniques. For refactoring code that already has tests, see refactoring-patterns. For day-to-day code quality, see clean-code.","https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper\u002Fblob\u002Fmain\u002Fdata\u002Fskills\u002Fwondelai-skills\u002Fworking-with-legacy-code\u002Fworking-with-legacy-code\u002FSKILL.md",[],[],{"skillNo":85,"name":79,"nameZh":6,"description":80,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":19},"01M7D4ZHZKJD2RSNGAF63V14P4","https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper\u002Fblob\u002Fmain\u002Fdata\u002Fskills\u002Fwondelai-skills\u002Fworking-with-legacy-code\u002FSkill.md",[],[],{"skillNo":90,"name":91,"nameZh":6,"description":92,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":93,"categories":94,"keywords":95,"publishedAt":19},"01M7D4ZB4CJBFW5JE67CPH2QRV","web-typography","Select, pair, and implement typefaces for web projects. Use when the user mentions \"font pairing\", \"which typeface\", \"line height\", \"responsive typography\", \"web font loading\", \"type hierarchy\", \"variable fonts\", \"FOUT\u002FFOIT\", \"typographic scale\", or \"the text is hard to read\". Also trigger when choosing between system fonts and web fonts, optimizing font-loading performance, or designing readable long-form content. Covers readability evaluation, CSS implementation, and performance optimization. For overall UI design systems, see refactoring-ui. For dramatic typographic experiences, see top-design.","https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper\u002Fblob\u002Fmain\u002Fdata\u002Fskills\u002Fwondelai-skills\u002Fweb-typography\u002Fweb-typography\u002FSKILL.md",[],[],{"skillNo":97,"name":91,"nameZh":6,"description":92,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":98,"categories":99,"keywords":100,"publishedAt":19},"01M7D4Z4MVYVY3NMJ18BNV6WNA","https:\u002F\u002Fgithub.com\u002Fom-scogo\u002Fskillsh-scraper\u002Fblob\u002Fmain\u002Fdata\u002Fskills\u002Fwondelai-skills\u002Fweb-typography\u002FSkill.md",[],[]]