Function Repository Resource:

BlockProtected

Source Notebook

Modify definitions of protected symbols and ensure that their attributes are restored

Contributed by: Richard Hennigan (Wolfram Research)

ResourceFunction["BlockProtected"][{sym₁,sym₂,…},expr]

evaluates expr with symbols sym_i unprotected and restores their protected attribute before returning the result.

ResourceFunction["BlockProtected"][{…,sym_i=val_i,…},expr]

sets initial values for the sym_i.

ResourceFunction["BlockProtected"][{syms}]

represents an operator form of ResourceFunction["BlockProtected"] that can be applied to an expression.

Details

ResourceFunction["BlockProtected"] has the attribute HoldAll.

All the protected sym_i are unprotected before evaluating expr and reprotected before returning the result.

If a symbol sym_i is initially unprotected and becomes protected during evaluation of expr, it will be unprotected again when evaluation completes.

ResourceFunction["BlockProtected"][{syms}][expr] is equivalent to ResourceFunction["BlockProtected"][{syms},expr].

ResourceFunction["BlockProtected"] returns a Failure object for invalid argument patterns rather than remain unevaluated.

Examples

Basic Examples (2)

Modify the definition of a protected symbol:

In[1]:=

In[2]:=

Out[2]=

The value has changed:

In[3]:=

Out[3]=

The Protected attribute is restored:

In[4]:=

Out[4]=

Modify the definition of a protected function:

In[5]:=

In[6]:=

Out[6]=

The definition has changed:

In[7]:=

Out[7]=

Scope (3)

Modify multiple protected symbols:

In[8]:=

In[9]:=

Out[9]=

The definitions have changed:

In[10]:=

Out[10]=

In[11]:=

Out[11]=

Use an initial value:

In[12]:=

Out[12]=

In[13]:=

Out[13]=

Get the operator form of BlockProtected:

In[14]:=

count = 0;
Protect[count];
withCounter = ResourceFunction["BlockProtected"][{count}]

Out[14]=

Use the operator form:

In[15]:=

Out[15]=

The value of count was changed:

In[16]:=

Out[16]=

In[17]:=

Out[17]=

Create another operator form that initializes a value:

In[18]:=

Out[18]=

In[19]:=

Out[19]=

Now the value is always reset before evaluating:

In[20]:=

Out[20]=

Applications (2)

A protected symbol cannot usually be cleared:

In[21]:=

In[22]:=

Clear protected symbols with BlockProtected:

In[23]:=

The value is removed:

In[24]:=

Out[24]=

Write a protected function that caches results in its definition:

In[25]:=

$CachedResourceFunction[id_] := ResourceFunction["BlockProtected"][{CachedResourceFunction}, CachedResourceFunction[id] = ResourceFunction[id, "Function"] ];$

In[26]:=

The results are cached for faster subsequent evaluations:

In[27]:=

Out[27]=

In[28]:=

Out[28]=

The cached value is stored in the definition:

In[29]:=

Out[29]=

Having the symbol be protected avoids accidental modifications:

In[30]:=

In[31]:=

Out[31]=

Properties and Relations (4)

Only the Protected attribute is modified within BlockProtected:

In[32]:=

In[33]:=

Out[33]=

The attribute is restored when exiting BlockProtected:

In[34]:=

Out[34]=

If a symbol is protected when entering BlockProtected, it will be protected when exiting, even if all other definitions are cleared:

In[35]:=

Out[35]=

In[36]:=

Out[36]=

If a symbol is unprotected going into BlockProtected, it will be unprotected when coming out:

In[37]:=

In[38]:=

Out[38]=

In[39]:=

Out[39]=

BlockProtected will ensure that attributes for symbols are restored even if evaluation is interrupted:

In[40]:=

Unprotect[f]; ClearAll[f];
f[x_] := 1/x;
Protect[f];

In[41]:=

Out[41]=

In[42]:=

Out[42]=

In[43]:=

Catch[
ResourceFunction["BlockProtected"][{f}, Throw[f[0] = 0]]
]

Out[43]=

In[44]:=

Out[44]=

BlockProtected is functionally similar to using Unprotect and Protect around the evaluation:

In[45]:=

$modifyProtected // ClearAll; modifyProtected // Attributes = {HoldAll}; modifyProtected[f_, eval_] := Module[{result}, Unprotect[f]; result = eval; Protect[f]; result ];$