Some work on std::ascii

[Kimundi]

• Marked a unsafe helper function as unsafe, added a second helper function
• Added moving implementations

[huonw]

This might be cleaner if one converted the string to ~[u8] and just used .mut_iter(); rather than pointer dances.

[Kimundi]

It would be indeed, but the function I updated there used pointer arithmetic for what I assumed to be speed reasons. I don't really know how to test such things, so I left the basic structure of the function as is.

[huonw]

The iterators are designed to optimize very well (they use pointers arithmetic internally); so that gives you the benefit of no unsafe code and equal (or faster) speed.

[Kimundi]

I could just replace both str_map_bytes and str_copy_map_bytes with iterator chains if you think that would be better.

str_copy_map_bytes originally got introduced in #8231 under the name map_bytes. @SimonSapin: Any reason why you choose pointer arithmetic?

[SimonSapin]

I wasn’t aware of vec.mut_iter(). How do you get a mutable[u8] from a string?

[huonw]

In this case, I think string.into_bytes() to get a ~[u8] which can be placed into a mut slot. (And then str::from_bytes_owned() at the end.)

(And yes; I think keeping the amount of unsafe code as small as possible is a good goal: less code to audit, and if there is a bug found then it'll only need to be changed in one spot.)

[SimonSapin]

I think you’d want str::raw::from_bytes_owned to avoid the UTF-8 check. (This is safe when the map only changes bytes in the ASCII range.)

[Kimundi]

Okay, gonna rewrite the functions to only use unsafe to circumvent the utf8 checks.

[Kimundi]

• Marked a unsafe helper function as unsafe, added a second helper function
• Added moving implementations

[huonw]

This might be cleaner if one converted the string to ~[u8] and just used .mut_iter(); rather than pointer dances.

[Kimundi]

It would be indeed, but the function I updated there used pointer arithmetic for what I assumed to be speed reasons. I don't really know how to test such things, so I left the basic structure of the function as is.

[huonw]

The iterators are designed to optimize very well (they use pointers arithmetic internally); so that gives you the benefit of no unsafe code and equal (or faster) speed.

[Kimundi]

I could just replace both str_map_bytes and str_copy_map_bytes with iterator chains if you think that would be better.

str_copy_map_bytes originally got introduced in #8231 under the name map_bytes. @SimonSapin: Any reason why you choose pointer arithmetic?

[SimonSapin]

I wasn’t aware of vec.mut_iter(). How do you get a mutable[u8] from a string?

[huonw]

In this case, I think string.into_bytes() to get a ~[u8] which can be placed into a mut slot. (And then str::from_bytes_owned() at the end.)

(And yes; I think keeping the amount of unsafe code as small as possible is a good goal: less code to audit, and if there is a bug found then it'll only need to be changed in one spot.)

[SimonSapin]

I think you’d want str::raw::from_bytes_owned to avoid the UTF-8 check. (This is safe when the map only changes bytes in the ASCII range.)

[Kimundi]

Okay, gonna rewrite the functions to only use unsafe to circumvent the utf8 checks.

[Kimundi]

• Marked a unsafe helper function as unsafe, added a second helper function
• Added moving implementations

[huonw]

This might be cleaner if one converted the string to ~[u8] and just used .mut_iter(); rather than pointer dances.

[Kimundi]

It would be indeed, but the function I updated there used pointer arithmetic for what I assumed to be speed reasons. I don't really know how to test such things, so I left the basic structure of the function as is.

[huonw]

The iterators are designed to optimize very well (they use pointers arithmetic internally); so that gives you the benefit of no unsafe code and equal (or faster) speed.

[Kimundi]

I could just replace both str_map_bytes and str_copy_map_bytes with iterator chains if you think that would be better.

str_copy_map_bytes originally got introduced in #8231 under the name map_bytes. @SimonSapin: Any reason why you choose pointer arithmetic?

[SimonSapin]

I wasn’t aware of vec.mut_iter(). How do you get a mutable[u8] from a string?

[huonw]

In this case, I think string.into_bytes() to get a ~[u8] which can be placed into a mut slot. (And then str::from_bytes_owned() at the end.)

(And yes; I think keeping the amount of unsafe code as small as possible is a good goal: less code to audit, and if there is a bug found then it'll only need to be changed in one spot.)

[SimonSapin]

I think you’d want str::raw::from_bytes_owned to avoid the UTF-8 check. (This is safe when the map only changes bytes in the ASCII range.)

[Kimundi]

Okay, gonna rewrite the functions to only use unsafe to circumvent the utf8 checks.

[Kimundi]

• Marked a unsafe helper function as unsafe, added a second helper function
• Added moving implementations

[huonw]

This might be cleaner if one converted the string to ~[u8] and just used .mut_iter(); rather than pointer dances.

[Kimundi]

It would be indeed, but the function I updated there used pointer arithmetic for what I assumed to be speed reasons. I don't really know how to test such things, so I left the basic structure of the function as is.

[huonw]

The iterators are designed to optimize very well (they use pointers arithmetic internally); so that gives you the benefit of no unsafe code and equal (or faster) speed.

[Kimundi]

I could just replace both str_map_bytes and str_copy_map_bytes with iterator chains if you think that would be better.

str_copy_map_bytes originally got introduced in #8231 under the name map_bytes. @SimonSapin: Any reason why you choose pointer arithmetic?

[SimonSapin]

I wasn’t aware of vec.mut_iter(). How do you get a mutable[u8] from a string?

[huonw]

In this case, I think string.into_bytes() to get a ~[u8] which can be placed into a mut slot. (And then str::from_bytes_owned() at the end.)

(And yes; I think keeping the amount of unsafe code as small as possible is a good goal: less code to audit, and if there is a bug found then it'll only need to be changed in one spot.)

[SimonSapin]

I think you’d want str::raw::from_bytes_owned to avoid the UTF-8 check. (This is safe when the map only changes bytes in the ASCII range.)

[Kimundi]

Okay, gonna rewrite the functions to only use unsafe to circumvent the utf8 checks.

[Kimundi]

• Marked a unsafe helper function as unsafe, added a second helper function
• Added moving implementations

[huonw]

This might be cleaner if one converted the string to ~[u8] and just used .mut_iter(); rather than pointer dances.

[Kimundi]

It would be indeed, but the function I updated there used pointer arithmetic for what I assumed to be speed reasons. I don't really know how to test such things, so I left the basic structure of the function as is.

[huonw]

The iterators are designed to optimize very well (they use pointers arithmetic internally); so that gives you the benefit of no unsafe code and equal (or faster) speed.

[Kimundi]

I could just replace both str_map_bytes and str_copy_map_bytes with iterator chains if you think that would be better.

str_copy_map_bytes originally got introduced in #8231 under the name map_bytes. @SimonSapin: Any reason why you choose pointer arithmetic?

[SimonSapin]

I wasn’t aware of vec.mut_iter(). How do you get a mutable[u8] from a string?

[huonw]

In this case, I think string.into_bytes() to get a ~[u8] which can be placed into a mut slot. (And then str::from_bytes_owned() at the end.)

(And yes; I think keeping the amount of unsafe code as small as possible is a good goal: less code to audit, and if there is a bug found then it'll only need to be changed in one spot.)

[SimonSapin]

I think you’d want str::raw::from_bytes_owned to avoid the UTF-8 check. (This is safe when the map only changes bytes in the ASCII range.)

[Kimundi]

Okay, gonna rewrite the functions to only use unsafe to circumvent the utf8 checks.

[Kimundi]

• Marked a unsafe helper function as unsafe, added a second helper function
• Added moving implementations

[huonw]

This might be cleaner if one converted the string to ~[u8] and just used .mut_iter(); rather than pointer dances.

[Kimundi]

It would be indeed, but the function I updated there used pointer arithmetic for what I assumed to be speed reasons. I don't really know how to test such things, so I left the basic structure of the function as is.

[huonw]

The iterators are designed to optimize very well (they use pointers arithmetic internally); so that gives you the benefit of no unsafe code and equal (or faster) speed.

[Kimundi]

I could just replace both str_map_bytes and str_copy_map_bytes with iterator chains if you think that would be better.

str_copy_map_bytes originally got introduced in #8231 under the name map_bytes. @SimonSapin: Any reason why you choose pointer arithmetic?

[SimonSapin]

I wasn’t aware of vec.mut_iter(). How do you get a mutable[u8] from a string?

[huonw]

In this case, I think string.into_bytes() to get a ~[u8] which can be placed into a mut slot. (And then str::from_bytes_owned() at the end.)

(And yes; I think keeping the amount of unsafe code as small as possible is a good goal: less code to audit, and if there is a bug found then it'll only need to be changed in one spot.)

[SimonSapin]

I think you’d want str::raw::from_bytes_owned to avoid the UTF-8 check. (This is safe when the map only changes bytes in the ASCII range.)

[Kimundi]

Okay, gonna rewrite the functions to only use unsafe to circumvent the utf8 checks.

[Kimundi]

• Marked a unsafe helper function as unsafe, added a second helper function
• Added moving implementations

[huonw]

This might be cleaner if one converted the string to ~[u8] and just used .mut_iter(); rather than pointer dances.

[Kimundi]

It would be indeed, but the function I updated there used pointer arithmetic for what I assumed to be speed reasons. I don't really know how to test such things, so I left the basic structure of the function as is.

[huonw]

The iterators are designed to optimize very well (they use pointers arithmetic internally); so that gives you the benefit of no unsafe code and equal (or faster) speed.

[Kimundi]

I could just replace both str_map_bytes and str_copy_map_bytes with iterator chains if you think that would be better.

str_copy_map_bytes originally got introduced in #8231 under the name map_bytes. @SimonSapin: Any reason why you choose pointer arithmetic?

[SimonSapin]

I wasn’t aware of vec.mut_iter(). How do you get a mutable[u8] from a string?

[huonw]

In this case, I think string.into_bytes() to get a ~[u8] which can be placed into a mut slot. (And then str::from_bytes_owned() at the end.)

(And yes; I think keeping the amount of unsafe code as small as possible is a good goal: less code to audit, and if there is a bug found then it'll only need to be changed in one spot.)

[SimonSapin]

I think you’d want str::raw::from_bytes_owned to avoid the UTF-8 check. (This is safe when the map only changes bytes in the ASCII range.)

[Kimundi]

Okay, gonna rewrite the functions to only use unsafe to circumvent the utf8 checks.

[Kimundi]

• Marked a unsafe helper function as unsafe, added a second helper function
• Added moving implementations

[huonw]

This might be cleaner if one converted the string to ~[u8] and just used .mut_iter(); rather than pointer dances.

[Kimundi]

It would be indeed, but the function I updated there used pointer arithmetic for what I assumed to be speed reasons. I don't really know how to test such things, so I left the basic structure of the function as is.

[huonw]

The iterators are designed to optimize very well (they use pointers arithmetic internally); so that gives you the benefit of no unsafe code and equal (or faster) speed.

[Kimundi]

I could just replace both str_map_bytes and str_copy_map_bytes with iterator chains if you think that would be better.

str_copy_map_bytes originally got introduced in #8231 under the name map_bytes. @SimonSapin: Any reason why you choose pointer arithmetic?

[SimonSapin]

I wasn’t aware of vec.mut_iter(). How do you get a mutable[u8] from a string?

[huonw]

In this case, I think string.into_bytes() to get a ~[u8] which can be placed into a mut slot. (And then str::from_bytes_owned() at the end.)

(And yes; I think keeping the amount of unsafe code as small as possible is a good goal: less code to audit, and if there is a bug found then it'll only need to be changed in one spot.)

[SimonSapin]

I think you’d want str::raw::from_bytes_owned to avoid the UTF-8 check. (This is safe when the map only changes bytes in the ASCII range.)

[Kimundi]

Okay, gonna rewrite the functions to only use unsafe to circumvent the utf8 checks.