Good question. Currently built ins are defined purely inside the compiler, but I would like to do what you're describing (which Java also does: native) and make it so you can have the signature in a source file and the implementation internal
I guess demangling is not so much what we need as it is mangling: we have a Pytek type signature which can be converted into a list of C++ type signatures, and from that we want the symbol
I've been hunting around for something that will do this
Other idea: func type.foo( x : int) -> Void { ... } is equivalent to func foo( this : type, x int ) -> Void { ... } and can also be called as object.foo(3) being the same as foo(object, 3), however it requires that type does not already have such a function.
So many times I've wished I could define my own e.g. string reverse function that I could call as "foo".reverse() and not necessarily reverse("foo")
Golfing and no other application I can think of at the moment.
I'm trying though
Maybe if you have a list of the first indices of a in some strings, and you end up with a bunch of nulls for strings that don't have a in them, so you don't want to do anything with those.
Small idea: deprecated keyword, e.g. deprecated public foo() -> Void { ... }. Doesn't do anything but causes a compiler warning: "function foo is deprecated". deprecated<bar> public foo() would say "function foo is deprecated, use bar instead."
Maybe C# style annotations, if @ is apply? They wouldn't actually be confused by the compiler since there wouldn't be anything before the @ in annotations, but for readability.
[Guid("123565C4-C5FA-4512-A560-1D47F9FDFA20")]
public interface IConfig
{
[DispId(1)]
string Destination{ get; }
[DispId(2)]
void Unserialize();
[DispId(3)]
void Serialize();
}
[ComVisible(true)]
[Guid("12AC8095-BD27-4de8-A30B-991940666927")]
[ClassInterface(ClassInterf...
