Implementing Rust's dbg! in Python (rtpg.co)

I use icecream [1] for the same purpose while debugging. It's really handy.

[1] https://github.com/gruns/icecream

Title should definitely have `dbg!` in it rather than "Dbg"

Rust's dbg! is one of those ideas that felt obvious and beautiful once I saw it.

Apparently it's inspired by Haskell.[0] I'd love to see it officially picked up in other languages.

[0] https://rust-lang.github.io/rfcs/2361-dbg-macro.html#prior-a...

    let x = y + z;

    let x = dbg!(y) + z;

    let c = dbg!(dbg!(a) + dbg!(b));

    #include <iostream>
    #include <string>

    template<typename T>
    T print_dbg(T val, std::string exp, std::string file, int line) 
    {
        std::cerr << exp << " = " << val << " @ " << file << ":" << line << "\n";
        return val;
    }

    #define dbg(x) print_dbg(x,#x,__FILE__,__LINE__)

    double c = dbg(dbg(a) + dbg(b));

    a = 1 @ debug.cxx:16
    b = 2 @ debug.cxx:16
    dbg(a) + dbg(b) = 3 @ debug.cxx:16

    double dbg(c) = dbg(a) + dbg(b);

Here's a lib with similar functionality: https://github.com/alexmojaki/snoop

Python now as a semi-shortcut for this (just add = to the end of any f-string expression):

In [8]: print(f'{foo.bar[1]=}') foo.bar[1]='2'

You can do more complex expressions:

In [9]: f'{1+1=}' Out[9]: '1+1=2'

It's not quite as fluid as dbg!(), but it's nice.

Might be worth mentioning that you do not have to resort to printf debugging in Rust or python; both languages have good ide debugger support. I use python and rust together professionally.

The one thing I wasn't sure that I liked with rust's dbg! is that I was typically passing the argument by value, but that sometimes works and sometimes fails the borrow checker. But now reading https://github.com/rust-lang/rust/issues/59943 I see that this is a feature -- I hadn't been taking advantage of the fact that you can use dbg! inline; I'd just been adding extra dbg!(foo) lines to the code. So I should probably (a) pass by reference always and (b) look our for where inline dbg! might be useful (probably lots).

I created a similar macro in C++, it had the ability to show the function name in addition to the file name

I dont get, isn't this just grabbing the filename (which has a built-in double underscore file variable), and the line number (e.g. https://code.activestate.com/recipes/145297-grabbing-the-cur...)

not to mention you can run via pdb and display or stop at points of interest.

what am I missing?

While I realize we don't always have a logger wired up, it's also easy to implement this in standard logging.

%(filename_lineno)s will give you the filename and line.

Typo in your first eval example:

    >>> foo = {
    ...     'bar': 3
    ... }
    >>> print(eval("foo['bar'[]"))
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<string>", line 1
        foo['bar'[]
                  ^
    SyntaxError: unexpected EOF while parsing

My personal experience is that doing println/dbg based debugging in python is most times a bad idea and does wast time.

Ironically my experience with rust is the opposite, i.e. not using println/dbg debugging is most times does wast time. (Except if you do certain thinks with unsafe code).

The difference is I guess that in rust I normally encode much more simple invariant in the type system and as such most times a bug happens I often can pin-down it's rough position by the way it appears (i.e. panics/errors not subtle timing bugs). In turn I just need to get a nice formatted printout of this one or two values. Instead of having to consider all the other ways things might have cone wrong in python which can't happen in rust (through python3's type annotation + linting can help).

You don't need IPython for startup scripts... https://docs.python.org/3/library/site.html

Another somewhat similar Python library, but logs to a /tmp file: https://github.com/zestyping/q