Re: [DISCUSSION] Class Constant Enums?
| From: | John Bafford | Date: | Fri, 16 Aug 2024 16:46:43 +0000 |
| Subject: | Re: [DISCUSSION] Class Constant Enums? | ||
| References: | 1 2 3 | Groups: | php.internals |
| Request: | Send a blank email to internals+get-124985@lists.php.net to get a copy of this message | ||
On Aug 16, 2024, at 10:17, Larry Garfield <larry@garfieldtech.com> wrote:
>
> I would have to research to see if other languages did this, but one option would be to allow
> an inner class to extend an outer class even if it's final, which would essentially give us
> sealed classes for free:
>
> final class Outer
> {
> class InnerA extends Outer {}
> class InnerB extends Outer {}
> class InnerC extends Outer {}
> }
>
> // But this is still not OK:
> class Sibling extends Outer {}
>
> Note: I have no idea how difficult/complicated this would be, but I would be in favor of
> exploring it.
>
> --Larry Garfield
Swift allows nested classes to extend their parent. It does not allow nested classes to extend a
final parent. Visibility modifiers can be applied and work as expected. Basically, types also
function as the equivalent of a namespace. More broadly, any type can be nested in any other type,
so you could certainly do something weird like:
```
class A {
enum E {
class C: A {}
case a(A)
case c(C)
}
}
let e = A.E.c(A.E.C())
```
However, you could implement your sealed class example by having a private constructor:
```
class Parent {
final class Child : Parent {
override init() { //within lexical scope of Parent, so can see Parent's private members
super.init()
}
}
private init() {}
}
let parent = Parent() //'Parent' initializer is inaccessible due to 'private'
protection level
let child = Parent.Child() //ok
```
Swift also has a fileprivate visibility, so the same could be accomplished with a fileprivate init
on Parent with a non-nested Child in the same file.
-John