What is the most convenient way to read definitions of in-memory symbols when we don't have the source files? (Spelunking tools)

Question

Note: I put Simon's implementation on GitHub. Contributions welcome!

---

When trying to read the definition of already defined (package or built-in) symbols using Information or FullDefinition, the biggest inconvenience is that lots of distracting private context names appear in front of all symbol names.

Currently I am using a little function contextFreeDefinition[] to avoid this problem. It will attempt to hide the most frequently appearing context name in the definition. contextFreeDefinition[] is based on this answer.

Compare for example ClearAttributes[RunThrough, ReadProtected]; Information[RunThrough] and contextFreeDefinition[RunThrough]. The latter is a lot less cluttered because the System`Dump` context is hidden in the definition. (I usually paste the output of this function into Workbench and re-indent it using the Source -> Format context menu item for better readability)

---

Unfortunately contextFreeDefinition[] does not always successfully hide contexts, for example try the following:

ImportString["1", "List"]; (* force Stub symbols to be loaded *)

System`Convert`TableDump`ImportList // contextFreeDefinition

and notice that several symbols (especially patterns) still have System`Convert`TableDump` prepended. For example, I see the following in the FullDefinition it prints:

protectRegEx[System`Convert`TableDump`s_String] := 
     StringReplace[System`Convert`TableDump`s, $ProtectedCharacterRules]

The symbol System`Convert`TableDump`s still has the context name prepended even though the function tried to hide exactly this context.

Question: How can contextFreeDefinition[] be fixed so it always hides the context, or what other alternative approaches are there to read the definitions of in-memory symbols?

---

The code of contextFreeDefinition[].

Clear[commonestContexts, contextFreeDefinition]

commonestContexts[sym_Symbol, n_: 1] := Quiet[
  Commonest[
   Cases[Level[DownValues[sym], {-1}, HoldComplete], 
    s_Symbol /; FreeQ[$ContextPath, Context[s]] :> Context[s]], n],
  Commonest::dstlms]

contextFreeDefinition::contexts = "Not showing the following contexts: `1`";

contextFreeDefinition[sym_Symbol, contexts_List] := 
 (If[contexts =!= {}, Message[contextFreeDefinition::contexts, contexts]];
  Internal`InheritedBlock[{sym}, ClearAttributes[sym, ReadProtected];
   Block[{$ContextPath = Join[$ContextPath, contexts]}, 
    Print@InputForm[FullDefinition[sym]]]])

contextFreeDefinition[sym_Symbol, context_String] := 
 contextFreeDefinition[sym, {context}]

contextFreeDefinition[sym_Symbol] := 
 contextFreeDefinition[sym, commonestContexts[sym]]

---

Understanding and using the function:

commonestContexts[sym, n] will find the n most frequently used contexts that are not in $ContextPath in the definition of symbol sym.

contextFreeDefinition[sym] will print the FullDefinition of sym, hiding the commonest context that would appear there. It will also issue a message with the name of the context being hidden.

contextFreeDefinition[sym, {"Context1`", "Context2`", ...}] will try to hide an explicitly given list of contexts.

Answer 1

Link to the code on GitHub

---

I have been using this. It's mostly Leonid's code from the stackoverflow question you linked to, but it uses Definition instead of DownValues. Symbol names are printed without any context, but the full symbol name is put into a Tooltip so you can always find out what context a symbol is in.

Update

FullDefinition[symbol] claims to "print the definitions given for symbol, and all symbols on which these depend", but sometimes one wants to explore deeper than the first level of dependency. Here is a version of Spelunk which uses plain Definition instead of FullDefinition, but allows you to click on symbols in the definition to get their definition. So you can dig right down into the dependency chain.

Update 2

The code now copes with definitions containing strings with backticks in, and cases where Definition throws an error.

Also, it now works for symbols which have OwnValues, e.g. Internal`$VideoEncodings.

BeginPackage["Spelunk`"];

Spelunk::usage = "Spelunk[symbol]";

Begin["`Private`"];

