How to sort the functions in a Package?

Question

Once a Package like abc` has been installed, we can use "?abc`*" to scan all the functions defined in this Package. Now I write a Package(abc`). After I have installed it, I use ?abc`* to scan the functions. But the function list is out-of-order. How can I set the function list to alphabetical order using ?abc`* ?

Answer 1

Description

• ? at the beginning of a line is the short from of Information.

• Given a pattern that matches multiple Symbols Information returns a list of them in alphabetical (canonical) order, in columns top to bottom and left to right. You are therefore asking how you can modify the behavior of this System function.

• You would need some way of storing the order that you wish to have these Symbol links displayed in.

Observations

The documentation for Names says:

• Names["string"] gives the same list of names as ?string.

In fact testing indicates that Names is directly used by Information to retrieve the list of Symbol names:

Block[
 {Names = {"Plus", "Times", "Divide"} &},
 Information["IAmABanana`*"]
]

We see that the Symbol links returned can be changed by manipulating Names, but we also see that the ordering remains so it is separate from Names functionality. Looking for a Sort operation with TracePrint reveals only one call:

TracePrint[
  Block[{Names = {"Plus", "Times", "Divide"} &}, Information["IAmABanana`*"]];,
  _Sort
]

Sort[{{Plus,System`},{Times,System`},{Divide,System`}},System`Dump`orderfun]

It seems logical that if we can replace System`Dump`orderfun we should control the output order of Information. (Sort is used by other internal functions during the call so we cannot Block it.)

Solution

A robust approach is to create specific ordering rules for the System`Dump`orderfun function as this will allow custom ordering of even partial results.

The implementation is complex enough to justify a function to set the needed definitions:

addSymbolOrdering[context_String, names : {__String}] :=
  With[{pos = PositionIndex[names]},
    PrependTo[DownValues[System`Dump`orderfun],
      HoldPattern[System`Dump`orderfun[{a_, context}, {b_, context}]] :> 
        OrderedQ[pos /@ {a, b}]
    ];
  ]

Example of use:

addSymbolOrdering["foo`", {"one", "two", "three", "four", "five"}]

Context symbols may be defined before or after that use.

foo`one; foo`two; foo`three; foo`four; foo`five; foo`bar;

Note that an additional Symbol, bar, is included here but not in the ordering list. This is to demonstrate that additional (or missing) names do not cause error; they will be placed at the end, though that could be changed if desired.

Example:

?foo`*

You will also find that ?foo`t* or ?foo`f* will produce the correct output, with only the matching names listed and in the correct order.

Additionally because we are setting rules on the ordering function that is used for all calls to Information this order will be used even for mixed results. (For this example make sure that you do not still have the definition from Solution 1 loaded.)

abc`one; abc`two; abc`three; abc`four; (* same names in a different context *)

?@@@`t*

Note that the custom ordering only affects the Symbol names in the specified context; those in abc` are returned in alphabetical order.