doc: typeclasses specification. #36
Conversation
|
|
||
| ### Basics of typeclasses and instances | ||
|
|
||
| 1. `tc` is a name of a typeclass. The type of `tc` is `typeclass`, which is a builtin type. All typeclasses are of type |
There was a problem hiding this comment.
The points here seem very much like they correspond with the line numbers above. Especially since there are 8 of each.
There was a problem hiding this comment.
Addressed, but not pushed yet. The lines are now "named" with letters instead of numbers.
doc/docs/spec/typeclasses/index.md
Outdated
| let tc = with (T : type) typeclass { // 1 | ||
| function fndecl() -> int; // 2 | ||
|
|
||
| function fndef(arg : int) -> int { // 3 |
There was a problem hiding this comment.
T isn't used here, so its use is less clear. Since you're building this typeclass with int below, it'd be useful to see how T can be used to represent that here.
There was a problem hiding this comment.
Addressed, not pushed yet.
doc/docs/spec/typeclasses/index.md
Outdated
| `typeclass`. | ||
| 2. `inst` is a name of a typeclass instance. The type of `inst` is `tc`. | ||
| 3. The type of the unnamed default instance is also `tc`. | ||
| 4. Values of type that is a typeclass can be used as a type. **Drafting note: this is somewhat unimportant for the time |
There was a problem hiding this comment.
This is an important point. I think it's also important to have another point saying that typeclasses can be stored as members, or treated no differently than something else you have specified to which you can refer.
There was a problem hiding this comment.
Your comment is probably a good proof that my sentence here is very confusing. I don't mean values of type tc (in this example); I mean values of type tc(int). I should try to make this clearer, and also write down what you said as a separate point.
There was a problem hiding this comment.
I put this comment on this line only because it seemed like a related place to put it. I wasn't thinking that tc alone could be used as a type, but I do see what you mean about the wording. Either way, both are valid points.
doc/docs/spec/typeclasses/index.md
Outdated
| This section uses names from the following piece of code to define semantics and requirements: | ||
|
|
||
| ``` | ||
| let tc = with (T : type) typeclass { // 1 |
There was a problem hiding this comment.
Only shown here is T : type, but that implies, to me, that T : C is valid. Some examples:
Integer
let bits = with (Bits : int) typeclass {
};
Typeclasses
let bits = with (Bits : int) typeclass {
};
let bits32 = with (Bits : bits(32)) typeclass {
};
More complex usage
let render = with (Dimension : int) typeclass {
function point(v : vector(Dimension)) -> void;
};
Are all of these valid? If so, I think it'd be worth adding a note and/or an example of a non-type parameter to a typeclass.
There was a problem hiding this comment.
I don't think I want value typeclasses to be valid. C++ is trying to do something with value concepts, but I don't think this is reasonable in the model I'm thinking about. This is explicitly meant to be used as a customization point mechanism, which makes no sense for values... I think.
At one point in the future Vapor will have a sort of "template template parameters", then those should be usable as another kind of an argument here. Simiarly you could specify a thing requiring a typeclass to be fulfilled here, but I don't see how values are useful.
doc/docs/spec/typeclasses/index.md
Outdated
| tc(int).fndef(123) // returns 123, per definition (3) | ||
| inst.fndef(123) // returns 122, per definition (8) | ||
| ``` | ||
|
|
There was a problem hiding this comment.
I think it'd be worth mentioning what happens when you refer to an incomplete typeclass. That is, in the case of tc, it only has a default for int. So what if I refer to tc(tc(int)) or tc(float) when there is no implementation for .fndecl?
There was a problem hiding this comment.
Compilation error when trying to say tc(float) because the instance doesn't exist. This also reminds me I haven't actually described the semantics of implicit typeclasses...
There was a problem hiding this comment.
Ah, and of course this is different with the default instance existing. Will write this down.
doc/docs/spec/typeclasses/index.md
Outdated
| }; | ||
|
|
||
| default instance tc(int) { // 4 | ||
| function fndecl() -> int { // 5 |
There was a problem hiding this comment.
Instances shouldn't have to (be able to?) explicitly state the type of the function they are implementing, as this is specified by the typeclass which is being implemented, so will be the same for all instances for a particular type.
|
@jeaye @elliotpotts please check if I've actually addressed your comments in the last commit. |
No description provided.