Hi, any experienced rust developer would mind sharing the best way to quickly edit external crate source for the main project I work on ? Can I run
cargo run with the edited source in ".cargo/registry/src/github.com-1ecc6299db9ec823/ispell-0.3.0/src/spell_checker.rs" for example ?
clone crate's repo, edit it and add its path to https://doc.rust-lang.org/cargo/reference/manifest.html#the-patch-section
@tigitz I usually fork it on github, create a branch and all that, and reference it through
crate = { git = "https://my-repo", branch = "something" } and then create a merge request. Or just report the problem and do something else in the meantime ‒ some crate authors are super fast and often a fixed version gets published in less than a day.
@spacekookie I think the default compare will be as fast as possible in given circumstances, so it'll short-circuit if it finds them different. It is done by comparing byte slices and I can't find that in the standard library :-|.
Which brings me to question, this doesn't seem to be unicode-aware compare.
hello
I need help with juniper
I've copied this file https://github.com/graphql-rust/juniper/blob/master/juniper/src/tests/model.rs
to my project
But when I cargo run, I get:
error[E0432]: unresolved import `InputValue`
--> src/model.rs:5:10
|
5 | #[derive(GraphQLEnum, Copy, Clone, Eq, PartialEq, Debug)]
| ^^^^^^^^^^^ no `InputValue` in the rootI added InputValue to main.rs, then compiler wanted another uses. So even with this in main.rs:
use juniper::InputValue;
use juniper::Value;
use juniper::ToInputValue;
use juniper::FromInputValue;
use juniper::Executor;I got:
error[E0365]: `InputValue` is private, and cannot be reexported
--> src/model.rs:5:10
|
5 | #[derive(GraphQLEnum, Copy, Clone, Eq, PartialEq, Debug)]
| ^^^^^^^^^^^ reexport of private `InputValue`
|
= note: consider declaring type or module `InputValue` with `pub`
error[E0365]: `Value` is private, and cannot be reexported
--> src/model.rs:5:10
|
5 | #[derive(GraphQLEnum, Copy, Clone, Eq, PartialEq, Debug)]
| ^^^^^^^^^^^ reexport of private `Value`
|
= note: consider declaring type or module `Value` with `pub`and so on...
better to create an issue on the repo. You will get faster answers :)
nice idea
How can I associate a lifetime with a return type ?
fn bar<'a>(y: &'a i32) -> impl FnMut()->i32 does not work
because the returned closure captures y
try
(impl FnMut() -> i32) + 'a?
error: expecting a path
I've tried with impl 'a + FnMut() -> i32 too without luck
try
impl FnMut() -> i32 + 'a
This message was deleted
nah idk
try that
that says that the returned value requires the static lifetime
:thinking:
if I change the return type to &'a i32
then it works
hm
but if I want to capture a reference
and return a value
impl FnMut() -> (i32 + 'a)
that doesn't work either
i32 is not a trait
ah fuck
ummmmm
wow this has me stumped
lifetime param is part of return type, not a trait = =
send full code on playground so i can play around with it?
and it's use on reference to tell the compiler that the references with given lifetime params can be use safe
I basically want to make the returned closure return i32 instead of &i32
ok so you need to deref it then
inside the closure
a move closure wont be FnMut either
it shouldnt be, at least
then why consider the lifetime? i32 is
Copy default @gnzlbg
because this is a mwe
mve*
basically youre trying to take &T and coerce it to T
no
to do that you need to deref it
what does
mve*mean?
i am storing a &T in a closure
well, that's what rust sees
minimum viable example
minimum working example
return
*thing, not just thing
mwe
get
in any case
i always think of it like mvp, minimum viable product
the real object is large
I want to have a closure that stores a reference to it
yes
and that clones it out when needed
but do you want to return the object or a reference to it?
a copy / clone on the object
but i don't want to store that in the closure
I also want full borrowck so I am using rust references and not raw pointers for this (I want to get a compile error when I am trying to build a closure that does not live long enough)
it must be doable because the reference case works
the problem is that when I omit the reference in the return type i cannot tell the compiler what the lifetime of the closure is
so you should wrap it in an uncopiable type?
fn bar<'a>(y: &'a i32) -> impl (FnMut()->i32) + 'a {
move || *y
}
move || *y
}
this works :/
i think you need
for
I tried (impl FnMut()->i32) + 'a
but never tried impl (FnMut()->i32) + 'a
duh
try
for<'b> somewhere
no need
that just works
one just needed to get the parentheses right
thanks anyways, unnecessary head smashing :D
glad it works!
fn bar<'a>(y: &'a i32) -> impl FnMut()->i32 + 'a {
move || *y
}
fn main() {
let x = 42;
println!("{}", bar(&x)());
}
no need to add parentheses 0. 0
its clearer with parentheses
showing its not
i32 + 'a
or maybe
thats what you need
well idk
ok
I'm going to write lifetime params in the first place for more clearness
like
but this only means I return a closure with liftetime
impl 'a + FnMut() -> i32but this only means I return a closure with liftetime
'a, not only the y with the 'a lifetime
yeah
my example stores the
y in the closure
so if your closure only has one data member, of lifetime
'a, then saying that the closure also has the lifetime 'a is a good approximation
(not a good approximation, but actually the right one)
if your closure stores multiple data-members with different lifetimes then this gets more complicated
I think this example can be induced by the compiler.
And I agree you on the more complex cases you're talking about.
And I agree you on the more complex cases you're talking about.
let induced = inferred;
Guys, how i can insert here:
let text_area: gtk::TextView = builder.get_object("output_label").unwrap() output of let mut out = 1 + 2 for example?
didn't understand your question
I have gtk::TextView, and i want to create something like calculator
How to insert to gtk::TextView some strings?
or i32 with f64
@aprokurov I'd probably start with a
gtk::Label instead of gtk::TextView
And how to insert string to gtk::Label?
I'm pretty sure it should be something like
output_label.set_label(&format!("{}", out))
i don't see set_label here:( http://gtk-rs.org/docs/gtk/struct.Label.html
Only this:
use gtk::Label;
use gtk::prelude::*;
let label = Label::new(None);
let text =
r#"Go to the
<a href="http://www.gtk.org" title="<i>Our</i> website">
GTK+ website</a> for more..."#;
label.set_markup(text);
They live in a separate trait --
LabelExt::set_label
Thanks!So i just need something like this:
label.set_label(&format!("{}", out));
If i had gtk::Entry i need to
let mut out = gtkentrylabel.get_text();?
Most likely you don't need
mut
Thanks for help!
Get error...
error[E0423]: expected value, found struct `gtk::Entry`
--> src/main.rs:19:22
|
19 | let text_entry = gtk::Entry = builder.get_object("text_enter").unwrap();
| ^^^^^^^^^^ did you mean `gtk::Entry { /* fields */ }`?
The first
= should have been :, no?
woops
Now it works
Now i had another question, how to convert this
let get_text_from_entry = atext_entry.get_text(); to i32
i know only one, it have type
std::option::Option<std::string::String>
let value: i32 = text.unwrap_or("").parse()?;
let get_text_from_entry = atext_entry.get_text();
let anum: i32 = get_text_from_entry.unwrap_or("").parse()?;let anum: i32 = get_text_from_entry.unwrap_or("").parse()?;
| ------------------------------------------
| |
| cannot use the `?` operator in a function that returns `()`
| in this macro invocation
Well, then you need to do something to this error :-) what do you expect to be done when the user types "hello" into an input field?
It breaks
but i think nobody enter words to entry, only numbers
Users will do every stupid thing you can imagine :-)
:laughing:
error[E0308]: mismatched types
--> src/main.rs:26:55
|
26 | let anum: i32 = get_text_from_entry.unwrap_or("").parse()?;
| ^^ expected struct `std::string::String`, found reference
|
= note: expected type `std::string::String`
found type `&'static str`
= help: here are some functions which might fulfill your needs:
- .escape_debug()
- .escape_default()
- .escape_unicode()
- .to_ascii_lowercase()
- .to_ascii_uppercase()
error[E0277]: the `?` operator can only be used in a function that returns `Result` (or another type that implements `std::ops::Try`)
--> src/main.rs:26:25
|
26 | let anum: i32 = get_text_from_entry.unwrap_or("").parse()?;
| ------------------------------------------
| |
| cannot use the `?` operator in a function that returns `()`
| in this macro invocation
|
= help: the trait `std::ops::Try` is not implemented for `()`
= note: required by `std::ops::Try::from_erro
Yes, the unwrap should have been
.unwrap_or("".to_string())
still not working
rror[E0277]: the `?` operator can only be used in a function that returns `Result` (or another type that implements `std::ops::Try`)
--> src/main.rs:26:25
|
26 | let anum: i32 = get_text_from_entry.unwrap_or("".to_string()).parse()?;
| ------------------------------------------------------
| |
| cannot use the `?` operator in a function that returns `()`
| in this macro invocation
|
the error says it all doesn't it?
@aprokurov I've already asked you: what do you want to do when the user types some text into your input field and presses the button?
that's full code
extern crate gtk;
use gtk::prelude::*;
use gtk::{Label,Button, Window, WindowType};
use gtk::Entry;
//use gtk::LabelExt;
fn main() {
if gtk::init().is_err() {
println!("Failed to initialize GTK.");
return;
}
let glade_src = include_str!("ui.glade");
let builder = gtk::Builder::new_from_string(glade_src);
let button: gtk::Button = builder.get_object("proceed").unwrap();
let window: gtk::Window = builder.get_object("window1").unwrap();
let text_area: gtk::Label = builder.get_object("output_label").unwrap();
let atext_entry: gtk::Entry = builder.get_object("anum").unwrap();
let btext_entry: gtk::Entry = builder.get_object("bnu").unwrap();
let ctext_entry: gtk::Entry = builder.get_object("cnum").unwrap();
button.connect_clicked(move |_| {
println!("Button pressed");
let get_text_from_entry = atext_entry.get_text();
let anum: i32 = get_text_from_entry.unwrap_or("".to_string()).parse()?;
});
window.show_all();
gtk::main();
}That's full error
error[E0277]: the `?` operator can only be used in a function that returns `Result` (or another type that implements `std::ops::Try`)
--> src/main.rs:26:25
|
26 | let anum: i32 = get_text_from_entry.unwrap_or("".to_string()).parse()?;
| ------------------------------------------------------
| |
| cannot use the `?` operator in a function that returns `()`
| in this macro invocation
|
= help: the trait `std::ops::Try` is not implemented for `()`
= note: required by `std::ops::Try::from_error`
error: aborting due to previous error
error: Could not compile `runo_gtk`.
well you are already unwrapping it right?
i want to convert it to i32
why do you expect it to return a result after unwrapping?
i need to get i32
And if it's not an i32, then?
Yes, Rust is forcing you to think about this case too.
display error
i make some gtk popup window with error later
BTW, I'd really suggest you don't throw
unwraps right and left with such ease.
i'd agree with that
i just need to convert to i32, i think that programm will be used by 4-10 people from my school class
I think better ask about that in gitter channel of gtk-rs
i don't see it as a gtk issue tbh
well you are not understanding the code you are writing and the error that is being thrown
Your error is not gtk-specific. It's related to the fact that you need to process the error case in some way. The
? operator is the most ergonomic one usually, but it needs the caller to expect a Result.
And how i can "create" that caller, i'm not so good at Rust
What I'd do here is to move the computation to a function returning a
Result<i32, whatever_error_type_you_need> and wrap it in a closure that does something to the result.
whatever_error is important?
If the only operation that can fail is
parse of an integer, it can be ParseIntError
i think i need to slep, i from Russia and there time is 1 pm, maybe at the morning i can do something with that