Add type validation for record fields if types are present

[define-null]

I'd like to suggest the following: to add automatic type validation based on the field type if present, with an approach like here: https://github.com/extend/sheriff/blob/master/src/sheriff.erl#L144
Together with support for optional validators that are already present it would add much more flexibility for validation.

I potentially keep in mind usecases like the following:

currency :: binary() | disabled %% <<"EUR">>, <<"USD">>

Where binary and disabled are checked by automic validation and then EUR and USD are checked by user-provided validation.

[shizzard]

@define-null
After some research made:

1. sheriff approach will not work with OTP types (that types defined in standard OTP modules like proplists, sets, etc.) because sheriff creates a separate validation function in-place. This means, that in order to validate built-in types cloak will need to process and parse-transform OTP modules; this is not an option, of course.
2. Even if we will ignore built-in types and will focus on user-defined types (which is obviously ugly approach because it leads to partial type-checking), such approach will need cloak to be a project-wide parse-transform application, which I don't like. For example, such approach might modify a module that was not intended to be modified (module with ?MODULE record definition).
3. With module-wide parse-transform (-compile directive in the intended module) it is obviously very hard to collect information about fully-qualified types, e.g. other_module:some_type().

Unfortunately, it seems that there is no easy and compile-time friendly ways to generate such type-checkers.

However, it is possible to generate type-checkers for "simple" fields, e.g. defined with built-in atomic types. Such validators may be turned on with a simple attribute, e.g.

-module(test).
-compile({parse_transform, cloak_transform}).
-cloak_enable_typecheck.

-record(?MODULE, {
    %% may be checked to be a list before passing to the validator function
    a :: list(), 
    %% cannot be checked, will be passed to the validator as-is
    b :: sets:set(integer()), 
    %% no type present, will be passed to the validator as-is
    c 
}).