Make my data-structure atomic

Question

Lately, and by lately I mean since version 7 or so, the number of atomic expressions in Mathematica constantly grew. In former times only the native types like integers and optimised arrays were atomic, but now we have Image, Graph, Association and many more.

The reason for this is mostly to make those structures highly performant. The big disadvantage is that it is not instantly visible what is atomic and that things like pattern matching, replacing, etc. don't work with them. A simple example is

Image[{{1, 0}, {0, 1}}] /. {0 :> {0, 1, 0}, 1 :> {1, 0, 0}}

The result is still a b/w image. When pattern matching doesn't work, I often give people the tip to look at the FullForm, but that doesn't help either. Those expressions look like something they are not.

Beside this obvious break with the one of the basic Mathematica paradigms, atomic expressions have advantages. One of those applications is when you use container expressions to store important information that should never be changed manually or bad things will happen. Let me give a simple example:

Assume you have a C++ library you use to calculate something and you need to manage a global object there. This object needs to stay alive for several callbacks from Mathematica. An easy way to achieve this is to not delete it and give a pointer to the object to Mathematica. So in Mathematica we have something like

LibraryObject[ptr->123456,state->"Initialised"]

Everyone should see that it is vitally important that no one changes the ptr to the object or the state. Therefore my question

Is it possible to make LibraryObject atomic like Image and protect it from access through [[]] from other changes?

Answer 1

Yes. Use

System`Private`SetNoEntry 

on any expression which you want to protect in this manner. This works on per-expression basis, so you have to apply this function to any instance which you want to protect. The result is a reference to the same expression.

The changes are performed in-place (no copy is created):

expr = h[1, 2, 3]

(* h[1, 2, 3] *)

AtomQ[expr]

(* False *)

System`Private`SetNoEntry[expr]

(* h[1, 2, 3] *)

AtomQ[expr]

(* True *)

This property belongs only to an expression to which the function was applied (of course, that extends to all places where you pass the reference to this expression). If you create a new expression with the same contents, you will have to perform the same procedure on it again. I stressed this subtlety, because we got used to think of expressions as stateless and immutable, but this particular operation actually mutates the expression (internally) and changes its internal state.