be rethought until it
can.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
Le mer. 11 nov. 2020 à 23:05, Jacob Bloom a
écrit :
> This SO answer provides a typing for Object.assign that appears to
> basically do the right thing: https://stackoverflow.com/a/51603499 -- but
> none of
the same... really, I'm dreaming about a standard
annotation for each ES feature,
covering all the usages. **when that feature is released**.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
Le sam. 17 oct. 2020 à 03:29, #!/JoePea a écrit :
> Would official syntax be worth it (JSDoc be
Sorry but my question isn't about providing a tool to generate our
documentations but to have a standard syntax to describe our code
(signatures). ;)
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
Le mar. 13 oct. 2020 à 01:29, Jordan Harband a écrit :
> Hopefully (imo) people are h
tion to
improve/create a lot of amazing tools (IDE's autocomplete, doc generation,
AST, subsets compilation, bundling, ...) on a spec which covers 100% of the
language features usages.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mai
to their stack.
IMHO, it's really urgent to have something formal to solve that missing
point of my favorite language.
What would it take to make this dream come true, please?
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
/issues/76#issuecomment-494686580
What's your opinion on this, please?
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
a rest
parameter to be able to get the first error, as actually, or all of them to
avoid any problems when the catch handler doesn't know if the fulfillment
is enforced or not.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
Le mer. 15 juil. 2020 à 19:35, Logan Smyth a écrit :
> I'm not sure
, allowing the rest parameter on the `catch (...errors)` resolves
that problem, without breaking changes.
What do you think about it, please?
Cordially,
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss@mozilla.org
About arrow functions/binding, it's just a principle, I try to never create
some function on-the-fly, I'm working only by immutable objects derivation.
But, ok, if no choice, I'll do that. ;)
___
es-discuss mailing list
es-discuss@mozilla.org
based on `a` and `b` -
> why would you need a receiver?
>
> On Mon, Nov 11, 2019 at 7:34 PM Michaël Rouges
> wrote:
>
>> Hi all,
>>
>> Is there a reason to not have a `thisArg ` for the
>> `Array.prototype.sort()` callback?
>>
>> Actually, it enforces to
Hi all,
Is there a reason to not have a `thisArg ` for the `Array.prototype.sort()`
callback?
Actually, it enforces to bind the context or to have nested functions, each
one creating a new function where it isn't strictly necessary.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
I understand better now ... Thanks a lot again...
And, sorry, Tab... to not deal with you on already debated topics.
I hope the following will not be one.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss
Hi all,
I'm coming to you for a tiny question... excuse me if already replied...
Where the rest parameter are only declarable at the end of the arguments
list, like this, please?
`
void function (a, ...b, c) {
// b = [2, 3]
}(1, 2, 3, 4);
`
Any real reasons?
Michaël Rouges - https
For me, the rest parameters must be unique per arguments list but,
logically, usable following the function requirements...
A classical example, the node.js methods, which takes a callback as last
argument, preceeded (generally) by one or more arguments, for a same method.
Michaël Rouges - https
For the undefined case, it isn't unexistent...
```JavaScript
void function () {
console.log(arguments.length); // 3
}(1, 2, undefined);
```
Then, I don't see how it may be ambiguous...
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es
Ok, ok, it's a bit that I dreaded opening this topic but the idea of a
shared private channel
between two foreign scopes seemed interesting enough to suggest, at
least to discuss
it.
Thanks to all. :)
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
test,
fn;
fn = new Function('value', 'return function (){console.log(value);}');
fn('hello');`
Really boring to share some private variables...
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss@mozilla.org
the inside this of the methods (if not equal to
foreignObject),
- it forces to have a 'shared' arguments on each foreignObject method
Better? :)
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss@mozilla.org
https
@Andrea :
Yeah, I don't really want to rewrite the methods, I only want to share my
shared variable with these methods.
Furthermore, your code don't works because method don't knows shared.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es
@ TJ, Rick :
I'm really interested too!
On an another side, my next idea, for the same goal, is a thing like :
```Function.prototype.attachContext()```
Where an attachContext call can share the context of the current scope
with the related function.
Michaël Rouges - https://github.com/Lcfvs
Um, no, I was thinking something like :
```
var fn;
fn = function fn() {
// After the context is attached fn scope already knows shared
};
(function () {
var shared;
shared = 'message';
fn.attachContext();
}());```
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
@ Andrea :
The why comes from an another question : why to reserve the variables
sharing (across the scopes) for the parenst/childs relations.
Imho, some things should be shared with objects out of this of relationship
type, no? :)
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
@Andrea :
There is no real equivalent in PHP.
I only used the use keyword as example to suggest, in your mind, an
ability to share vars with a foreign function
without to touch the foreign function arguments. ;)
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
,
a few like a Object.preventExtensions().
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
constraints).
And don't worry... dont make a fixation on the PHP use, read the last
Rick's post. ;)
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
@ Andrea :
Thanks for the fixes, I tried but got Internal server error, on edit.
The Tab's solution works but not on a secure channel between the closures.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss
@ Rick :
Or a more controlled solution might be to create a method able to only
attach one pointer at a time.
What do You think about it?
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
not sure) to pass some infos/tools that we need
to take our decision, in the negociation process
Lemme your advices. ;)
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org
', '...']
};
controller = foreignController.bind(handler);
new Promise(controller)
.then(onFulFilled, onRejected, onNegociated.bind(handler))
/* a lot of thens */;
```
Personnaly, I don't see how the current promises can solve it as simply.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
;
}());`
Is there a reason not to do that, please?
Thanks in advance.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
: Thanks, a little too excited in my mind, I have made a mistake, I
will correct it. ;)
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
() {
Object.prototype.hasOwnProperty('serialize') // true
}());
(function () {
'use native';
Object.prototype.hasOwnProperty('serialize') // false
}());
} ());`
Thanks in advance for your advices.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
___
es
not paid for
a license to use a jQuery plugin.
So yes, I agree, it's the developer responsibility, but it would be nice that
there is a way to do so to ensure that the tools we propose behaves exactly
as desired, whatever the practices of the developer who uses them.
No?
Michaël Rouges - https
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
2013/9/25 Eric Kever lolbum...@gmail.com
I'm no real expert here, but this seems like a proposal for a workaround
for messy code rather than something that's actually necessary within the
language.
On Wed, Sep 25, 2013 at 11:27 AM, Michaël
Hum ... in this proposal case, I don't think we should talk about a
real new version
of the language ...
Rather, I see it as a JavaScript sandbox that, internally, should not
require major developments, I believe
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
2013/9/25 Rick Waldron
Hum...the closures doesn't prenvent from foreign prototyping... and all
actual sorts of sandboxes are really heavy, much more than a possibly
native solution, mainly about performances, like my
Sandbox.jshttps://github.com/Lcfvs/Sandbox.js
.
Michaël Rouges - https://github.com/Lcfvs - @Lcfvs
Hi all,
Thanks for your answers.
Domenic Denicola sent me an example by email, but I don't understand it all.
I waited for his response, but seemed busy, I turn back to you.
The sample :
Hello everyone,
I wondered why it would be possible to send only one variable via this
method?
Knowing that we will have the opportunity to use destructuring assignments, why
can't we deal on this problem?
Thanks in advance.
___
es-discuss mailing
Hello everyone,
What's the point about optional named arguments support, please?
ES6? ES7? abandoned?
___
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
39 matches
Mail list logo
