I've just learned about the method
Meteor.defer(function() {
// Do something
});
over at https://bulletproofmeteor.com, which according to them is short for:
Meteor.setTimeout(function() {
// Do something
}, 0);
However, I found nothing about this function in the Official Meteor Documentation. Is there any reason for this not being in there despite it being part of the core?
It's been raised before and is tracked as an issue here: https://github.com/meteor/meteor/issues/2176
The short answer is they haven't gotten around to documenting all functions, and this one isn't considered very important because it's basically just a shorthand.
Related
The help text for require-atomic-updates talks exclusively about statements that both set and consume the same variable.
I have some old† code that looks something like this (I think I've included everything that is relevant):
var someFunction = async function someFunction () {
switch(someVariable) {
case 0:
if (maybe) {
await doSomething();
}
break;
case 1:
//similar to above
}
someVariable = 0; // Error detected on this line
return
}
var someVariable = 0;
someFunction is invoked during some event processing later, while someVariable can be adjusted by multiple code paths
As far as I can tell, the line on which the error is reported is an atomic update, it doesn't read the value or set the new value based on anything else.
I can't understand why eslint thinks there is a possible race-condition here?
The code has been functional for a long time now, so I'm happy to just disable the rule on this line to stop it complaining. But I'd like to understand the reason that eslint highlighted it.
† The original code was written long ago, but has been adjusted more recently to be async
If you upgraded to eslint 6.0.1 like I just did, you're encountering a recently introduced bug.
There are several open github issues referencing this bug, but the gist of it is that require-atomic-updates is currently broken.
I recommend downgrading eslint or disabling the rule as a workaround.
Bug reports on the issue here:
https://github.com/eslint/eslint/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+require-atomic-updates
Looking up how to read from stdin in rust-0.13, I got to this page, which had the following code:
for line in io::stdin().lock().lines() {
print!("{}", line.unwrap());
}
I tried following the docs to figure out what exactly is happening, but got stuck with the lines() function. At the end I went through the code (pretty awesome that they have a link to it in the docs) and found BufferPrelude which answered where lines() came from:
impl<T: Buffer> BufferPrelude for T {...}
My question is - was there an easier to figure what was happening? Does the documentation engine simply not catch this type of logic?
That's what's referred to as a blanket implementation, i.e. an implementation for all types T that already implement Buffer, and the documentation system doesn't currently follow transitive implementations like that (i.e. BufferedReader impls Buffer, and so BufferPrelude is "blanket impl'd" for BufferedReader).
The quickest way to have found this would've been to look for the method in particular, so lines, using the search feature. This would have led you to, indeed, BufferPrelude, where you would notice that it's "only" implemented for types that implement Buffer, so you would deduce that BufferedReader must implement Buffer. To verify this you could click on Buffer and look at the "implementors" at the bottom.
I am wondering if there is a way to ignore certain TypeScript errors upon compilation?
I basically have the same issues most people with large projects have around using the this keyword, and I don't want to put all my classes methods into the constructor.
So I have got an example like so:
TypeScript Example
Which seems to create perfectly valid JS and allows me to get around the this keyword issue, however as you can see in the example the typescript compiler tells me that I cannot compile that code as the keyword this is not valid within that scope. However I don't see why it is an error as it produces okay code.
So is there a way to tell it to ignore certain errors? I am sure given time there will be a nice way to manage the this keyword, but currently I find it pretty dire.
== Edit ==
(Do not read unless you care about context of this question and partial rant)
Just to add some context to all this to show that I'm not just some nut-job (I am sure a lot of you will still think I am) and that I have some good reasons why I want to be able to allow these errors to go through.
Here are some previous questions I have made which highlight some major problems (imo) with TypeScript current this implementation.
Using lawnchair with Typescript
Issue with child scoping of this in Typescript
https://typescript.codeplex.com/discussions/429350 (And some comments I make down the bottom)
The underlying problem I have is that I need to guarantee that all logic is within a consistent scope, I need to be able to access things within knockout, jQuery etc and the local instance of a class. I used to do this with the var self = this; within the class declaration in JavaScript and worked great. As mentioned in some of these previous questions I cannot do that now, so the only way I can guarantee the scope is to use lambda methods, and the only way I can define one of these as a method within a class is within the constructor, and this part is HEAVILY down to personal preference, but I find it horrific that people seem to think that using that syntax is classed as a recommended pattern and not just a work around.
I know TypeScript is in alpha phase and a lot will change, and I HOPE so much that we get some nicer way to deal with this but currently I either make everything a huge mess just to get typescript working (and this is within Hundreds of files which I'm migrating over to TypeScript ) or I just make the call that I know better than the compiler in this case (VERY DANGEROUS I KNOW) so I can keep my code nice and hopefully when a better pattern comes out for handling this I can migrate it then.
Also just on a side note I know a lot of people are loving the fact that TypeScript is embracing and trying to stay as close to the new JavaScript features and known syntax as possible which is great, but typescript is NOT the next version of JavaScript so I don't see a problem with adding some syntactic sugar to the language as people who want to use the latest and greatest official JavaScript implementation can still do so.
The author's specific issue with this seems to be solved but the question is posed about ignoring errors, and for those who end up here looking how to ignore errors:
If properly fixing the error or using more decent workarounds like already suggested here are not an option, as of TypeScript 2.6 (released on Oct 31, 2017), now there is a way to ignore all errors from a specific line using // #ts-ignore comments before the target line.
The mendtioned documentation is succinct enough, but to recap:
// #ts-ignore
const s : string = false
disables error reporting for this line.
However, this should only be used as a last resort when fixing the error or using hacks like (x as any) is much more trouble than losing all type checking for a line.
As for specifying certain errors, the current (mid-2018) state is discussed here, in Design Meeting Notes (2/16/2018) and further comments, which is basically
"no conclusion yet"
and strong opposition to introducing this fine tuning.
I think your question as posed is an XY problem. What you're going for is how can I ensure that some of my class methods are guaranteed to have a correct this context?
For that problem, I would propose this solution:
class LambdaMethods {
constructor(private message: string) {
this.DoSomething = this.DoSomething.bind(this);
}
public DoSomething() {
alert(this.message);
}
}
This has several benefits.
First, you're being explicit about what's going on. Most programmers are probably not going to understand the subtle semantics about what the difference between the member and method syntax are in terms of codegen.
Second, it makes it very clear, from looking at the constructor, which methods are going to have a guaranteed this context. Critically, from a performance, perspective, you don't want to write all your methods this way, just the ones that absolutely need it.
Finally, it preserves the OOP semantics of the class. You'll actually be able to use super.DoSomething from a derived class implementation of DoSomething.
I'm sure you're aware of the standard form of defining a function without the arrow notation. There's another TypeScript expression that generates the exact same code but without the compile error:
class LambdaMethods {
private message: string;
public DoSomething: () => void;
constructor(message: string) {
this.message = message;
this.DoSomething = () => { alert(this.message); };
}
}
So why is this legal and the other one isn't? Well according to the spec: an arrow function expression preserves the this of its enclosing context. So it preserves the meaning of this from the scope it was declared. But declaring a function at the class level this doesn't actually have a meaning.
Here's an example that's wrong for the exact same reason that might be more clear:
class LambdaMethods {
private message: string;
constructor(message: string) {
this.message = message;
}
var a = this.message; // can't do this
}
The way that initializer works by being combined with the constructor is an implementation detail that can't be relied upon. It could change.
I am sure given time there will be a nice way to manage the this keyword, but currently I find it pretty dire.
One of the high-level goals (that I love) in TypeScript is to extend the JavaScript language and work with it, not fight it. How this operates is tricky but worth learning.
All,
Could you explain me about Monitor Class, esp following code in more detail?
if (Monitor.TryEnter(CashDrawers.lockObject))
{
try
{
// Work here
}
finally
{
Monitor.Exit(lockObject);
}
}
Thanks,
CK
Not sure if this is what you're looking for but...
The code you posted in your question is the non blocking version of
lock(CashDrawers.LockObject)
{
//work here
}
Meaning that it will only do it's "work" if it is able to acquire the lock on the first try. If something else already has the lock, then your code won't do anything. I'm assuming this code is written within the CashDrawers class, otherwise you probably have a transcription error in that you need to Moniter.Exit on the same object that you Entered on.
Are you looking for an explanation on synchronization in general? If so that's beyond the scope of what I can write in an answer. Please check out http://www.albahari.com/threading/part2.aspx for some general synchronization info in .net.
Does anyone know what's wrong with the code below? The this->progressBar1->Value part worked by the button_click_event but not in this snippet. I've been messing around with it but to no avail:
int Trouble ()
{
int hour = System::DateTime::Now.Hour;
this->progressBar1->Value = hour;
return 0;
}
This code snippet is part of a WinForm and it is located in the #pragma endregion part of my code (BTW This is Visual C++). As always I will apperciate any help or suggestions. Thanks!
It appears you've made this a free function rather than a member function of your class. Place this definition inside your class' definition (probably under the private: access modifier) and you'll get the behavior you expect. Also, do some reading on "scope", as it's a very fundamental concept and not understanding it is why you're having this problem.
I think this exchange of comments may qualify as an answer:
#Francis: Then you'll need to show more code, especially the function which calls Trouble. – Ben Voigt
There's no function that calls it; this code is stand-alone. – Francis Lau
So you can remove it from your code, and the program still compiles? – Ben Voigt
You may say that. – Francis Lau
That certainly explains why it doesn't "work". It's not sufficient to write a function, you also have to call it at an appropriate time.