I'd like to hear some comments about the following ideas; maybe they are someway obsolete or even useless nonsense.
A few days ago, I thought about abstracting the instance of an object away, like used in Foreign.Storable.sizeOf::(Storable a)=>a->Int, where only the type of an object is used.
The problem with the function sizeOf is, that the result should be constant per definition(*), but how can we make the compiler know this?
So I thought we may need a new (abstract) datatype to wrap the type of an object, just to contain no dynamic data:
data Type a
typeOf :: a -> Type a
typeOf = undefined
#define TYPE(a) (undefined::Type (a))
sizeOf :: (Storable a) => Type a -> Int
Maybe this is a little bit too ugly and cumbersomely, just to make sizeOf constant.
This version of sizeOf is not really comfortable anymore; but it isn't comfortable to write "(undefined::a)", too.
To be able to write "(::a)" instead, would be really nice, IMHO; but how about "(_::a)"?
<trying to be equivocating>
undefined is another way to implement ...nothing.
</trying to be equivocating>
More comfortable would it be to write a single symbol instead of the long word "undefined":
_ :: a
_ = undefined
Using "_" as a function should not be such a problem: it cannot be mixed with the joker "_" as parameter.
To define this function may be a problem: It needs a compiler-patch to allow this, ATM.
By the way, this symbol is not used at type-level... How about praefix/postfix operators instead of only infix?
newtype BigLambda a = BigLambda a
(/\) :: _ -> a -> BigLambda a
/\ a = BigLambda a
newtype Lifted a = Lifted a
(!^) :: a -> _ -> Lifted a
a !^ = Lifted a
May this be confusing? Or even impossible? Am I insane?
Well, I don't know how hard it would be to implement those language features. I would not like to make anyone implement all this, if it is only a niceToHave-butIDontUseIt, like the implicit parameters feature.