funcDiff¶

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

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

funcErrorf¶

func Errorf(formatstring, a ...interface{})error

Errorf is a convenience wrapper for fmt.Errorf.

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

funcFdiff¶

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

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

funcFormatter¶

func Formatter(x interface{}) (ffmt.Formatter)

Formatter makes a wrapper, f, that will format x as go source with linebreaks 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 willformat x according to the usual rules of package fmt.In particular, if x satisfies fmt.Formatter, then x.Format will be called.

funcFprintf¶

func Fprintf(wio.Writer, formatstring, a ...interface{}) (nint, errorerror)

Fprintf is a convenience wrapper for fmt.Fprintf.

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

funcLdiff¶

func Ldiff(lLogfer, 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.

funcLog¶

func Log(a ...interface{})

Log is a convenience wrapper for log.Printf.

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

funcLogf¶

func Logf(formatstring, a ...interface{})

Logf is a convenience wrapper for log.Printf.

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

funcLogln¶

func Logln(a ...interface{})

Logln is a convenience wrapper for log.Printf.

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

funcPdiff¶

func Pdiff(pPrintfer, 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.

funcPrint¶

func Print(a ...interface{}) (nint, errnoerror)

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

Calling Print(x, y) is equivalent tofmt.Print(Formatter(x), Formatter(y)), but each operand isformatted with "%# v".

funcPrintf¶

func Printf(formatstring, a ...interface{}) (nint, errnoerror)

Printf is a convenience wrapper for fmt.Printf.

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

funcPrintln¶

func Println(a ...interface{}) (nint, errnoerror)

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

Calling Println(x, y) is equivalent tofmt.Println(Formatter(x), Formatter(y)), but each operand isformatted with "%# v".

funcSprint¶

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

Sprint is a convenience wrapper for fmt.Sprintf.

Calling Sprint(x, y) is equivalent tofmt.Sprint(Formatter(x), Formatter(y)), but each operand isformatted with "%# v".

funcSprintf¶

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

Sprintf is a convenience wrapper for fmt.Sprintf.

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

typeLogfer¶

type Logfer interface {Logf(formatstring, a ...interface{})}

typePrintfer¶

type Printfer interface {Printf(formatstring, a ...interface{})}