q

README

Forked version... with changes not likely to be merged into original.

Added features I need:

• "leveled" logging via -ql which uses ast reflection to enable logs in only certain functions/pkgs
• turn all logs off with -ql. by default nothing printed via Q.
• output specified via -qo. -qo stdout, -qo stderr, -qo filename
• -qo xyz creates /tmp/xyz file
• -ql all turns on all q.Q messages
• -ql xyz turns on q.Q for functions or packages that contain string xyz
• -ql and -qo flags inserted at init()

Example for this forked version usage at qqtest/main.go

q

q is a better way to do print statement debugging.

Type q.Q instead of fmt.Printf and your variables will be printed like this:

Why is this better than fmt.Printf?

• Faster to type
• Pretty-printed vars and expressions
• Easier to see inside structs
• Doesn't go to noisy-ass stdout. It goes to $TMPDIR/q.
• Pretty colors!

Basic Usage

import "github.com/y0ssar1an/q"
...
q.Q(a, b, c)

// Alternatively, use the . import and you can omit the package name.
import . "github.com/y0ssar1an/q"
...
Q(a, b, c)

For best results, dedicate a terminal to tailing $TMPDIR/q while you work.

Install

go get -u github.com/y0ssar1an/q

Put these functions in your shell config. Typing qq or rmqq will then start tailing $TMPDIR/q.

qq() {
    clear
    local gpath="${GOPATH:-$HOME/go}"
    "${gpath%%:*}/src/github.com/y0ssar1an/q/q.sh" "$@"
}
rmqq() {
    if [[ -f "$TMPDIR/q" ]]; then
        rm "$TMPDIR/q"
    fi
    qq
}

Editor Integration

VS Code

Preferences > User Snippets > Go

"qq": {
    "prefix": "qq",
    "body": "q.Q($1) // DEBUG",
    "description": "Pretty-print to $TMPDIR/q"
}

Sublime Text

Tools > Developer > New Snippet

<snippet>
    <content><![CDATA[
q.Q($1) // DEBUG
]]></content>
    <tabTrigger>qq</tabTrigger>
    <scope>source.go</scope>
</snippet>

Atom

Atom > Open Your Snippets

'.source.go':
    'qq':
        'prefix': 'qq'
        'body': 'q.Q($1) // DEBUG'

vim/Emacs

TBD Send me a PR, please :)

Haven't I seen this somewhere before?

Python programmers will recognize this as a Golang port of the q module by zestyping.

Ping does a great job of explaining q in his awesome lightning talk from PyCon 2013. Watch it! It's funny :)

FAQ

Why q.Q?

It's quick to type and unlikely to cause naming collisions.

Is q.Q() safe for concurrent use?

Yes.

Documentation

Overview

Package q provides quick and dirty debugging output for tired programmers.

q.Q() is a fast way to pretty-print variables. It's easier than typing fmt.Printf("%#v", whatever). The output will be colorized and nicely formatted. The output goes to $TMPDIR/q, away from the noise of stdout.

q exports a single Q() function. This is how you use it:

import "github.com/y0ssar1an/q"
...
q.Q(a, b, c)

Index

• Variables
• func Q(v ...interface{})

Variables

var Level, Output string

Level can be set to limit output

Functions

func Q

func Q(v ...interface{})

Q pretty-prints the given arguments to the $TMPDIR/q log file.