Proposal: ValidateMonoLiterals - Initial bikeshed discussion

[Gershom B]

I recall having some discussions with Mathieu Boespflug regarding how the
static pointers work could be of use here. (And also Richard Eisenberg?) In
particular, we want to demand a special property of our validation
functions -- that they can safely be used at compile-time without
necessarily "linking in the world" and invoking the whole of template
haskell.

A function that is "static" should in a sense have this sort of property?
And so requiring that our validation functions be static seems like a
useful thing from an implementation standpoint. Static semantics might also
help "force the thunk" on what the correct relationship to polymorphism is.

I guess the remaining question is then where to add them. I suppose we
could stick them with special semantics on Num and IsString or the like and
do it by magic?

Alternately we could maybe have a whole class of "compile-time static
functions" that we just explicitly use, and all have the property that they
have type "a -> a" for some concrete "a", and that the value they are
applied to is static. These functions are then applied at compile time, and
forced to whnf. If they toss an error it is a compile error, otherwise they
are not present in the generated code.

There are other design variations possible, but that one feels pretty neat
to me, if feasible.

So then I could write

foo :: Even
foo = even 6

for example, and get errors at compile-time.

On top of this we could add a special way to augment Num, IsString, etc
with such methods to yield the desired:

foo :: Even
foo = 6

-gershom
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/ghc-devs/attachments/20150206/abfae3f1/attachment.html>