Return a Part by Reference? (For accessing hierarchical / structured data)

Question

Is there a way to return a part of a list by reference, for reading and writing?

I want to do this so I can easily manipulate "rule-styled structured", i.e., hierarchical data that is loaded from a MAT file with struct's. Example:

obj = {"Name" -> "Something", "Age" -> 10};

I think this is a relatively simple way to get / set fields, which deals with nested structures by limiting Position to levelspec 1:

RuleQ[x_] := False;
RuleQ[rule_Rule] := True;
RuleQ[{}] := True; (* An empty list can be a Rule set... *)
RuleQ[rules_List] := SameQ[Head[First[rules]], Rule];

StructQ[x_] := False;
StructQ[rules_List?RuleQ] := True;

FindFirst[list_List, item_] := Module[{res},
   res = Flatten[Position[list, item, 1]];
   Return[If[Length[res] > 0, First[res], {}]];
   ];

FieldRule[field_] := field -> _;

GetFieldIndex[obj_?StructQ, field_] := FindFirst[obj, FieldRule[field]];

SetField[obj_?StructQ, field_, value_] := Module[{index},
   index = GetFieldIndex[obj, field];
   If[NumberQ[index],
    obj[[index, 2]] = value;
    ,
    AppendTo[obj, field -> value];
    ];
   ];
SetAttributes[SetField, HoldFirst];

GetField[obj_?StructQ, field_] := Module[{index},
   index = GetFieldIndex[obj, field];
   (* How to return a reference? *)
   Return[obj[[index, 2]]];
   ];
SetAttributes[GetField, HoldFirst];

So you can do something like

Print[GetField[obj, "Name"]];
SetField[obj, "Name", "REPLACED"];
Print[GetField[obj, "Name"]];

All that being said, I would like to do something like this:

GetField[obj, "Name"] = "REPLACED";

An example of my hope for such a feature:

GetFieldByReference[obj_?StructQ, field_] :=
    Return[Part[obj, {GetFieldIndex[obj, field], 2}];
SetAttributes[GetFieldByReference, HoldReturn];
obj = {"Name" -> "Something", "Age" -> 10};
GetFieldByReference[obj, "Name"] = "REPLACED";

The contents of obj would then be:

{"Name" -> "REPLACED", "Age" -> 10}

Answer 1

I've experimented with this kind of structure-representation years before, when I thought that object oriented programming is something that must be implemented in Mathematica. Since, I've learned that it does not really worth it. The core of the method is to set up a reference object (generally, via a constructor, but here we take it as granted) and set up a field $\rightarrow$ position dispatch table that is used when accessing fields.

For static object structure

Create a reference: this should be the reference format of a class of objects, with head Entry (any arbitrary name suffices). Any non built-in symbol or string will be identified as a field-name. Note that you can use hierarchical lists or functions, as in case of $slot, and fields can be repeated.

reference = 
  Entry[$type, $size, $method, $slot[{"a", "b"}, {"a", "b"}, {"a", "b"}]];

Extract all user-defined symbols/strings. (Unsorted union can be used instead of Union to keep the fields in order, but it is not essential.)

fields = Union@
  Rest@Cases[reference, 
    Except[List, _Symbol | _String], {0, Infinity}, Heads -> True]

{"a", "b", $method, $size, $slot, $type}

Now set up the dispatch table that is used to replace field names with positions. We include All and similar position specifiers for better usability.

dispatch = 
 Dispatch@Join[
   Rule[#, Last@DeleteCases[First@Position[{reference}, #], 0]] & /@ 
    fields, {All -> All, None | Identity | Null -> Sequence[]}];

Define the access function:

GetField[obj_] := obj;
GetField[obj_, par__] := Part[obj, Sequence @@ ReplaceAll[{par}, dispatch]];

Now create a real object (this should be created with a constructor or by instantiating a class member):

object = Entry[Real, 13, "N\\A", {{1, 2}, {3, 4}, {5, 6}}];

Let's access some parts:

GetField[object, $type]            ==> Real
GetField[object, $size]            ==> 12
GetField[object, $slot]            ==> {{1, 2}, {3, 4}, {5, 6}}
GetField[object, $slot, 2, "a"]    ==> 3
GetField[object, $slot, All, "b"]  ==> {2, 4, 6}

Define the set function:

SetField[obj_, par__, val_] := ReplacePart[obj, ReplaceAll[{par}, dispatch] -> val];

...and modify the structure. One can define a SetFieldTofunction that modifies the original object instead of a copy of it (like AddTo vs. Add), but it is left for sake of simplicity.

SetField[object, $type, Integer]
SetField[object, $size, 21]
SetField[object, $slot, 3, 1, 555]

Entry[Integer, 13, "N\\A", {{1, 2}, {3, 4}, {5, 6}}]
Entry[Real, 21, "N\\A", {{1, 2}, {3, 4}, {5, 6}}]
Entry[Real, 13, "N\\A", {{1, 2}, {3, 4}, {555, 6}}]

For dynamic object structure

If one allows dynamic objects where new fields can be introduced on the fly, I suggest using a 1D list of rules, like in the OP. This method assumes that all elements in object are rules.

Remove[GetField, SetField, object];
GetField[obj_] := obj;
GetField[obj_, field_] := field /. obj;
SetField[obj_] := obj;
SetField[obj_, field_, val_] := Module[{pos},
   pos = Position[obj, field, {0, \[Infinity]}, 1];
   If[pos === {},
    Join[obj, {field -> val}],
    ReplacePart[obj, {First@First@pos, 2} -> val]
   ]];

object = {"f1" -> 1, "f2" -> 2, "f3" -> 3};

GetField[object, "f2"]      ==> 2
SetField[object, "f3", 4]   ==> {"f1" -> 1, "f2" -> 2, "f3" -> 4}
SetField[object, "f4", 5]   ==> {"f1" -> 1, "f2" -> 2, "f3" -> 3, "f4" -> 5}