pretty: github.com/kr/pretty Index | Examples | Files

package pretty

import "github.com/kr/pretty"

Package pretty provides pretty-printing for Go values. This is useful during debugging, to avoid wrapping long output lines in the terminal.

It provides a function, Formatter, that can be used with any function that accepts a format string. It also provides convenience wrappers for functions in packages fmt and log.

Code:

type myType struct {
    a, b int
}
var x = []myType{{1, 2}, {3, 4}, {5, 6}}
fmt.Printf("%# v", pretty.Formatter(x))

Output:

[]pretty_test.myType{
    {a:1, b:2},
    {a:3, b:4},
    {a:5, b:6},
}

Index

Examples

Package Files

diff.go formatter.go pretty.go zero.go

func Diff Uses

func Diff(a, b interface{}) (desc []string)

Diff returns a slice where each element describes a difference between a and b.

func Errorf Uses

func Errorf(format string, a ...interface{}) error

Errorf is a convenience wrapper for fmt.Errorf.

Calling Errorf(f, x, y) is equivalent to fmt.Errorf(f, Formatter(x), Formatter(y)).

func Fdiff Uses

func Fdiff(w io.Writer, a, b interface{})

Fdiff writes to w a description of the differences between a and b.

func Formatter Uses

func Formatter(x interface{}) (f fmt.Formatter)

Formatter makes a wrapper, f, that will format x as go source with line breaks and tabs. Object f responds to the "%v" formatting verb when both the "#" and " " (space) flags are set, for example:

fmt.Sprintf("%# v", Formatter(x))

If one of these two flags is not set, or any other verb is used, f will format x according to the usual rules of package fmt. In particular, if x satisfies fmt.Formatter, then x.Format will be called.

func Fprintf Uses

func Fprintf(w io.Writer, format string, a ...interface{}) (n int, error error)

Fprintf is a convenience wrapper for fmt.Fprintf.

Calling Fprintf(w, f, x, y) is equivalent to fmt.Fprintf(w, f, Formatter(x), Formatter(y)).

func Ldiff Uses

func Ldiff(l Logfer, a, b interface{})

Ldiff prints to l a description of the differences between a and b. It calls Logf once for each difference, with no trailing newline. The standard library testing.T and testing.B are Logfers.

func Log Uses

func Log(a ...interface{})

Log is a convenience wrapper for log.Printf.

Calling Log(x, y) is equivalent to log.Print(Formatter(x), Formatter(y)), but each operand is formatted with "%# v".

func Logf Uses

func Logf(format string, a ...interface{})

Logf is a convenience wrapper for log.Printf.

Calling Logf(f, x, y) is equivalent to log.Printf(f, Formatter(x), Formatter(y)).

func Logln Uses

func Logln(a ...interface{})

Logln is a convenience wrapper for log.Printf.

Calling Logln(x, y) is equivalent to log.Println(Formatter(x), Formatter(y)), but each operand is formatted with "%# v".

func Pdiff Uses

func Pdiff(p Printfer, a, b interface{})

Pdiff prints to p a description of the differences between a and b. It calls Printf once for each difference, with no trailing newline. The standard library log.Logger is a Printfer.

func Print Uses

func Print(a ...interface{}) (n int, errno error)

Print pretty-prints its operands and writes to standard output.

Calling Print(x, y) is equivalent to fmt.Print(Formatter(x), Formatter(y)), but each operand is formatted with "%# v".

func Printf Uses

func Printf(format string, a ...interface{}) (n int, errno error)

Printf is a convenience wrapper for fmt.Printf.

Calling Printf(f, x, y) is equivalent to fmt.Printf(f, Formatter(x), Formatter(y)).

func Println Uses

func Println(a ...interface{}) (n int, errno error)

Println pretty-prints its operands and writes to standard output.

Calling Print(x, y) is equivalent to fmt.Println(Formatter(x), Formatter(y)), but each operand is formatted with "%# v".

func Sprint Uses

func Sprint(a ...interface{}) string

Sprint is a convenience wrapper for fmt.Sprintf.

Calling Sprint(x, y) is equivalent to fmt.Sprint(Formatter(x), Formatter(y)), but each operand is formatted with "%# v".

func Sprintf Uses

func Sprintf(format string, a ...interface{}) string

Sprintf is a convenience wrapper for fmt.Sprintf.

Calling Sprintf(f, x, y) is equivalent to fmt.Sprintf(f, Formatter(x), Formatter(y)).

type Logfer Uses

type Logfer interface {
    Logf(format string, a ...interface{})
}

type Printfer Uses

type Printfer interface {
    Printf(format string, a ...interface{})
}

Package pretty imports 7 packages (graph) and is imported by 563 packages. Updated 2018-01-13. Refresh now. Tools for package owners.