[oschijns]

Allow defining the sign of a numerical value without wrapping into into extra parenthesis.
from

  let buffer = tvf!(SimpleStringTvf {
      10 => (-10),
      11 => (-10.25),
      12 => (-2) as Signed,
      13 => (+2.125) as Float,
  });

to

  let buffer = tvf!(SimpleStringTvf {
      10 => -10,
      11 => -10.25,
      12 => -2 as Signed,
      13 => +2.125 as Float,
  });

[reneca]

Some edge cases are not working with this solution. I think you should reconsider the negative sign parsing. It should be apply on the expression.
For me these should work (not the case right now):

let amount: i64 = 7;

let buffer = tvf!(SimpleStringTvf {
    1 => -amount as Signed,
});

assert_eq!(Ok(-7), buffer.get_signed(1));

Also for String conversion:

let buffer = tvf!(SimpleStringTvf {
    1 => -7 as String,
});

assert_eq!(
    Ok("-7"),
    buffer.get_string(1).map(|value| value.to_string()).as_deref(),
);

And maybe an error could be trigger if we try to negate an unsigned value:

let buffer = tvf!(SimpleStringTvf {
    1 => -7 as Unsigned,
    2 => -7u64,
});

assert_ne!(Ok(7), buffer.get_unsigned(1));
assert_ne!(Ok(7), buffer.get_unsigned(2));

[reneca]

You fix common things, but we still have an issue regarding expression.
For example: -(left - right) as Signed, with left = 10 and right = 3, stores 7 instead of -7. Can you also consider it please ?

Also what can we do about these ?

-7 as Unsigned // stores 7
-7u64          // stores 7
-7 as Byte     // stores 7

BTW you didn't sign your last commit.
And can you increase prose_macros version to 0.5.1 please.

[reneca]

User can also put !false and it'll be consider as false. It should consume the token only if it's -.

[oschijns]

Also what can we do about these ?

-7 as Unsigned // stores 7
-7u64          // stores 7
-7 as Byte     // stores 7

They should throw an error. I'll look into it.

[oschijns]

I think I've fixed some of the issues. But I am not satisfied with the implementation.
value.rs and literal.rs are kind of doing the same thing so there should be a way to group them.

[oschijns]

The refactoring is done.
The existing tests pass and unary operator can be easily tweaked.
Maybe we could add support for format! to trivially format a primitive type into a string and deduce that the resulting field is a string.

[oschijns]

Test borrow and dereference operators with strings.
Test using constants and variables as field identifiers.

Implement format! so we can trivially write:

  let buffer = tvf!(SimpleStringTvf {
      1 => format!("{:0<12}", var),
  });

[reneca]

-"abc" give "abc", but -"abc" as String give an error. You should return an error when modifier.is_numeric() and the type is not Byte/Signed/Unsigned/Float.

[reneca]

-format!(..) should not work. Can you reject the case ?

[oschijns]

It should be fixed now

[reneca]

There is lot ongoing in this.
But there is many case to handle.
It's maybe dumb, but could this be enough: (#modifier #lit).to_string() ?

[oschijns]

Nope it doesn't work, I encounter edge-cases

assertion `left == right` failed
  left: Ok("string from bytes")
 right: Ok("b\"string from bytes\"")