Type error with negative floats as static expressions

[Gekctek]

Moc version: 0.8.8

I get the following error when trying to declare a static value with a negative float in it: type error [M0014], non-static expression in library or module

module {
	public let t : Float = -147.1; // Error
	public let t2 : Float = 147.1; // No Error
	public let t3 : Int = -147; // No Error
}

Is this intended?
I am trying to generate a large static piece of data but all the negative floats wont work

[nomeata]

Thanks for the good bugreport.

There is some tension whether -123 should be thought of as a single literal, or an unary operator applied to a literal. But the inconsistency you point out is certainly not great, and the use in modules is a strong reason to treat them as one IMHO. Could be a simple fix, didn't look at the code so far.

[rossberg]

Regardless of that distinction, I think -(147.1) should be considered static as well. In general, I see no particular reason not to consider all arithmetic operators static whose semantics is free of traps.

I'm confused about the difference between Float and Int, though. I'm pretty sure signs used to be treated uniformly.

[nomeata]

Ah, the not fully resolved question of whether our notion of “static” for modules means “is a (manifest) value” or “can be evaluated (purely) to a value”. But I guess we don't need to fully answer that, and just continue to find a pragmatic middle ground - we already allow projections, certain (soon more) negations, without claiming to be fully principled here.

[nomeata]

So the staticness checker regards any use of UnE as nonstatic. So why does it work for Int? Probably because of this code in the parser;

  | op=unop e=exp_un(ob)
    { match op, e.it with
      | (PosOp | NegOp), LitE {contents = PreLit (s, Type.Nat)} ->
        let signed = match op with NegOp -> "-" ^ s | _ -> "+" ^ s in
        LitE(ref (PreLit (signed, Type.Int))) @? at $sloc
      | _ -> UnE(ref Type.Pre, op, e) @? at $sloc
    }

Is there a reason to do that only for Type.Nat, and not also Type.Float, @rossberg?

[rossberg]

Okay, it seems that was a hack introduced in #505.

Treating signs as part of literals is nasty. For one, there shouldn't be a difference between -1 and - 1, and I shouldn't be forced to write the former for obscure reasons.

Second, it inevitably screws up operator precedence: for example, making-2**2 result in +4 is surprising and inconsistent with math -- that said, we screwed up precedence of unary operators anyway, and - 2**2 is +4 as well. Other languages are no better, but we set out to avoid such pitfalls.

[nomeata]

Yeah, it’s a mess either way. But doing this to just Type.Nat but not Type.Float is probably not making things better?