I just started to experiment with mapped types.
Just to see what it is doing I wrote:
type Test = public class mapped to String
end;
I expected to have a fully working mapped type now that has a 1:1 mapping to String, meaning that I only have to implement the parts where the mapping is needed (where Test has another interface than String).
But when I use it, none of the methods or properties of String are known in Test.
This makes it very hard to create a mapping for a complex class.
Is this by design?
Is there a way to start with a 1 to 1 mapping and implement the differences only?
For my understanding a mapped type is a new type and needs all the methods and properties you want to use.
So you can map the different platform classes to a single type signature.
I guess if you expose all the method of the original type, then the mapped type is not so cross-platform any more, as you can use methods that are not available on all platforms.
It is, yes. The goal for mapped types is create a new “virtual” type with different exposed Apis than the original. If all the original members were still available, what would be gained by the new type?
If you simply want the type under a different name, you should use a type alias.
If you want to add additional members to the type, on top of the existing ones, you’ll want to look at defining an Extension, instead.
How would you remove members you want to hide though? I cannot envision a non-ugly way to do that, even if we supported such a mode.
As always, I was looking for a way to do the impossible, in this case a way to re-implement methods and properties on sealed classes (I know dirty ,not OOP, and I should not do that - but it would save so much time implementing some things…).
Note that mapped classes, like extensions, cannot add new storage to a class. To just add new behavior or helper methods, an extension is the best option, IMHO.
I agree - in this case I wanted to implement Substring is such a way that it never throws an exception, but return an empty string instead - what I can do with a mapped type. But because I have to map all other members by hand (I don’t want to hide anything) it just isn’t worth it.
Just to test my luck
Possible syntax:
type Test = public class mapped to String with default mappings //Everything that is not defined is mapped 1 on 1
Public Method SubString(start: Integer; lenght: Integer); //reimplementation
Public Method SubString(Start: Integer); //reimplementation
[EditorBrowsable(never)]Public Method Clone: Object; //Hides the clone method from the mapped class
end;
But when you have a class with 100 methods and 50 properties, and you need a mapped class where 4 methods should be hidden, 5 methods should be reimplemented (or mapped in a special way) while the other ones should stay as they were, this saves a lot of work.
If I remember correctly, when a extension has the same signature (name and parameters types) as an existing method of the class, the existing method takes precedence.
I think you missintepret mapped classes.
They are here to help for cross platform, so you can have a single Signature across Platforms.
But maybe I don’t really understand what you try to solve. (happens all the time with a lot of things)
Problem with this is that it gives the possibility to redefine a method within a dll.
Whoever references this dll will get the new implementation (regardless if they want it or not).
That is why (I think) extensions never hide existing members.
So I that is why I went to the mapped classes - this will define a new class name where the methods are redefined, so it will not have any side effects on other software.
