knifer

README

🔪 knifer-go

🔪 A Swiss Army knife for Go development, keeping your daily coding sharp.

🧰 Batteries-included utility toolkit: string, slice, map, crypto, HTTP, cache, ID generation, logging, config, and more. Import only what you need via v* domain packages.

knifer-go is a Go / Golang utility library for strings, slices, maps, JSON, files, HTTP, URL safety, crypto, JWT, config, cache, IDs, logging, and common application helpers. It exposes focused v* packages so developers and AI coding agents can import only the tools they need.

New here: start with 10 tasks in 10 minutes, the task index, the documentation hub, or pkg.go.dev.

📑 Table of Contents

• 📚 Introduction
• ✨ Why knifer-go
• 🚀 Install
• ⭐ Start with these packages
• 🤖 For AI agents and coding assistants
• 🧭 Find by scenario
• ⚖️ Compare with other Go utility libraries
• 🧩 Package catalog
• 🏗️ Architecture
• 🔒 API compatibility policy
• ✅ Recommended APIs
• 📖 Documentation
• 📦 Build and test
• 🛡️ Governance
• 🤝 Contributing
• ⭐ Star knifer-go

📚 Introduction

knifer-go is a practical utility toolkit for Go projects. It collects frequently used capabilities—string helpers, collection utilities, encoding/decoding, cryptography, HTTP, JSON, cache, cron, JWT, logging, configuration, and system information—into reusable packages.

Use it when you search for a Go utility library, Golang helper functions, Go slice/map/string helpers, safe HTTP download helpers, URL validation helpers, crypto/JWT helpers, JSON path helpers, file helpers, or config helpers in one module with explicit public package boundaries.

The root package github.com/imajinyun/knifer-go is only the module entry point. Actual APIs live in public v* facade packages so applications can import only the domain they need.

✨ Why knifer-go

knifer comes from “knife”: a handy little tool for solving common everyday problems in Go development.

• 🧰 Focused facades: import vstr, vslice, vhttp, vcrypto, and other domain packages directly.
• 🧪 Testable options: many APIs provide WithXxx options and provider injection for deterministic tests.
• 🛡️ Safe defaults: security-sensitive helpers prefer explicit errors, bounded reads, SSRF-aware URL access, and path traversal checks.
• 📚 Domain docs: detailed quickstarts live under docs/doc, keeping this README easy to scan.

🚀 Install

Go 1.25 or later is required.

See the Go version adoption policy for the current minimum-version rationale and downgrade requirements.

go get github.com/imajinyun/knifer-go

⭐ Start with these packages

If you are new to knifer-go, make the decision in three minutes: use the standard library when it is explicit and short; use knifer-go when a repeated workflow needs safety policy, error-returning convenience, provider injection, or documented dynamic data contracts.

Need	Start here	Why
Safe HTTP and downloads	vhttp, vresty, vurl	Common request helpers plus explicit safe paths for untrusted URLs and files.
Safe crypto workflows	vcrypto, vrand, vjwt	Recommended hashing, HMAC, encryption, secure random bytes, and signed-token entry points.
Daily JSON and file workflows	vjson, vfile	Cookbook-style helpers for common object, formatting, read/write, copy, and explicit-error flows.
Dynamic config and mapping	vconf, vbean, vconv, vobj	Config loading, weak conversion, decode metadata, and generic object checks with executable contracts.
Collection and text helpers	vslice, vmap, vstr	Reusable transforms, predicates, grouping, pagination, and string cleanup when a local loop becomes repeated.

Stdlib-first decision table:

