How to re-parse (or re-map) character '.' to user-defined function

Question

The default behavior of the character . between two non-numeric characters is to be interpreted as the infix of the Mathematica function Dot.

Is there a command that can be placed in a package to get the front-end to parse . as an infix for another function -- say user-defined one, myDot[]?

That is,

1. a.b should be interpreted as myDot[a, b]

2. myDot[a.b] should map to a.b

3. Dot[a,b] should not get mapped to a.b, but the functionality of the built-in function Dot should not be lost.

4. 3.14 should remain a single number, where here the dot indicates a decimal separator.

Answer 1

Updated

First, let's stop Dot from creating these box structures.

MakeBoxes[Dot[x__], form_] := 
 RowBox[{"Dot", "[", RowBox@Riffle[MakeBoxes /@ {x}, ","], "]"}]

Next, let's specify that these structures should instead be interpreted as myDot:

MakeExpression[RowBox@(row : {PatternSequence[_, "."] .., _}), form_] := 
 MakeExpression[
  RowBox@{"myDot", "[", RowBox@Riffle[row[[1 ;; -1 ;; 2]], ","], "]"}, form]

The slicing and riffling is ugly... there is probably a cleaner way to do it. ReplacePart seemed to be doing weird things when I tried it but I didn't spend any time on it.

The last step is to specify that myDot should also be rendered into the same structure:

MakeBoxes[myDot[x__], form_] := RowBox@Riffle[MakeBoxes /@ {x}, "."]

Now,

Dot[a, b, c]

Dot[a, b, c]

Dot[{a, b, c}, {x, y, z}]

a x + b y + c z

a.b.c

a.b.c

a.b.c // FullForm

myDot[a, b, c]

{a, b, c}.{x, y, z} // InputForm

myDot[{a, b, c}, {x, y, z}]

a.(b^2).c

a.b².c

% // InputForm

myDot[a, b^2, c]

In all cases you will have to use MakeExpression to override the interpretation of user input, but you may also find TagBox and InterpretationBox interesting alternatives to the MakeBoxes implementations above.

Answer 2

I am guessing that you intend for a transformation into myDot[a, b] rather than myDot[a.b] and I will answer accordingly. Different output formatting would remain possible.

There is not much that you can do to affect the parsing of code as that is handled by the Front End before even CellEvaluationFunction is called. To see how an expression is parsed you may use the method given by John Fultz in answer to my question:

• How can I get the unchanged Box form of an arbitrary expression?

For example:

parseString[s_String, prep : (True | False) : True] := 
  FrontEndExecute @ UndocumentedTestFEParserPacket[s, prep]

"3.14 + foo.bar / 22 - Dot[x,y]" // parseString

{BoxData[RowBox[{"3.14", "+", RowBox[{RowBox[{"foo", ".", "bar"}], "/", "22"}], "-", 
    RowBox[{"Dot", "[", RowBox[{"x", ",", "y"}], "]"}]}]], StandardForm}

We can see that foo.bar is already parsed differently from 3.14 and Dot[x,y] therefore, fortunately, we do not need to change parsing to effect your modification. Instead we can operate on this Box data.

Here is a basic implementation using $PreRead:

symbolQ[s_String] := MatchQ[ToHeldExpression@s, Hold[_Symbol]]

$PreRead = # /. 
    RowBox[{a_?symbolQ, ".", b_?symbolQ}] :> 
     RowBox[{"myDot", "[", RowBox[{a, ",", b}], "]"}] &;

Now:

3.14 + foo.bar / 22 - Dot[x, y]

3.14 - x.y + 1/22 myDot[foo, bar]

If you want to add output formatting for myDot please read:

• How can one define a custom data object?

Then ask for help as needed.

Answer 3

I guess this is too easy, but \[CenterDot], or Esc.Esc, is all set up for use as an infix operator, with no need to mess with box structures or confuse the user by changing the built-in meaning of ..

You can just set

CenterDot = myDot

and then call

a·b
(* myDot[a, b] *)