https://pastebin.com/2TXGSDLw
Perform the action.
match action {
Add { text } => tasks::add_task(journal_file, Task::new(text)),
List => tasks::list_tasks(journal_file),
Done { position } => tasks::complete_task(journal_file, position),
https://pastebin.com/zb0CCDWT
I've been working on this CLI for what seems like 8 hours. One more error seems to get in my way and while it seems simple enough I can't fix it. Unresolved module and it can't find the path to my task.rs file.
Based from the screenshots you’ve uploaded. It seems the problem might be the name of your struct.
You have a code under task.rs:
pub struct tasks {...}
and then below it
impl Task {...}
I think it’s also recommended having structs with names starting with a capital letter.
PS.
Perhaps copy and paste the code in your post next time? Others might easily see the problem you’re facing. Or perhaps they can copy and paste the codes you’ve posted with the fix as well.
Related
How do you look up a macro in Rust?
E.g., I was reading the source code for serde_json and encountered the macro tri!.
I ended up downloading the code and running spinning up VS Code. But this isn't always feasible. And sometimes it's a different version, etc. I should be able to read code without running it.
But this is only a specific example. How do you look up any macro in Rust, in any codebase"?
Macros have different lookup rules than normal items. You can find details in the Scoping, Exporting, and Importing section for Macros by Example in the Rust Reference.
Basically there are two kinds of scopes to lookup macros:
path based scoping: which is the same as normal item lookup where it can be imported by use statement or by path:
use macros::a;
a!();
macros::b!();
textual scoping: a non-path-qualified macro will first look at macro definitions in the current module and all parent modules. I think this is better shown with an example:
mod a {
macro_rules! macro_a { () => {}; }
mod b {
macro_rules! macro_b { () => {}; }
mod c {
macro_rules! macro_c { () => {}; }
macro_a!(); // these all work
macro_b!(); // without any
macro_c!(); // explicit imports
}
}
}
This will work across files as well. However, keep in mind that macro definitions are ordered, meaning a macro defined after its use is not considered.
So when looking at source code, I generally search for macros in this order:
Look in the current module for any macro_rules! definitions or matching import statements. This can get hairy if there are wild-card imports, but that's just how it goes sometimes; use your best judgement if the macro could be there.
Look in the crate root (usually main.rs or lib.rs) for similar definitions or imports. This is because often crate-internal macros are designed to be used crate-wide, and following textual lookup above, any macro in the crate root is available everywhere. This is also the likely place where you'll find #[macro_use] definitions either for some internal macros module (as is the case with serde-json), or on extern crate ...; declarations (where they must be at the crate root).
Then look in intermediate modules. I don't think I've ever had to do this personally, but its possible.
One of my dependencies has a few println! scattered around that seem to be debugging artifacts and I'm trying to find a way to suppress them, but haven't had any success so far.
I've been looking at macros, and tried putting one inside the function where the imported struct is instantiated but with no success, likewise when giving it a global scope.
macro_rules! println {
($($rest:tt)*) => { }
}
Is there any way I can use a macro to target an external crate, or any other solution short of forking the codebase?
I'd like to build a custom path, then download a file at that path. Eg,
warp::path!("files" / u32)
.map(|fileId| {
format!("{}.txt", *FILES_PATH, fileId)
})
.and(warp::fs::file)
But I get an error like:
the trait bound 'fn(_) ->
impl warp::filter::FilterClone {
warp::filters::fs::file::<_>
}: warp::filter::FilterBase' is not satisfied
Am I missing an easy way that this can be done?
In warp, filters cannot be dynamically generated, they must be created when the program starts up. There is a pull request to support this, but it hasn't seen activity in a while.
Your best option is to copy Warp's implementation of file paths - it uses Warp-internal code, so you'd have to define your own error and rejection types, but that's not too difficult.
I decided to start a new project to get into hacklang, and after fixing some if the problems I initially ran into transitioning from php habits, I ran into the following errors:
Unbound name: str_replace
Unbound name: empty
Doing some research I found that this is due to using 'legacy' php which isn't typechecked, and will error with //strict.
That's fine and all, empty() was easy enough to replace, however str_replace() is a bit more difficult.
Is there an equivalent function that will work with //strict? Or at least something similar.
I'm aware that I could use //decl but I feel like that defeats the purpose in my case.
Is there at least any way to tell which functions are implemented in hack and which are not in the documentation as I couldn't find one?
For reference (though it isn't too relevant to the question itself), here is the code:
<?hh //strict
class HackMarkdown {
public function parse(string $content) : string {
if($content===null){
throw new RuntimeException('Empty Content');
}
$prepared = $this->prepare($content);
}
private function prepare(string $contentpre) : Vector<string>{
$contentpre = str_replace(array("\r\n","\r"),"\n",$contentpre);
//probably need more in here
$prepared = Vector::fromArray(explode($contentpre,"\n"));
//and here
return $prepared;
}
}
You don't need to change your code at all. You just need to tell the Hack tools about all the inbuilt PHP functions.
The easiest way to do this is to download this folder and put it somewhere in your project. I put it in a hhi folder in the base of my project. The files in there tell Hack about all the inbuilt PHP functions.
Most of them don't have type hints, which can lead to Hack thinking the return type of everything is mixed instead of the actual return, that is actually correct in most cases as, for example, str_replace can return either a string or a bool. However, it does stop the "unbound name" errors, which is the main reason for adding them.
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.