defboxes[symbol_Symbol] := Hold[symbol] /. _[sym_] :>
        If[MemberQ[Attributes[sym], Locked], "Locked",
          Internal`InheritedBlock[{sym},
            Unprotect[sym]; ClearAttributes[sym, ReadProtected];
            Quiet@Check[ToBoxes[Definition@sym], "DefError"] /. 
            InterpretationBox[a_, b___] :> a ]];

defboxes[s_String] := defboxes[#] &@ToExpression[s, InputForm, Unevaluated]

prettyboxes[boxes_] := 
  boxes /. {" "} -> {"\n-----------\n"} //. {RowBox[{left___, ";", 
       next : Except["\n"], right___}] :> 
     RowBox[{left, ";", "\n", "\t", next, right}], 
    RowBox[{sc : ("Block" | "Module" | "With"), "[", 
       RowBox[{vars_, ",", body_}], "]"}] :> 
     RowBox[{sc, "[", RowBox[{vars, ",", "\n\t", body}], "]"}]};

fancydefinition[symbol_Symbol] :=
  Cell[BoxData[
    prettyboxes[
     defboxes[symbol] /. 
      s_String?(StringMatchQ[#, __ ~~ "`" ~~ __] &) :> 
       First@StringCases[s, 
         a : (__ ~~ "`" ~~ b__) :> processsymbol[a, b]]]], "Output", 
   Background -> RGBColor[1, 0.95, 0.9],
   CellGroupingRules->"OutputGrouping",
   GeneratedCell->True,
   CellAutoOverwrite->True,
   ShowAutoStyles->True,
   LanguageCategory->"Mathematica",
   FontWeight->"Bold"
];

processsymbol[a_, b_] := Module[{db},
  Which[
   ! StringFreeQ[a, "\""], a,
   ! StringFreeQ[a, "_"] || (db = defboxes[a]) === "Null", 
   TooltipBox[b, a],
   db === "Locked", TooltipBox[b, a <> "\nLocked Symbol"],
   db === "DefError", TooltipBox[b, a <> "\nError getting Definition"],
   True, ButtonBox[TooltipBox[b, a], ButtonFunction :> Spelunk@a, 
    BaseStyle -> {}, Evaluator -> Automatic]]]

Spelunk[symbol_Symbol] := CellPrint[fancydefinition[symbol]];

