Question

I’m looking for data structure with the following features or way to emulate it in Clojure (via http://www.erlang.org/course/advanced.html#refs):

References are erlang objects with exactly two properties:

They can be created by a program (using make_ref/0), and,
They can be compared for equality.

Erlang references are unique, the system guarantees that no two references created by >different calls to make_ref will ever match. The guarantee is not 100% – but differs from >100% by an insignificantly small amount :-).

and particularly Name data type from Oz language (http://www.mozart-oz.org/documentation/tutorial/node3.html):

The only way to create a name is by calling the procedure {NewName X} where X is assigned >a new name that is guaranteed to be worldwide unique. Names cannot be forged or printed.

While “unforgeable” value sounds suspicious, especially in dynamic language like Clojure this is what I am looking for. Van Roy uses this feature in CTM to create so called “secure data structures” and later on, for secure token shared between trusted entities in code:

declare NewWrapper in
proc {NewWrapper ?Wrap ?Unwrap} 
    Key={NewName} 
in 
    fun {Wrap X} 
            fun {$ K} if K==Key then X end end
    end 
    fun {Unwrap C} 
            {C Key}
    end 
end

% A secure declarative unbundled Stack
declare NewStack Push Pop IsEmpty in
local Wrap Unwrap in
    {NewWrapper Wrap Unwrap}
    fun {NewStack} {Wrap nil} end
    fun {Push S E} {Wrap E|{Unwrap S}} end
    fun {Pop S E}
        case {Unwrap S} of X|S1 then E=X  {Wrap S1} end
    end
    fun {IsEmpty S} {Unwrap S}==nil end
end

Can this behavior be emulated in Clojure? This way I can assure e.g. that programmer can unwrap a data structure if and only if I have granted him a token. I am aware that it can be insecure nonetheless I would like to find the solution that is functionally equivalent to Van Roy one’s and at least hard to circumvent by programmer.

The next requirement would be to base on pure Clojure and not JVM magic – so no “token = new Object()” etc. For example, function value looks like a good candidate because AFAIK after (defn f [] nil) then (identical? f x) evaluates to true only for x=f and and f is not a subject to memory optimizations like other constructs in functional language (or is it?). However, this approach may have further consequences I am not aware of. Could {NewName} from the above example could be just replaced with new anonymous function (provided non-distributed environment)?

Answer 1

gensym is guaranteed to produce a unique symbol that can be used to name things.

user> (gensym 'token)
token3783
user> (gensym 'token)
token3788
user> (gensym 'token)
token3793
user> (gensym 'token)
user> (def mine (gensym 'token))
#'user/mine
user> (def yours (gensym 'token))
#'user/yours
user> (= mine yours)
false
user> (= mine mine)
true