Enriched Descriptors, maybe ES7 ?

[Andrea Giammarchi]

about the first example, I forgot the writable for the num property so
please read that as if I wrote:

```javascript
var o = {};
Object.defineProperty(o, 'num', {
  writable: true,
  value: 0,
  type: 'number'
});
```

the library makes possible to create a partial shim of StructType in few
lines of code, using same mechanism to guard types:
https://github.com/WebReflection/define-strict-properties/blob/master/src/StructType.js#L40

In this case, types are downgraded to 'number' ... and that's just an
example


On Sun, Mar 9, 2014 at 2:25 PM, Andrea Giammarchi <
andrea.giammarchi at gmail.com> wrote:

> As written before, and explained in the project, I can write descriptors
> with optional extra properties such as:
>
> **type**, describing as string the typeof, as Function the expected
> instanceof, or as generic object as prototypeOf(expectedType)
>
> ```javascript
>
> var o = {};
> Object.defineProperty(o, 'num', {
>   value: 0,
>   type: 'number'
> });
>
> o.num = 123; // ok
>
> o.num = '123'; // throws an error, '123' is string, not number
>
> ```
>
> The meaning of type here is the same MS choose for TypeScript but no
> breaking syntax is necessary plus types can be optionally used to described
> methods or functions too.
>
>
> ```javascript
>
> var o = {};
> Object.defineProperty(o, 'increment', {
>   value: function (much) {
>     this.num += much;
>     return this;
>   },
>   arguments: ['number'], // 1 arg as number
>   returns: Object // just an instanceof object
> });
>
> o.num = 0;
> o.increment(1).increment(2);
> o.num; // 3
>
> o.increment('1'); // thorws since the argument is not a typeof number
>
> ```
>
> The received arguments can have overloads so that:
>
> ```javascript
>
> var o = {};
> Object.defineProperty(o, 'increment', {
>   value: function (much) {
>     this.num += parseFloat(much);
>     return this;
>   },
>   arguments: [['number'],['string']],
>   // 1 arg as number or 1 arg as string
>   returns: Object // just an instanceof object
> });
>
> o.num = 0;
> o.increment(1).increment(2);
> o.num; // 3
>
> o.increment('1'); // OK
> o.num; // 4
>
> o.increment(new Number(1)); // throws, not typeof number/string
>
> ```
>
> Either the amount of arguments is wrong or the type won't match ... the
> signature is guarded during development time.
>
> In production, you just do not include upfront the proposed script and
> everything will work as regular ES5 preserving all behaviors and
> descriptors ... in few words, I am proposing an alternative to TypeScript
> that integrates well down to ES5.
>
> If engines would like to use types and descriptors provide such info, this
> could have ideally performance benefits too plus the code will be most
> likely less "*undefined is not defined*" prone.
>
> The library I have there, already provides all I've said behind 64 tests
> that verify the behavior is guarded and preserved with or without the
> library upfront.
>
> Compatibility with the test link [here](
> https://github.com/WebReflection/define-strict-properties#compatibility)
>
> Best Regards
>
>
>
>
> On Sun, Mar 9, 2014 at 2:05 PM, Brendan Eich <brendan at mozilla.com> wrote:
>
>> Andrea Giammarchi wrote:
>>
>>> Although my idea is more about types
>>>
>>
>> You are starting on the wrong foot there. "Types" mean something in CS.
>> Best if you start with use-cases instead of abusing the term. What code do
>> you want to write, and how exactly would it operate?
>>
>> /be
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20140309/f9e6964b/attachment.html>