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/bingoohuang/q/pretty"
)
func main() {
type myType struct {
a, b int
}
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 ¶
- 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 Indent(s, prefix string) string
- func IndentBytes(b, prefix []byte) []byte
- func Ldiff(l Logfer, a, b interface{})
- func Log(a ...interface{})
- func Logf(format string, a ...interface{})
- func Logln(a ...interface{})
- func NewIndentWriter(w io.Writer, pre ...[]byte) io.Writer
- 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 ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
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 ¶
Errorf is a convenience wrapper for fmt.Errorf.
Calling Errorf(f, x, y) is equivalent to fmt.Errorf(f, Formatter(x), Formatter(y)).
func 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 ¶
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 Indent ¶
Indent inserts prefix at the beginning of each non-empty line of s. The end-of-line marker is NL.
func IndentBytes ¶
IndentBytes inserts prefix at the beginning of each non-empty line of b. The end-of-line marker is NL.
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 NewIndentWriter ¶
NewIndentWriter makes a new write filter that indents the input lines. Each line is prefixed in order with the corresponding element of pre. If there are more lines than elements, the last element of pre is repeated for each subsequent line.
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 ¶
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 ¶
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 ¶
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".
Source Files