[?] Best way to model domain-specific concepts with Wolfram language?

Questions
1

Hi,

I’m just wondering what would be the best choice to model a domain-specific concept. If I take as an example the concept of a pet, with a name and a size. I see two options:

createPet[name_String, size_Real] := aPet["name"->name,"size"->size];

or

createPet[name_String, size_Real] := {"name"->name,"size"->size};

The first option allows me to use the Head aPet in my patterns. But it seems to me that the extraction of raw data is more verbose:

lotOfPets = {aPet["name"->"name1","size"->size1], aPet["name"->"name2","size"->size2],...};
lotOfPets /. aPet[___,"size" -> size_Integer, ___] -> size;
(* OR *)
Last/@Last/@lotOfPets (* I don't like this one because it is tightly linked to fixed positions in the expression*)

The second option allows me to more easily extract data using ReplaceAll:

lotOfPets = {{"name"->"name1","size"->size1},{"name"->"name2","size"->size2},...};
Flatten["size"/.lotOfPets]

What do you think?

Best

Fabrice

2

You can try Association and Dataset:

petsDatabase = 
 Dataset[{Association["name" -> name1, "size" -> size1], 
   Association["name" -> name2, "size" -> size2]}]
petsDatabase[All, "name"]
petsDatabase[All, "size"]
3

Right. But my question was more about the best choice in a modeling process between a built-in data structure with all its advantages (like the practical way to query a Dataset or the easy way to extract the elements of a List with ReplaceAll) and a user-defined data structure (an expression with a user-defined Head). Then I remembered these Upvalues and Downvalues allowing you to setup operations linked to your Head. For example the cross between two pets with the operator +:

aPet /: aPet["name" -> name1_String] + aPet["name" -> name2_String] :=
   aPet["name" -> "My parents are " <> name1 <> " and " <> name2];
aPet["name" -> "Bob"] + aPet["name" -> "Brenda"]

Then no real best choice. I think it depends mainly if your domain-specific concepts are also linked to domain-specific operations.

Thank you for your answer.

4

You really should use associations.

If you really want your own head for some reason, try this:

In[1]:= pet[asc_?AssociationQ][prop_] := Lookup[asc, prop]

In[2]:= petQ[pet[asc_?AssociationQ]] := Sort@Keys[asc] === Sort[{"name", "size"}]
petQ[_] := False

In[4]:= x = pet[<|"name" -> "foo", "size" -> 12|>]    
Out[4]= pet[<|"name" -> "foo", "size" -> 12|>]

In[5]:= x["name"]    
Out[5]= "foo"

In[6]:= petQ[x]    
Out[6]= True

In[7]:= petQ[pet[123]]    
Out[7]= False

In[8]:= pet /: MakeBoxes[p_pet?petQ, form : (StandardForm | TraditionalForm)] :=     
 BoxForm`ArrangeSummaryBox[
  pet,
  p,
  None,
  {BoxForm`SummaryItem[{"name: ", p["name"]}],
   BoxForm`SummaryItem[{"size: ", p["size"]}]},
  {},
  form
  ]