Allow leading '+' in number strings

[Sija]

This PR allows + leading character in numeric strings passed to Big* class constructors, bringing coherence to the rest of the Number constructors and parity with Ruby:

Crystal:

require "big"

# WORKS
"+10".to_i  # => 10
"+10".to_u8 # => 10_u8
"+10".to_f  # => 10.0

# DOESN'T WORK
"+10".to_big_i # => Invalid BigInt: +10 (ArgumentError)
"+10".to_big_d # => Invalid BigDecimal: +10 (Unexpected '+' character) (InvalidBigDecimalException)
"+10".to_big_f # => 0_big_f

Ruby:

require "bigdecimal"
require "bigdecimal/util"

# WORKS
"+10".to_i # => 10
"+10".to_f # => 10.0

"+10".to_d # => 0.1e2
"+10".to_r # => (10/1)
"+10".to_c # => (10+0i)

[RX14]

It would be really simple to optimize this by simply adding 1 to the pointer if str.starts_with? '+'. I think this optimization is so easy it might be a good idea to do it now to avoid the string copy and extra garbage.

[Sija]

yeah, it's done in String#lchop.

[asterite]

@Sija What do you mean? lchop creates a new string. We should just ignore the first char if it's +, like what @RX14 says.

[Sija]

My bad indeed. str = str[1..-1] if str.starts_with?('+')?

[Sija]

Wouldn't be better to implement it directly in String#lchop instead?

[asterite]

It's not possible. All strings have 8 leading bytes: four bytes for the type_id, and four bytes for the string's size. So a substring must have this info too.

In any case, I consider this an optimization. We can merge this now and optimize it later.

[RX14]

Yes, it's an optimization. However, we'll probably forget if this is merged as-is. This is a very simple optimization:

unsafe_str = str.to_unsafe
unsafe_str += 1 if str.starts_with?('+')

then use unsafe_str. If you don't want to implement it, that's fine, it's just simple enough that now is as good a time as any to do this.

[Sija]

I'd like to merge it as-is and leave this perf optimization to the most interested parties like yourself. Thank you.

[asterite]

I general I hate it that we need such unsafe code. We should maybe work with slices in most cases unless we can prove a big performance loss.