Understanding Block and Definition

Question

The code

Block[{f}, f := test; Definition[f]]

Outputs Null. Why? I would have expected it to output the definition of f, like f := test; Definition[f] does.

---

Does it have to do with Definition being an output form. If so how can I get a function that does the exact same thing but that really evaluates to the value shown as output?

Answer 1

It does not work because Definition does not evaluate.

It is a wrapper which is formatted the way you are familiar with.

f:="test"

FullForm @ Definition[f]

Definition[f]

So during evaluation definitions are not (meant to be) collected, Block returns Definition[f] and later it is formatted to Null as our Block does not exist anymore.

Print workaround works because it forces print cell creation, so formatting and typesetting too, before Block is done. So definitions can be collected.

Another way to force formatting stage:

Block[{f}, f := test; ToString[Definition[f], InputForm]]

it is better than Print because the latter can be sent to the console, depending on your settings.

Answer 2

If you just need to get a cell that prints the definition of f while Blocked, you can use Print since Print will create the cell while f is still Blocked:

Block[{f}, f := test; Print[Definition[f]]]

Answer 3

I'm not entirely sure of what you are asking for, but here is a simple (and naive, it will probably not work on more complicated cases) way to convert the output of DownValues to a format similar to the output of Definition:

definitions[symb_Symbol] := DownValues @ symb /. {
    Verbatim[RuleDelayed][a_, b_] :> Hold[SetDelayed[a, b]]
    } /. Verbatim[HoldPattern][args__] :> args

for example:

foo[x_] := x + 2;
foo[x_List] := x + 3
foo[x_, y_] := x + y
definitions @ foo

produces

{Hold[foo[x_List] := x + 3], Hold[foo[x_] := x + 2], Hold[foo[x_, y_] := x + y]}

To also remove the Hold from the output you can use this other version:

definitions[symb_Symbol] := DownValues @ symb /. {
     Verbatim[RuleDelayed][a_, b_] :> Hold[SetDelayed[a, b]]
  } /. Verbatim[HoldPattern][args__] :> args /. {
     Hold[args__] :> Defer[args]
  }

Replacing DownValues with Definitions from GeneralUtilities should moreover generalise the function to also capture UpValues, OwnValues etc.