Spelunk[s_String] := CellPrint[fancydefinition[#] &@ToExpression[s, InputForm, Unevaluated]];

SetAttributes[{defboxes, fancydefinition, Spelunk}, HoldFirst] 

End[];

EndPackage[];

Answer 2

In version 10.1, I've built something like Spelunk into GeneralUtilities`.

To use it, run

Needs["GeneralUtilities`"]
PrintDefinitions[symbol];

This will pop up a window that shows all definitions of symbol. Here is a short summary of features:

• The window shows code cells containing all DownValues, OwnValues, UpValues, SubValues, and Attributes of a symbol.
• Most pathological kinds of StandardForm are avoided, so that Image, Graphics, Row, Column, SparseArray, etc. will show up as code, not UI elements. This is achieved via the PlainForm and CodeForm wrappers, which can also be found in GeneralUtilities`.
• Hyperlinks are be injected as appropriate. Click on a hyperlinked symbol to print its definitions in a new window.
• The CellContext of each code cell is set to reduce the amount of clutter from fully qualified private symbols. For symbols outside this context, the name is shown, the fully qualified name is tooltipped, and color coding is used: symbols in conventional private contexts like `Private` are brown/orange; system symbols are black; other symbols are dark gray if on the context path, otherwise light gray.

Here's a simple example of PrintDefinitions running on itself:

Answer 3

I can now offer a solution which leverages the full power of the code formatter, in its new, more robust form.

Load the formatter:

Import["https://raw.github.com/lshifr/CodeFormatter/master/CodeFormatter.m"]

Some examples:

CodeFormatterSpelunk[RunThrough]

CodeFormatterSpelunk[PacletManager`CreatePaclet]

In the last example, using MakeBoxes would produce a slightly better result:

CodeFormatterSpelunk[PacletManager`CreatePaclet, MakeBoxes]

CodeFormatterSpelunk[PacletManager`PackPaclet]

Answer 4

Since nobody has mentioned it yet...

V8 introduced the undocumented flag Debug`$ExamineCode. When it is set to true, the information functions will display the definitions of ReadProtected symbols:

Debug`$ExamineCode = True
??BinLists

It is sometimes useful to suppress some of the internal package names to make it easier to scan the definitions. Here is a quick-and-dirty way to do it:

Block[
  { $ContextPath = {"System`", "Internal`", "Statistics`BinningDump`"}
  , Debug`$ExamineCode = True
  }
, RawBoxes @ ToBoxes @ Information[BinLists]
]

Here, the $ContextPath is carefully chosen to include package names I do not want to see. This, of course, can be automated but as that is the subject of other answers I will pass over it here.

Answer 5

I would just use strings, for all their fragility:

ClearAll[print];
print[sym_, {conts_String}] :=
 With[{altptrn =  Alternatives @@ Reverse[SortBy[{conts}, StringLength]]},
    Print@StringReplace[ToString[InputForm@FullDefinition@sym],
         (x : (_ | "") ~~ altptrn ~~ y : (_ | "")) /; ! (x === "\"" && y === "\"") :> 
            StringJoin[x, y]]]

contextFreeDefinition[sym_Symbol, contexts_List] :=
 (
    If[contexts =!= {}, Message[contextFreeDefinition::contexts, contexts]];
    print[sym, contexts]
 );

Note that my code to protect against modifications inside strings is not quite robust. But, if needed, it can be easily made more robust by preprocessing the string.

Answer 6

I have not tested this yet but here is one possible approach:

contextFreeDefinition[sym_Symbol, contexts_List] :=
 Internal`InheritedBlock[{sym},
  ClearAttributes[sym, ReadProtected];
  If[contexts =!= {}, Message[contextFreeDefinition::contexts, contexts]];
  Block[{ipf = ToString @ InputForm @ FullDefinition @ sym},
   ipf = MakeExpression@StringSplit[ipf, "\n"] /. HoldComplete[Null] -> "";
   ipf /. x_Symbol /; MemberQ[contexts, Context[x]] :>
     With[{eval = StringDrop[ToString@Unevaluated@x, StringLength@Context@x]},
         eval /; True]
     /. HoldComplete -> HoldForm // Column
   ]
  ]

(sorry for the messy formatting)

Please point out all failings and I shall see if this is redeemable tomorrow.

Answer 7

This answer addresses hiding the context marks only, not spelunking. You could use the following functions to view output without contexts marks:

SetAttributes[{ContextFreeForm, ContextFreeInformation}, HoldAll]

ContextFreeForm /: MakeBoxes[ContextFreeForm[expr_], form_] := Block[
    {Internal`$ContextMarks=False},

    MakeBoxes[expr, form]
]

ContextFreeInformation[expr_] := With[
    {name = ToString[Unevaluated @ expr, InputForm]},

    Block[{Internal`$ContextMarks = False}, Information[name]]
]

First, here is the definition of System`Convert`TableDump`ImportList viewed using ContextFreeForm:

ContextFreeForm @ Definition @ System`Convert`TableDump`ImportList

ImportList[file_String,opts___]:=Block[{listsep},listsep=LineSeparators/. {opts}/. Options[ImportList];If[!ListQ[listsep],listsep={listsep}];Data->Flatten[Last[ImportTable[file,LineSeparators->listsep,FieldSeparators->listsep,RepeatedSeparators->False,opts]],1]]

Options[ImportList]={LineSeparators->{

, , , }}

For Information (i.e., ?symbol) there is no output, the definition is displayed as a side effect, so a different function is needed:

ContextFreeInformation @ System`Convert`TableDump`ImportList

System`Convert`TableDump`ImportList

ImportList[file_String,opts___]:=Block[{listsep},listsep=LineSeparators/. {opts}/. Options[ImportList];If[!ListQ[listsep],listsep={listsep}];Data->Flatten[Last[ImportTable[file,LineSeparators->listsep,FieldSeparators->listsep,RepeatedSeparators->False,opts]],1]]

Options[ImportList]={LineSeparators->{

, , , }}

It is also possible to just set Internal`$ContextMarks = False globally, but that can have issues (e.g., Information[System`Convert`TableDump`ImportList] will no longer work).