Scenario	Prefer stdlib	Prefer knifer-go
Slice/map/string basics	Plain for, slices, maps, strings, strconv, or regexp is shorter and local.	Repeated Map/Filter/GroupBy/Pick/case/predicate workflows need shared semantics.
JSON	encoding/json streaming, Decoder.UseNumber, or direct struct marshaling is the contract.	Dynamic object/array helpers, path lookup, defaults, formatting, or map-like JSON are the contract.
HTTP/URL	Trusted URL and full net/http transport/request control are clearer.	User/config-provided URLs need SSRF-aware allow-lists, private-host rejection, redirects, or bounded reads.
Crypto/random/JWT	You need direct primitive composition and full crypto/* control.	You need reviewed HMAC, AES-GCM, RSA, JWT signing, secure token, or deterministic provider-injected helpers.
Config/mapping/conversion	Direct assignment, flag, os.LookupEnv, or typed decoding keeps shape explicit.	Tag-aware binding, profile overlays, weak conversion, DecodeResult, or remote config safety are needed.
Files/archives	Small trusted file operations fit os, io, archive/zip, and path/filepath.	Untrusted paths, ZIP entries, downloads, overwrite policy, or bounded IO need explicit safety helpers.
SQL/CLI boundaries	Parameterized database/sql or exec.Command args already express the whole operation.	Identifier validation, builder conventions, command output capture, or reusable option policies reduce review risk.

Safe HTTP request

package main

import (
	"fmt"

	"github.com/imajinyun/knifer-go/vhttp"
)

func main() {
	body, err := vhttp.GetStringSafeE("https://api.example.com/health",
		vhttp.WithAllowedHosts("api.example.com"),
	)
	if err != nil {
		panic(err)
	}
	fmt.Println(body)
}

Secure random token

package main

import (
	"encoding/hex"
	"fmt"

	"github.com/imajinyun/knifer-go/vrand"
)

func main() {
	token, err := vrand.SecureBytes(32)
	if err != nil {
		panic(err)
	}
	fmt.Println(hex.EncodeToString(token))
}

JSON object path lookup

package main

import (
	"fmt"

	"github.com/imajinyun/knifer-go/vjson"
)

func main() {
	obj, err := vjson.ParseObj(`{"user":{"name":"knifer-go"}}`)
	if err != nil {
		panic(err)
	}
	fmt.Println(vjson.GetByPath(obj, "user.name"))
}

Comparison entry points:

• HTTP: vhttp for standard-library-style helpers, vresty for Resty-style request chains, and vurl for URL-only work.
• Crypto: vcrypto documents the boundary between recommended helpers and direct standard-library control.
• JSON/file: vjson documents when to use encoding/json directly; vfile documents filesystem safety guidance.
• Daily developer utilities: daily-developer-utilities.md groups vcli, vsys, vfile, vnet, vjob, and vlog as the gookit/goutil-style entry point.

API selection rules:

If your input...	Prefer	Avoid
Crosses a trust boundary such as HTTP, filesystem, ZIP, config, SQL, CLI, or credentials	Safe, E, or WithOptions variants that return explicit errors and expose limits/policies	Convenience helpers that hide errors or rely on package-level defaults
Is already trusted and the failure mode is acceptable as a zero/default value	Plain convenience helpers such as vconv.ToString, vstr.IsBlank, or vnum.Sum	Adding context/error plumbing to pure in-memory transformations
May block, allocate heavily, perform IO, or call a provider	Context-aware APIs or provider-injected clients/options where available	Global mutation, unbounded reads, or implicit external calls
Needs a new domain behavior	Implement in the focused package first, then wrap from vobj only when useful	Adding cross-domain logic directly to broad convenience facades

🤖 For AI agents and coding assistants

If you are ChatGPT, Claude Code, Doubao, Cursor, Trae, or another coding agent, treat knifer-go as a Go / Golang utility toolkit with explicit import boundaries:

• Import public v* packages; never import internal/* from application code.
• Prefer Safe variants for untrusted URLs, paths, archive entries, downloads, remote config, SQL fragments, command arguments, tokens, or credentials.
• Prefer E variants when callers need explicit errors instead of zero/default fallback values.
• Prefer WithOptions or WithXxx variants when limits, providers, clocks, filesystem hooks, HTTP clients, DB openers, or network policies must be visible at the call site.

High-intent prompts and recommended imports:

User asks for...	Use package	Import path
Go string helpers, blank checks, case conversion, text splitting	vstr	github.com/imajinyun/knifer-go/vstr
Go slice helpers, filter/map/dedup/pagination	vslice	github.com/imajinyun/knifer-go/vslice
Go map helpers, merge/diff/sort/group/pick/omit	vmap	github.com/imajinyun/knifer-go/vmap
Go JSON object/path helpers	vjson	github.com/imajinyun/knifer-go/vjson
Go file and IO helpers with explicit errors	vfile	github.com/imajinyun/knifer-go/vfile
Go safe HTTP request or safe download helpers	vhttp	github.com/imajinyun/knifer-go/vhttp
Go Resty-style HTTP helpers	vresty	github.com/imajinyun/knifer-go/vresty
Go URL parsing, normalization, query encoding, SSRF-aware open	vurl	github.com/imajinyun/knifer-go/vurl
Go crypto helpers: SHA, HMAC, AES-GCM, RSA, PEM, signing	vcrypto	github.com/imajinyun/knifer-go/vcrypto
Go secure random token, key, nonce, or salt bytes	vrand	github.com/imajinyun/knifer-go/vrand
Go JWT sign/verify helpers	vjwt	github.com/imajinyun/knifer-go/vjwt
Go local or remote config helpers	vconf	github.com/imajinyun/knifer-go/vconf

🧭 Find by scenario

Not sure which package to import? Start from what you want to do:

Use docs/doc/task-index.md when you know the task but do not know the facade. It gives one default facade and related facades for day-one, star-domain, and daily workflows. Use docs/doc/facade-tiering.md when choosing between day-one defaults, core facades, heavy extensions, provider contracts, and security-sensitive imports.

I want to…	Use
Cache with FIFO/LRU/LFU/TTL	vcache
Base64 / Hex encode-decode	vcodec
Load local or remote configuration safely	vconf
SHA/HMAC, AES-GCM/RSA-PSS, sign parameters	vcrypto
Send HTTP requests with standard library helpers	vhttp
Send HTTP requests with Resty-based helpers	vresty
Generate UUID / Snowflake / NanoId	vid
Mask sensitive data	vmask
Create, query, transform, merge, diff, or sort maps	vmap
Filter / map / dedup / paginate slices	vslice
Trim, split, case-convert, compare text, or check blank strings	vstr
Encode/parse URLs or open untrusted HTTP(S) resources safely	vurl

Agent decision guide

First time here? Start with docs/doc/first-use-golden-paths.md for 10 tasks in 10 minutes.

1. String manipulation → use vstr.
2. Slice transformation → use vslice.
3. Map transformation → use vmap.
4. Safe HTTP request or file download → use vhttp; use vresty only when Resty-style chaining is already desired.
5. URL parsing, normalization, query handling, or SSRF-aware resource checks → use vurl.
6. Hashing, HMAC, AES-GCM, RSA, PEM, or parameter signing → use vcrypto; use vhash only for non-cryptographic hashes.
7. Secure random bytes or tokens → use vrand.
8. JWT creation or verification → use vjwt.
9. JSON object/path/formatting helpers → use vjson; use encoding/json directly for streaming decoder control.
10. File IO with limits, providers, or explicit errors → use vfile; use vzip for archives.

👉 See the full documentation index for every package.

⚖️ Compare with other Go utility libraries

knifer-go is broader than a single-purpose helper package. Use this boundary when an agent or developer is choosing a Go utility library:

Need	Prefer	Boundary
Lodash-style generic collection helpers only	samber/lo	Use knifer-go when the same project also needs safe HTTP, URL, crypto, JWT, JSON, file, config, cache, ID, or logging helpers.
Broad utility coverage with a simple adoption story	duke-git/lancet	Use knifer-go when the toolkit choice depends on explicit safety boundaries, generated API metadata, facade packages, and machine-checked governance.
Daily development utilities across env, filesystem, structs, system, and CLI helpers	gookit/goutil	Use knifer-go when daily utilities should sit beside security-focused HTTP/URL/crypto/JWT/database boundaries in one facade model.
Type conversion only	spf13/cast	Use knifer-go/vconv when conversion is part of a broader knifer-go toolkit adoption.
Struct-to-struct or map copying only	jinzhu/copier	Use knifer-go/vbean when struct/map mapping should stay inside the same public facade model.
Map-to-struct decoding only	mitchellh/mapstructure	Use knifer-go/vconf or vbean when config loading or bean mapping is the surrounding workflow.
Reflection-heavy functional helpers	thoas/go-funk	Use knifer-go/vslice, vmap, or vstr for focused helpers with clearer package boundaries.

For a broader comparison, see docs/doc/utility-library-comparison.md. For daily CLI, system, file, network, job, and logging tasks, see docs/doc/daily-developer-utilities.md. For collection workflows by task, see docs/doc/collection-golden-paths.md. For advanced collection API candidates, see docs/doc/collection-advanced-backlog.md. For type-conversion migration from spf13/cast, see docs/doc/vconv-cast-migration.md. For dynamic config, map/struct, JSON, object, reflection, and scalar-conversion boundaries, see docs/doc/dynamic-data-toolkit-matrix.md. For planned debug and test utility lanes, see docs/doc/developer-debug-test-backlog.md. Benchmark evidence rules are public in docs/doc/benchmark-trust.md.

🧩 Package catalog

knifer-go follows an “internal implementation + public facade” layout: internal/* contains concrete implementations, while v* packages expose stable public APIs.

• 📦 Full module matrix: docs/doc/README.md#package-catalog
• 🔎 Per-package quickstarts: docs/doc/*.md
• 🧾 Exported API snapshot: docs/api/exports.txt
• 🧭 Machine-readable function catalog: docs/api/tools.json
• 📋 Human-readable function catalog: docs/api/tools.md

🏗️ Architecture

Application code should import public v* packages. internal/* packages are implementation details and can evolve without exposing every helper as public API.

For domain boundary rules, provider-injection patterns, API compatibility policy, error contracts, and safety defaults, see Architecture and package boundaries.

🔒 API compatibility policy

knifer-go treats top-level v* facade packages as the public API boundary. The generated API snapshot in docs/api/exports.txt is reviewed with public API changes so upgrade risk is visible before release.

Stability level	Applies to	Compatibility promise
Stable	Exported names in v* facade packages and docs/api/exports.txt	No breaking change without a documented migration path and release note.
Internal	internal/* implementation packages	May change without public compatibility guarantees.
Experimental	Newly introduced provider contracts or adapter packages marked experimental in docs	May change before being promoted to Stable; migration notes are still required.

A breaking change includes removing or renaming an exported facade API, changing a public function signature, changing exported type field semantics, changing sentinel error matching behavior, weakening a documented security default, or changing generated API snapshot content without release notes.

Deprecated APIs stay available for at least two minor releases. Every deprecation must name the replacement API, explain the migration, and appear in release notes before removal.

✅ Recommended APIs

For new code, prefer explicit-error and safe variants when inputs cross a trust boundary:

• Use Safe variants when the operation touches an untrusted URL, path, archive entry, remote configuration source, or download target.
• Use E variants when conversion, parsing, decoding, IO, or request execution can fail and the caller needs to distinguish failure from an empty/default value.
• Use non-E convenience helpers only when inputs are trusted and zero/default fallback is an intentional compatibility choice.
• Use WithOptions / WithXxx variants when resource limits, providers, clocks, filesystem hooks, or network policies must be visible at the call site.

Scenario	Recommended API
Trusted standard-library HTTP request	vhttp.Get, vhttp.Post, vhttp.NewRequest
Untrusted HTTP(S) URL	vhttp.GetStringSafeE, vresty.GetStringSafeE, vurl.OpenSafe
User-controlled download target/source	vhttp.DownloadFileSafe, vresty.DownloadFileSafe
Secret bytes, tokens, keys, nonces, or salts	vrand.SecureBytes
Remote configuration from a trust boundary	vconf.LoadRemoteSafe

More recommendations are documented in Recommended API entry points.

📖 Documentation

• 📚 Documentation hub: docs/doc/README.md
• 🌐 Online Go docs: pkg.go.dev/github.com/imajinyun/knifer-go
• 🧾 API snapshot: docs/api/exports.txt
• 🤖 Machine-readable tool catalog: docs/api/tools.json
• 📋 Readable tool catalog: docs/api/tools.md
• 🗺️ AI-oriented project map: llms.txt
• 🤖 Machine-readable AI/CLI metadata: ai-context.json
• 🧯 Security policy: SECURITY.md
• 📝 Changelog: CHANGELOG.md

📦 Build and test

Clone the source code:

git clone https://github.com/imajinyun/knifer-go.git
cd knifer-go

Run the common local checks:

make test        # unit tests
make ci-test     # CI test-job gates
make check       # full local gate: tests, vet, lint, vuln, coverage, API checks

Useful focused commands:

make doctor
make worktree-check
make quick-check
make security-check
make ai-context-check
make install-hooks
make bench-core
make bench-facade
make generate
UPDATE_API=1 make api-check

See Build, test, and release workflow for the full command guide.

🛡️ Governance

• Security reports: see SECURITY.md. Please do not disclose suspected vulnerabilities in public issues.
• Release notes: see CHANGELOG.md. User-visible changes should be recorded before tagging a release.
• Adoption trust: see docs/doc/adoption-trust.md for release notes, compatibility policy, deprecation policy, security policy, generated API catalog, and validation-gate entry points.
• Coverage/API/workflow gate details: see Governance.
• Compatibility and deprecation: see API compatibility policy and run make api-freeze-check before release branches.
• CI trust signals include race/shuffle tests, coverage gates, generated API and tool-catalog checks, golangci-lint, govulncheck, CodeQL, benchmark smoke tests, and OpenSSF Scorecard.
• Benchmark output is treated as evidence, not a universal performance claim; see the benchmark trust guide.

🤝 Contributing

Pull requests are welcome. Please add new capabilities to the appropriate internal/* implementation package first, expose public APIs from the corresponding v* package, add comments/tests, run local checks, and keep code formatted with gofmt.

For issue templates, PR principles, and gate expectations, see Contributing.

⭐ Star knifer-go

If this project helps you reduce repeated code, please consider giving it a Star. Your feedback and contributions will help make it a sharper Go utility toolkit.

Documentation

Overview

Package knifer is the root package of the knifer-go utility toolkit.

This module is split into 55 public subpackages by domain. Import only the packages you need. The subpackages are grouped below for navigation:

String & text:

vstr    strings and text similarity helpers
vregex  regular expressions
vtpl    html/template rendering (TemPLate)
vurl    URL/URI parsing, escaping, query building
vhan    Han text romanization adapters
vtok    tokenization adapters

Collections & data structures:

vslice  slices
vmap    maps
vset    sets
vobj    object-level helpers
vblf    bloom filters (BLoom Filter)
vcache  generic caches (FIFO/LRU/LFU/Timed)
vbean   struct/map mapping and copying

Primitives & conversion:

vbool   booleans
vnum    numeric helpers
vconv   permissive type conversion
vdate   date/time
vref    reflection

Encoding & serialization:

vcodec  Base64/Hex
vcsv    CSV reading/writing
vimg    raster images and graphical captchas
vjson   JSON
vxml    XML
vhash   non-cryptographic hashes

Networking & communication:

vhttp   standard-library HTTP client/server
vresty  Resty-based HTTP client
vmail   email message construction, MIME attachments, and SMTP sending
vskt    sockets (SocKeT)
vnet    IP/port/interface utilities
vftp    FTP adapters
vssh    SSH/SFTP adapters

Security & matching:

vcrypto cryptography and digests
vjwt    JWT sign/verify
vmask   data masking (desensitization)
vpass   password strength analysis
vdfa    DFA word-tree text matching

Tasks & concurrency:

vjob    job orchestration
vcron   cron scheduling
vsem    semaphores (SEMaphore)
vrand   randomness

IO & files:

vfile   file and IO helpers
vzip    archive/compression
vpoi    office documents (Excel)

Runtime & system:

vsys    system information (SYStem)
vlog    logging
verr    error handling, panic recovery, stacks (errx)
vconf   configuration
vcli    CLI helpers
vai     AI adapters

Identity & misc:

vid     generated IDs (UUID/Snowflake/ObjectId/NanoId)
vident  legal identity numbers (ID cards)
vform   form and input validators
vver    version comparison (VERsion)
vdb     database/sql helpers
vgeo    coordinate conversion (WGS-84/GCJ-02/BD-09)

Example:

import "github.com/imajinyun/knifer-go/vstr"
import "github.com/imajinyun/knifer-go/vhttp"

Subpackages are independent from each other. The root package exposes no business APIs; it only defines the cross-cutting error contract (ErrCode, Error, CodeCarrier, CodeOf and the New/Wrap/Errorf constructors) that subpackages may use to classify failures consistently.

Callers can match failures by code regardless of the originating subpackage:

if errors.Is(err, knifer.ErrCodeInvalidInput) { ... }
if code, ok := knifer.CodeOf(err); ok { ... }

Subpackages that participate should return *knifer.Error or implement CodeCarrier on their existing error types/sentinels while wrapping any underlying cause so the standard error chain is preserved.

The project follows an internal implementation plus public facade layout: concrete implementations live in internal/* packages, while application code should import the public v* packages. This keeps domain boundaries explicit and allows internal implementations to evolve without exposing every helper as public API.

Index

• type CodeCarrier
• type ErrCode
  • func CodeOf(err error) (ErrCode, bool)
  • func (c ErrCode) Error() string
• type Error
  • func Errorf(code ErrCode, format string, args ...any) *Error
  • func NewError(code ErrCode, message string) *Error
  • func WrapError(code ErrCode, message string, cause error) *Error
  • func (e *Error) Error() string
  • func (e *Error) ErrorCode() ErrCode
  • func (e *Error) Is(target error) bool
  • func (e *Error) Unwrap() error

Examples

• Error
• WrapError

Types

type CodeCarrier

type CodeCarrier interface {
	ErrorCode() ErrCode
}

CodeCarrier is implemented by errors that can expose a knifer-go error code.

Custom subpackage errors can implement this interface while preserving their own concrete type and sentinel semantics.

type ErrCode

type ErrCode string

ErrCode is a stable, cross-subpackage error classifier.

It is itself an error so that it can be used directly with errors.Is:

if errors.Is(err, knifer.ErrCodeInvalidInput) { ... }

const (
	// ErrCodeInvalidInput indicates the caller provided invalid arguments.
	ErrCodeInvalidInput ErrCode = "GK_INVALID_INPUT"
	// ErrCodeNotFound indicates the requested resource does not exist.
	ErrCodeNotFound ErrCode = "GK_NOT_FOUND"
	// ErrCodeUnsupported indicates the requested operation is not supported.
	ErrCodeUnsupported ErrCode = "GK_UNSUPPORTED"
	// ErrCodeUnsafeResource indicates the requested file, URL, archive entry, or
	// remote resource failed a safety policy such as traversal or SSRF checks.
	ErrCodeUnsafeResource ErrCode = "GK_UNSAFE_RESOURCE"
	// ErrCodeTimeout indicates the operation exceeded its time budget.
	ErrCodeTimeout ErrCode = "GK_TIMEOUT"
	// ErrCodeProviderFailure indicates an injected provider, transport, codec,
	// filesystem, random source, or external adapter failed after input was valid.
	ErrCodeProviderFailure ErrCode = "GK_PROVIDER_FAILURE"
	// ErrCodeInternal indicates an unexpected internal failure.
	ErrCodeInternal ErrCode = "GK_INTERNAL"
)

Predefined cross-cutting error codes.

These cover the most common failure categories shared across subpackages. Domain-specific codes can be defined within each subpackage when needed.

func CodeOf

func CodeOf(err error) (ErrCode, bool)

CodeOf extracts a knifer-go error code from err.

It first looks for an error implementing CodeCarrier, then falls back to the predefined base ErrCode values through errors.Is. The fallback keeps sentinel errors that only implement Is(target ErrCode) discoverable.

func (ErrCode) Error

func (c ErrCode) Error() string

Error implements the error interface so an ErrCode constant can be used as the target of errors.Is without wrapping.

type Error

type Error struct {
	// Code classifies the error. It is matched by errors.Is.
	Code ErrCode
	// Message is a human-readable description.
	Message string
	// Cause is the underlying error, if any. It is exposed through Unwrap.
	Cause error
}

Error is the unified error type for knifer-go subpackages.

Subpackages that want to participate in the cross-cutting error contract should return *Error and wrap any underlying cause through Cause so that callers can rely on errors.Is(err, knifer.ErrCodeXxx) and on the standard error-chain helpers.

Example

package main

import (
	"errors"
	"fmt"

	"github.com/imajinyun/knifer-go"
)

func main() {
	err := knifer.NewError(knifer.ErrCodeInvalidInput, "url is empty")
	fmt.Println(errors.Is(err, knifer.ErrCodeInvalidInput))
	fmt.Println(err)
}

Output:
true
GK_INVALID_INPUT: url is empty

func Errorf

func Errorf(code ErrCode, format string, args ...any) *Error

Errorf builds an *Error whose message is formatted with fmt.Sprintf.

func NewError

func NewError(code ErrCode, message string) *Error

NewError builds an *Error with the given code and message.

func WrapError

func WrapError(code ErrCode, message string, cause error) *Error

WrapError builds an *Error that wraps cause; cause is preserved on the chain and remains discoverable via errors.Is / errors.As.

Example

package main

import (
	"errors"
	"fmt"

	"github.com/imajinyun/knifer-go"
)

func main() {
	cause := errors.New("connection refused")
	err := knifer.WrapError(knifer.ErrCodeTimeout, "dial failed", cause)
	fmt.Println(errors.Is(err, knifer.ErrCodeTimeout))
	fmt.Println(errors.Is(err, cause))
}

Output:
true
true

func (*Error) Error

func (e *Error) Error() string

Error returns "CODE: Message" or "CODE: Message: cause" when Cause is set.

func (*Error) ErrorCode

func (e *Error) ErrorCode() ErrCode

ErrorCode returns the error code carried by e.

func (*Error) Is

func (e *Error) Is(target error) bool

Is reports whether target matches this error.

It returns true when target is the same ErrCode value or another *Error with the same Code. The standard library walks the chain via Unwrap, so callers can write errors.Is(err, knifer.ErrCodeInvalidInput).

func (*Error) Unwrap

func (e *Error) Unwrap() error

Unwrap returns the underlying cause, enabling errors.Is and errors.As to traverse the error chain.