Menu
Why the following is not allowed? (2.12):
type Foo <: {def foo(): Unit}
type Bar <: {def bar(): Unit} with Foo
Looks natural to me, Bar should have both foo() and bar().
923
Use an intersection type to extend a type in TypeScript, e.g. type TypeB = TypeA & {age: number;} . Intersection types are defined using an ampersand & and are used to combine existing object types. You can use the & operator as many times as necessary to construct a type.
A structural type system means that when comparing types, TypeScript only takes into account the members on the type. This is in contrast to nominal type systems, where you could create two types but could not assign them to each other.
TypeScript allows an interface to extend a class. In this case, the interface inherits the properties and methods of the class. Also, the interface can inherit the private and protected members of the class, not just the public members.
Duck typing can be viewed as a usage-based structural equivalence between a given object and the requirements of a type.
Seems to work with parenthesis
scala> type Foo <: {def foo(): Unit}
| type Bar <: ({def bar(): Unit}) with Foo
type Foo
type Bar
type Foo <: {def foo(): Unit} is type Foo <: AnyRef{def foo(): Unit}.
So while type Bar <: {def bar(): Unit} with Foo is not parsable, with AnyRef and different order it works
type Foo <: {def foo(): Unit}
type Bar <: Foo with AnyRef{def bar(): Unit}
val b: Bar = ???
b.foo()
b.bar()
Also with brackets (and direct order) it works
type Foo <: {def foo(): Unit}
type Bar <: ({def bar(): Unit}) with Foo
val b: Bar = ???
b.foo()
b.bar()
Actually type Bar <: {def bar(): Unit} with Foo is against the spec while type Bar <: ({def bar(): Unit}) with Foo satisfies the spec because {def bar(): Unit} is not a SimpleType but ({def bar(): Unit}) is a SimpleType.
CompoundType ::= AnnotType {‘with’ AnnotType} [Refinement]
| Refinement
AnnotType ::= SimpleType {Annotation}
SimpleType ::= ............
| ‘(’ Types ‘)’
Types ::= Type {‘,’ Type}
Type ::= ...........
| CompoundType
| ...........
https://scala-lang.org/files/archive/spec/2.13/03-types.html#compound-types
32
It's not allowed by the spec, which calls the { ...} part a refinement which may both have a with clause. The other way around it's fine though.
That's somewhat tautological of course as it doesn't say why it's not allowed by the spec. It appears there is no deep understanding here, just that that's not a way you're allowed to write a type. You should be able to express the same intent in another way.
41
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
