pretty

README

package pretty

    import "github.com/kr/pretty"

    Package pretty provides pretty-printing for Go values.

Documentation

    http://godoc.org/github.com/kr/pretty

Documentation

Overview

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.

Example

package main

import (
	"fmt"
	"github.com/kr/pretty"
)

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

	var zeroedFields = []myType{{33, 0}, {a: 0, b: 34}}
	// Note the '+' in the format
	fmt.Printf("%# +v", pretty.Formatter(zeroedFields))
}

Output:

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

Index

• func Diff(a, b interface{}) (desc []string)
• func Errorf(format string, a ...interface{}) error
• func Fdiff(w io.Writer, a, b interface{})
• func Formatter(x interface{}) (f fmt.Formatter)
• func Fprintf(w io.Writer, format string, a ...interface{}) (n int, error error)
• func Ldiff(l Logfer, a, b interface{})
• func Log(a ...interface{})
• func Logf(format string, a ...interface{})
• func Logln(a ...interface{})
• func Pdiff(p Printfer, a, b interface{})
• func Print(a ...interface{}) (n int, errno error)
• func Printf(format string, a ...interface{}) (n int, errno error)
• func Println(a ...interface{}) (n int, errno error)
• func Sprint(a ...interface{}) string
• func Sprintf(format string, a ...interface{}) string
• type Logfer
• type Printfer

Examples

• Package

Functions

func Diff

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

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

func Errorf

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

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

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

func Formatter

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.

If the "+" flag is provided, zero-valued structure fields will be omitted. For example:

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

func Fprintf

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

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

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

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

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

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

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

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

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

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

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

func Sprint

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

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)).

Types

type Logfer

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

type Printfer

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