De-anonymized Models

Learn
1

Do you use tuples () and anonymous records { .. } in your Models?

I do, especially if I am hacking out some piece of code in an exploratory way, and I don’t have a solid idea of the exact data model yet. If I designed the data model up front, I do this less. I am finding of late, I like to refactor my more hacky efforts into a less anonymous form. Which led me to think, what is the definition of a fully de-anonymized model in Elm?

Given a model that includes them:

type alias Model = 
   { tuple : (A, B)
   , record : { x : X, y : Y }
   }

(where A, B, X, Y are types not shown above).

There is a transformation to turn this into a model where all of the types and fields are named. Which is, to replace each tuple with a record (with named fields), and to replace each anonymous record type with a reference to a type alias:

type alias Model = 
   { tuple : Tuple
   , record : Record
   }

type alias Tuple = { a : A, b : B }

type alias Record = { x : y, y : Y }

Also note that tagged union types are also implicitly using tuples for their arguments:

type Tagged = Option A1 A2 ... An => -- Is almost equivalent to
    type Tagged = Option (A1, A2, ..., An)

So these constructor arguments also need to be turned into records with a type alias and named fields.

Once a model is in its de-anonymized form every type and field is named.

So my question is, is this better from a self-documenting code perspective, because these names give a clue to someone reading the code what the purpose of each type and field is? On the down-side sometimes it gets hard to think up good names for things.

I also find that I do not generally turn 1-tuples into records where they are arguments of tagged union constructors - the tagged union constructor serves as the name for the parameter in that case.

2

This topic was automatically closed 10 days after the last reply. New replies are no longer allowed.