Re: Format[ ] with \[OverBracket] in a package `Private` context
- To: mathgroup at smc.vnet.net
- Subject: [mg56471] Re: Format[ ] with \[OverBracket] in a package `Private` context
- From: Maxim <ab_def at prontomail.com>
- Date: Tue, 26 Apr 2005 01:34:14 -0400 (EDT)
- References: <d4hvn9$1io$1@smc.vnet.net>
- Sender: owner-wri-mathgroup at wolfram.com
On Mon, 25 Apr 2005 05:37:45 +0000 (UTC), Trevor Baca <trevorbaca at gmail.com> wrote: > hello mathgroup, > > my goal is to format foo[_List] objects with an overscripted > \[OverBracket], and then shove this bit of code into a package for > later access. this does the trick in a notebook session: > > Format[foo[l_List]] := Overscript[RowBox[l], \[OverBracket]] // > DisplayForm; > > the interpreter now outputs foo[{2,3,4,5}] as 1 2 3 4 with a lovely > overbracket stretching across the top. so far so good. now the hard > part: shoving this bit of code into a package without context issues > getting in the way. > > (three example packages follow; feel free to skip to the section marked > "CONCLUSION" at the bottom for the actual question.) > > > ==== PROBLEM PACKAGE ================= > > BeginPackage["Foo`"] > > foo::usage="foo objects print with overbracket."; > > Begin["`Private`"] > > Format[foo[e_]]:=Overscript[RowBox[e],\[OverBracket]]//DisplayForm > > End[] > > EndPackage[] > > ==== end problem package ================ > > > with the problem package, i interpret the following three commands: > > Quit[ ] (* to clear out any previous definitions in any contexts *) > > << Foo` > > foo[{2,3,4,5}] > > ... and, unfotunately, foo[{2,3,4,5}] prints as 2 3 4 5 with the ugly > label Foo`Private`\[OverBracket] running across the top. not at all > what i wanted. first solution: > > > ==== SOLUTION PACKAGE 1: use System` context ========== > > BeginPackage["Foo`"] > > foo::usage="foo objects print with overbracket."; > > Begin["`Private`"] > > Begin["System`"] > > \[OverBracket] > > End[] > > Format[foo[e_]]:=Overscript[RowBox[e],\[OverBracket]]//DisplayForm > > End[] > > EndPackage[] > > ==== end solution package 1 ======================= > > > > with solution package 1, i again interpret the following three > commands: > > Quit[ ] (* to clear out any previous definitions in any contexts *) > > << Foo` > > foo[{2,3,4,5}] > > ... and this works: foo[{2,3,4,5}] now prints as 2 3 4 5 with the > overbracket running across the top, as desired. but i've introduced the > OverBracket symbol into the System` context directly; and is this a > generally bad practice? fearing that it might be, i build this second > solution: > > > ==== SOLUTION PACKAGE 2: use Foo` context ========== > > BeginPackage["Foo`"] > > foo::usage="foo objects print with overbracket."; > > \[OverBracket] > > Begin["`Private`"] > > Format[foo[e_]]:=Overscript[RowBox[e],\[OverBracket]]//DisplayForm > > End[] > > EndPackage[] > > ==== end solution package 2 ===================== > > > > with solution package 2, i interpret the following three commands one > last time: > > Quit[ ] (* to clear out any previous definitions in any contexts *) > > << Foo` > > foo[{2,3,4,5}] > > ... and this, too, works fine: foo[{2,3,4,5}] prints as 2 3 4 5 with > the requested overbracket. unfortunately, the OverBracket symbol now > lives in Foo`\[OverBracket], which somehow seems wrong to me, and > further seems to violate the spirit of the purpose of the public > section of a package ... introduce symbols "for export". > > > > CONCLUSION: so is it better to stick the OverBracket symbol into the > System` context (as in solution package 1), or to stick the OverBracket > symbol into the Foo` context (as in solution package 2), or to do > something else entirely? > > (i strongly prefer solution 1 (using the System` context) because it > seems bizarre to me that the OverBracket symbol doesn't already exist > in the System` context, so why not remedy the situation? on the other > hand, i could be convinced that messing with the System` context is as > bad an idea as messing with most reserved namespaces, hence solution 2. > but what i don't like about solution 2 is that after loading the > package, Names["Foo`*"] will give you both "foo" (which is good) and > "\[OverBracket]" (which just seems wrong)). > > anything to help make the decision or clean this up? > > > trevor. > It seems that symbols such as \[OverBracket] are created when they're used for the first time, and they obey the usual rules: first search the current context and $ContextPath for that symbol, and if it is not found, create it in the current context. Therefore, they always have the full name such as Global`\[OverBracket], but if their context is in the $ContextPath or is the same as the current context, then the context prefix is not shown. That is what happens in your examples: if you put the symbol in System` or in Foo`, then the context name is omitted, but Foo`Private`\[OverBracket] can be accessed only by its full name. You are correct that the simplest way seems to be just to put \[OverBracket] in the System` context by evaluating (System`\[OverBracket];) once, after which you can reference \[OverBracket] by the short name -- it will automatically be found in the System` context, which is still in $ContextPath within BeginPackage/EndPackage. Alternatively, you could reference the symbol as Global`\[OverBracket] every time it is used inside the package. A subtle point is that if you enter f + Ctrl-^ + Escape + ' + Escape to enter f' (with the \[Prime] symbol as Superscript) and evaluate it, the expression will be interpreted as Derivative[1][f] and the symbol Global`\[Prime] won't be created, but if you just evaluate Escape + ` + Escape, then the symbol will be created. I'm not sure how to state this rule in an exact way, but in any case it doesn't affect your case. Also I can't understand why with the definition Format[foo[l_List]] := Overscript[RowBox[l], \[OverBracket]] // DisplayForm foo[Table[i, {i, 3}]] and foo[Range[3]] are displayed differently -- in the second case the output will contain an explicit RowBox. Here's another way to define the same formatting rule: MakeBoxes[foo[L_List], form_] := OverscriptBox[ RowBox[ Function[b, MakeBoxes[b, form], HoldFirst] /@ Unevaluated@ L], \[OverBracket]] This will correctly display expressions such as foo[{EllipticE[0], EllipticE[1]}] // TraditionalForm // HoldForm. Maxim Rytin m.r at inbox.ru