Safe alternatives to ToExpression

Question

Background

Conversion from string/boxes to expression is quite common. Very often the goal would be a simple switch from "1" to 1. Or "foo" to foo

Mindless ToExpression can lead to evaluation caused by unexpected input or by someone's bad will. E.g. 1 + ToExpression["1"] is fine but 1 + ToExpression["Quit[]"] not anymore.

Ideally the function's signature should be foo[_String] -> _expectedHead | $Failed. But unevaluated will do too.

Example

An example could be Symbol returning symbols of strings containing valid symbol's names. If we need $Failed it could be enhanced

Symbol[str] /. Verbatim[Symbol][_String] -> $Failed

Questions

What other alternatives are there?

What if there is no alternative and we need to cook up a custom interpreter? Can we do better than:

Interpreter["Integer"] @ "Evaluate @ Print[1]"

or

ToExpression["1+1", StandardForm, HoldComplete] // 
  Replace[HoldComplete[Except[_Integer]] -> {$Failed}] // First

Answer 1

This is too long to fit in a comment so I post it as an answer, sorry.

The last example provided in the question seems already very effective and useful to me. What are the shortcomings of this method that made you look for a different one? Is it unsafe? Not generic enough? Too slow?

It can also be extended to allow for more heads, like:

ToExpressionSafer[string_String] := ReleaseHold@Replace[
   ToExpression[string, StandardForm, HoldComplete],
   {h : _Plus | _Times | _Integer | _Real :> h, _ -> $Failed},
   Infinity
 ]

In[]:= ToExpressionSafer["1+2"]
(* 3 *)

In[]:= ToExpressionSafer["1+2*4+8.5"]
(* 17.5 *)

In[]:= x = 100;
ToExpressionSafer["1+x"]
(* 1 + $Failed *)

In[]:= ToExpressionSafer["Quit[]"]
(*$Failed*)

Some timings:

ToExpressionSafer["12.5"]; // TimeIt
(* 4.9 * 10^-5 *)

ToExpression["12.5"]; // TimeIt
(* 5.9 * 10^-6 *)

Internal`StringToDouble["12.5"]; // TimeIt
(* 4.0 * 10^-7 *)

For this simple string to real conversion, the methods become one order of magnitude slower for each increase in complexity and error checking. That seems quite reasonable to me.

Answer 2

In more recent versions (certainly in 13.3), there is an Interpreter type of "ComputedNumber" which I think achieves your desired goals:

(* evaluate simple arithmetic expressions *)
In[4]:= Interpreter["ComputedNumber"]["1+1"]

Out[4]= 2


(* Non-numeric computations give a Failure *)
In[5]:= Interpreter["ComputedNumber"]["1+Quit[]"]

Out[5]= Failure["RestrictionFailure", <|
 "MessageTemplate" :> MessageName[Interpreter, "number"], 
  "MessageParameters" -> <|"Input" -> "1+Quit[]"|>, "Input" -> 
  "1+Quit[]"|>]


(* Yet, you can still compute more complicated expressions *)

In[6]:= Interpreter["ComputedNumber"]["1+Sin[3.2 Pi]"]

Out[6]= 0.412215


(* ComputerNumber has access to expressions outside of the input scope, so long as they compute a number *)

In[7]:= a = {1, 2, 3};
Interpreter["ComputedNumber"]["1+a[[2]]+a[[3]]"]

Out[7]= 6
```