Outputs the following error when I run cargo run

Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading skiplist v0.2.4
 Downloading time v0.1.26
 Downloading gcc v0.3.8
   Compiling libc v0.1.8
   Compiling gcc v0.3.8
   Compiling response v0.1.0 (file:///Workspace/rustlang/git/rsedis)
   Compiling parser v0.1.0 (file:///Workspace/rustlang/git/rsedis)
<std macros>:6:1: 6:32 error: the trait `core::convert::From<core::num::ParseFloatError>` is not implemented for the type `ParseError` [E0277]
<std macros>:6 $ crate:: convert:: From:: from ( err ) ) } } )
               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<std macros>:1:1: 6:48 note: in expansion of try!
parser/src/lib.rs:77:39: 77:66 note: expansion site
<std macros>:6:1: 6:32 error: the trait `core::convert::From<core::num::ParseFloatError>` is not implemented for the type `ParseError` [E0277]
<std macros>:6 $ crate:: convert:: From:: from ( err ) ) } } )
               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<std macros>:1:1: 6:48 note: in expansion of try!
parser/src/lib.rs:79:35: 79:57 note: expansion site
<std macros>:6:1: 6:32 error: the trait `core::convert::From<core::num::ParseFloatError>` is not implemented for the type `ParseError` [E0277]
<std macros>:6 $ crate:: convert:: From:: from ( err ) ) } } )
               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<std macros>:1:1: 6:48 note: in expansion of try!
parser/src/lib.rs:85:19: 85:41 note: expansion site
error: aborting due to 3 previous errors
Build failed, waiting for other jobs to finish...
Could not compile `parser`.

To learn more, run the command again with --verbose.

cant run cargo build

warning: unused import: libc::funcs::c95::ctype::isprint

compiling parser v0.1.0 ...... rsedis/parser error[E0554]..... skiplist.0.2.10/src/lib.rs:26:35

I am learning rust and the source code of rsedis is a good teaching material.But I found a BUG:

  pub fn ltrim(&mut self, _start: i64, _stop: i64) -> Result<(), OperationError> {
        let list = match *self {
            ValueList::Data(ref mut list) => {
                let len = list.len();
                let start = match normalize_position(_start, len) {
                    Ok(i) => i,
                    Err(g) => if !g { 0 } else {
                        list.split_off(len);
                        len
                    },
                };
                let stop = match normalize_position(_stop, len) {
                    Ok(i) => i,
                    Err(g) => if !g {
                        list.split_off(len);
                        0
                    } else { len },
                };
                list.split_off(stop + 1);
                list.split_off(start)
            }
        };
        *self = ValueList::Data(list);
        Ok(())
    }

This is a function of the struct ValueList in database/src/list.rs. If _stop argument equal or greater than len , the value of stop will be len and stop + 1 will out of range. If stop less than len and start greater than stop + 1 , the program will panic.

So I'm forking this library as a base to add a Redis-compatible API to my own database backend, and I thought I'd split out my own general fixes for efficiency and coding style into their own PR so that I could merge them back upstream. I'll explain some of the more common fixes:

• &String/&Vec<T> are unnecessary for the API and just add an extra pointer indirection, you should use &str/&[T]
• format!(..).to_owned() is unnecessary, format! already returns a String so you're creating a String, then copying it to a new allocation and dropping the first String.
• format!("{}", foo) is strictly slower than foo.to_string() since Rust's formatting machinery is a little inefficient (there might be a fast path for this in the compiler that makes it just as fast as to_string but to_string is clearer anyway)
• General replacement of owned heap-based structures like Vec<T> and String with their borrowed counterparts where possible
• Replace write with write_all, since every case where write was used the returned value was ignored and so if only part of the value could be written you would have ignored that error
• Make the build script put the generated file into OUT_DIR, which is considered best practice (and in fact if you try to publish a crate, cargo will make sure that you're not generating any files in the source directory during the build)
• Update to Rust edition 2018 and remove deprecated code

Great job on this project by the way! None of these issues I've fixed are that bad, they're just less-efficient ways of doing things or minor violations of Rust language style. If you want to get more specific warnings, many of the points above can be found with Clippy. If you run rustup component add clippy and then cargo clippy, you'll get far more warnings than the Rust compiler emits by default.

I'm not at all familiar with the codebase, but figured it might be worth a look in case you want to consider a similar approach here.

https://youtu.be/s19G6n0UjsM https://jon.thesquareplanet.com/crates/noria/

Can not compile on windows for x86_64-pc-windows-msvc target with VisualStudio 2019.

... almost 50k lines ommited ...
error: aborting due to 4550 previous errors

For more information about this error, try `rustc --explain E0412`.
error: Could not compile `kernel32-sys`.

(see full cargo output build.log.msvc.txt)

kernel32-sys crate is now obsolete and should be replaced with winapi.

I'm using Redis for some time series logging on a Raspberry Pi, but I just had to compile Redis 5.0 from source for Streams.

It would be great if rsedis supported Streams with a short guide to embed the same functionality in my Rust program so I can drop Redis as a custom-build dependency :).

Good luck with your project! Looks cool

The code did not compile with rustc 1.13.0-nightly (91f057de3 2016-09-04), so I fixed it.

I also ran rustfmt on it, in a separate commit, in order to clearly separate semantic changes from style changes.

The tests, ran with $ tclsh tests/test_helper.tcl, all passed successfully.

Once https://github.com/alexcrichton/net2-rs/pull/6 is merged, this will enable the same behaviour as real Redis.

I explicitely disabled it for Windows for the known and discussed reasons.

I am always curious on how people do the "conversion" from one language to another? Did you take the original source code and translated it one file after another or did you take the concepts and try to implement it or another way?

Sorry for my curious mind. Thanks.