Not my type

An irreverent yet positively innovative approach regarding data typing

I love programming. I discovered the computers and wrote my first programs when I was a kid and I've never stopped since then.

For some time now, I've been working on a Web App framework, and this led me to think about a lot of things, amongst which data typing.

It took me quite a long time to realize that the conventional approach of using variable types in most programming languages leads developers to create programs that require tremendous efforts to deal with validation, adaptation, storage and rendering of the manipulated values.

The reason is that traditional data typing in programs is very permissive, tends to prioritizes technical needs over human reasoning, often lacks of context validation, and is rarely explicit in terms of human representation.

This article presents a solution that aims to tackle these limitations by suggesting a more complete, flexible and unambiguous way to define and to handle data.

TL;DR

Then you're using an ambiguous typing and you probably have to manually deal with validations and conversions.

This article presents the advantages of using an explicit typing, and suggests that a simple syntax inspired by the ) for building such descriptors.

Using the MIME notation, in conjunction with concepts for which an unambiguous definition or an international standard exists, provides an explicit typing. For instance, we can assume that a "language" is a value that holds 2 or 3 lowercase letters and whose possible values are provided by the ISO standards ISO-639-1 and ISO-639-2.

The term "usage" is used to distinguish explicit types from primitive types.

Here is the full syntax of a "usage" descriptor:

type [ ["/" subtype[.variation][":" length]] ]["{" min, max "}"]

• 
  type is the name of the non-primitive type;


• 
  subtype is the mandatory categorization of the non-primitive type (example: number/integer). It always has a default value so it can be omitted (ex. text defaults to text/plain);


• 
  variation (optional) additional meta information to identify a specific standard or norm (example: hash/md.4);


• 
  length is either an amount of digits (or glyphs), or a length under the form precision.scale;
  
  
  
  
  • for numeric values, the length tells the amount of digits (required bytes can be found with ceil(log2(x) / 8);
  
  
  • for strings, the length indicates the amount of glyphs (which might differ from the number of bytes);
  
  
  • for usages that imply a floating point numbers, the length can be composed of several parts separated with dots (e.g. precision[.scale]).
  
  
  
  
  
  


• 
  min and max are optional parameters intended for numbers and can be used for defining custom limits. By default, there are always limits, set based on the min and max implied by the usage. If set, these values must be consistent with the length (for instance number/natural:2 cannot have a min lower than 0 nor a max higher than 99).

The primitive types can coexist, but become special cases of the "usage".

The proposition being that:

• A usage always relates to a generic type (by example, all variations of "number/real" relate to the type "float");


• All generic types are associated with one default usage;


• The default boundaries depend on the local environment and off-limit values should be rejected by it.

Examples

Below is presented a non-exhaustive list of descriptors using such notation.

Numbers boundaries

When it comes to numbers, it is common for a variable not to relate to any standard or external convention, but instead to have boundaries (i.e. minimum and maximum possible values).

For that, we can use a notation similar to the one used in regular expressions for {n,m} quantifiers (

Valuable sources consulted over time

https://docs.oracle.com/javase/tutorial/essential/regex/