Documentation ¶
Overview ¶
Package dapper is a deterministic pretty-printer with minimal output.
Index ¶
- Constants
- Variables
- func AsConcrete[T any](v Value) (T, bool)
- func AsImplementationOf[T any](v Value) (T, bool)
- func ErrorFilter(r Renderer, v Value)
- func Format(v any) string
- func Is[T any](v Value) bool
- func Print(values ...any)
- func ProtoFilter(r Renderer, v Value)
- func ReflectFilter(r Renderer, v Value)
- func StringerFilter(r Renderer, v Value)
- func SyncFilter(r Renderer, v Value)
- func TimeFilter(r Renderer, v Value)
- func Write(w io.Writer, v any) (int, error)
- type Config
- type Filter
- type Printer
- type Renderer
- type Stringer
- type Value
Examples ¶
Constants ¶
const ( // DefaultZeroValueMarker is the default string to display when rendering a // zero-value struct. DefaultZeroValueMarker = "<zero>" // DefaultRecursionMarker is the default string to display when recursion // is detected within a Go value. DefaultRecursionMarker = "<recursion>" )
const DefaultIndent = " "
DefaultIndent is the default indent string used to indent nested values.
Variables ¶
var DefaultPrinter = Printer{ Config: Config{ Filters: []Filter{ StringerFilter, ErrorFilter, ProtoFilter, ReflectFilter, SyncFilter, TimeFilter, }, }, }
DefaultPrinter is the printer used by Write(), Format() and Print().
Functions ¶
func AsConcrete ¶ added in v0.5.0
AsConcrete returns a v as type T if its dynamic type is exactly T.
func AsImplementationOf ¶ added in v0.5.0
AsImplementationOf returns v as a value of type T if it directly implements T.
func ErrorFilter ¶ added in v0.5.0
ErrorFilter is a Filter that formats implementations of [error].
func Format ¶
Format returns a pretty-printed representation of v.
Example ¶
s := Format(123) fmt.Println(s)
Output: int(123)
func Print ¶ added in v0.2.0
func Print(values ...any)
Print writes a pretty-printed representation of v to os.Stdout.
Example ¶
Print(123, 456.0)
Output: int(123) float64(456)
func ProtoFilter ¶ added in v0.5.0
ProtoFilter is a Filter that formats implementations of proto.Message.
func ReflectFilter ¶ added in v0.5.0
ReflectFilter is a Filter that formats various types from the reflect package.
func StringerFilter ¶ added in v0.4.4
StringerFilter is a Filter that formats implementations of dapper.Stringer.
func SyncFilter ¶ added in v0.3.4
SyncFilter is a filter that formats various types from the sync package.
func TimeFilter ¶ added in v0.3.4
TimeFilter is a filter that formats various values from the time package.
Types ¶
type Config ¶ added in v0.4.0
type Config struct { // Filters is the set of filters to apply when formatting values. Filters []Filter // Indent is the string used to indent nested values. // If it is empty, DefaultIndent is used. Indent string // ZeroValueMarker is a string that is displayed instead of a structs field // list when it is the zero-value. If it is empty, DefaultZeroValueMarker is // used. ZeroValueMarker string // RecursionMarker is a string that is displayed instead of a value's // representation when recursion has been detected. // If it is empty, DefaultRecursionMarker is used. RecursionMarker string // OmitPackagePaths, when true, causes the printer to omit the // fully-qualified package path from the rendered type names. OmitPackagePaths bool // OmitUnexportedFields omits unexported struct fields when set to true OmitUnexportedFields bool }
Config holds the configuration for a printer.
type Filter ¶ added in v0.3.0
Filter is a function that provides custom formatting logic for a specific type or value.
The filter uses r to render v. If r is unused v is rendered using the default formatting logic.
type Printer ¶
type Printer struct { // Config is the configuration for the printer. Config Config }
Printer generates human-readable representations of Go values.
The output format is intended to be as minimal as possible, without being ambiguous. To that end, type information is only included where it can not be reliably inferred from the structure of the value.
Example ¶
type TreeNode struct { Name string Value any Children []*TreeNode } type NodeValue struct{} v := TreeNode{ Name: "root", Children: []*TreeNode{ { Name: "branch #1", Value: 100, }, { Name: "branch #2", Value: NodeValue{}, }, }, } p := Printer{} s := p.Format(v) fmt.Println(s)
Output: github.com/dogmatiq/dapper_test.TreeNode{ Name: "root" Value: nil Children: { { Name: "branch #1" Value: int(100) Children: nil } { Name: "branch #2" Value: github.com/dogmatiq/dapper_test.NodeValue{} Children: nil } } }
type Renderer ¶ added in v0.5.0
type Renderer interface { io.Writer Config() Config FormatType(Value) string WriteType(Value) WriteValue(Value) FormatValue(Value) string Indent() Outdent() Print(format string, args ...any) WithModifiedConfig(func(*Config)) Renderer }
Renderer is an interface for rendering human-readable representations of arbitrary values.
type Stringer ¶ added in v0.4.4
type Stringer interface {
DapperString() string
}
Stringer is an interface for types that produce their own Dapper representation.
type Value ¶ added in v0.3.0
type Value struct { // Value is the value to be formatted. Value reflect.Value // DynamicType is the value's type. DynamicType reflect.Type // StaticType is the type of the "variable" that the value is stored in, // which may not be the same as its dynamic type. // // For example, when formatting the values within a slice of "any" // containing integers, such as []any{1, 2, 3}, the DynamicType will be // "int", but the static type will be "any". StaticType reflect.Type // IsAmbiguousDynamicType is true if the value's dynamic type is not clear from // the context of what has already been rendered. IsAmbiguousDynamicType bool // IsAmbiguousStaticType is true if the value's static type is not clear from // the context of what has already been rendered. IsAmbiguousStaticType bool // IsUnexported is true if this value was obtained from an unexported struct // field. If so, it is not possible to extract the underlying value. IsUnexported bool }
Value contains information about a Go value that is to be formatted.
func (*Value) IsAmbiguousType ¶ added in v0.3.0
IsAmbiguousType returns true if either the dynamic type or the static type is ambiguous.
func (*Value) IsAnonymousType ¶ added in v0.3.0
IsAnonymousType returns true if the value has an anonymous type.