raku 内置的访问器方法可以被子类覆盖吗？

Question

我正在尝试“覆盖” raku 为 public $ 生成的内置访问器。属性。但是，我可以使用一些帮助来尝试找出此代码失败的原因...

class Measure {
    has $.value is rw
}

class Angle is Measure {
    multi method value( $x ) { 
        nextwith( $x % 360 );
    }   
}

my $m = Measure.new( value => 27 );
$m.value = 42;     
say $m;   #Measure.new(value => 42)

my $a = Angle.new( value => 27 );
$a.value = 43; 
say $a;   #Error...

Cannot resolve caller value(Angle:D: ); none of these signatures match:
    (Angle: $x, *%_)

你的指导会很有帮助！

Answer 1

当您使用 a.将属性声明为公共属性时，Raku 将创建一个具有相同名称的方法。

该方法不需要参数。
即使是rw。
（如果您将属性声明为，is rw那么生成的方法实际上是用 标记的is rw。）

当您使用nextwith它时，它会分派到父类中的方法。

在这种情况下，该方法不接受任何参数。

这是至少有效的东西：

class Angle is Measure {
    method value( $x ) { 
        callwith() = $x % 360;
    }   
}

my $a = Angle.new( value => 27 );
#$a.value = 43; 
$a.value(43);

当然，这意味着它Angle.value不是像这样的左值Measure.value。
（左值意味着它可以在 的左侧=。）

所以让我们这样做。

由于我们需要在调用过程中进行计算，因此.value我们需要返回一个Proxy

class Angle is Measure {
    method value() is rw { 
        Proxy.new:
            FETCH => -> $ { self.Measure::value },
            STORE => -> $, $x {
                self.Measure::value = $x % 360;
            }
    }   
}

请注意，我们不能只callsame在这些块中使用或相似，因为它们会启动一个新的调度链。
相反，我们需要调用Measure类中方法的版本。

callsame如果将该调用的结果绑定到用作闭包的一部分的变量，则可以使用或 类似的。
（我使用$attr是因为它绑定到实际的属性标量。）

class Angle is Measure {
    method value is rw {
        my $attr := callsame();
        Proxy.new:
            FETCH => -> $ { $attr },
            STORE => -> $, $x {
                $attr = $x % 360;
            }
    }
}

我个人认为这Measure可能应该是一个角色，因为这使事情变得更容易，因为您可以直接访问该属性。

role Measure {
    has $.value is rw
}

class Angle does Measure {
    method value() {
        Proxy.new:
            FETCH => -> $ { $!value },
            STORE => -> $, $x {
                $!value = $x % 360;
            }
    }   
}

我也有一个问题，一个角度被声明为一个数字，而不是说它是度数，而不是说弧度或梯度。

实际上，您甚至没有将其声明为数字。

所以我可能会尝试这样的事情：

role Measure {
    has Real $.value is rw;
}

role Angle {…}

class Degrees  {…}
class Radians  {…}
class Gradians {…}

role Angle does Measure {
    method Degrees  ( --> Degrees  ) {…}
    method Radians  ( --> Radians  ) {…}
    method Gradians ( --> Gradians ) {…}
}

class Degrees does Angle {
    method value() {
        Proxy.new:
            FETCH => -> $ { $!value },
            STORE => -> $, $x {
                $!value = $x % 360;
            }
    }
    method Degrees  () { self }
    method Radians  () { !!! } # needs to actually be implemented here
    method Gradians () { !!! }
}
class Radians does Angle {
    method value() {
        Proxy.new:
            FETCH => -> $ { $!value },
            STORE => -> $, $x {
                $!value = $x % ?;
            }
    }
    method Degrees  () { !!! }
    method Radians  () { self }
    method Gradians () { !!! }
}
class Gradians does Angle {
    method value() {
        Proxy.new:
            FETCH => -> $ { $!value },
            STORE => -> $, $x {
                $!value = $x % 400;
            }
    }
    method Degrees  () { !!! }
    method Radians  () { !!! }
    method Gradians () { self }
}

老实说，我也不喜欢那样，因为您将值视为容器。

基本上你是这样工作的，你不能有一个恒定的角度。

 class Foo {
     has Angle $.bar;
 }

 my $foo = Foo.new( bar => Degrees.new( value => 27 ) );
 $foo.bar.angle = 43;

我认为您应该要求它像这样工作，您可以选择角度是否恒定。

 class Foo {
     has Angle $.bar is rw;
 }

 my $foo = Foo.new( bar => Degrees.new( value => 27 ) );
 $foo.bar .= new( value => 43 );

这样做可以使您可以直接删除value所有子类中的方法，并将它们替换为简单的TWEAK. （无论如何，这是您真正需要的东西。）
当然，您还需要is rw从$.value.

我会这样做，以便您可以.new只使用一个值而不是value => 27.

role Measure {
    has Real $.value;

    multi method new ( $value ) {
        samewith( :$value )
    }
}

role Angle {…}

class Degrees  {…}
class Radians  {…}
class Gradians {…}

role Angle does Measure {
    method Degrees  ( --> Degrees  ) {…}
    method Radians  ( --> Radians  ) {…}
    method Gradians ( --> Gradians ) {…}
}

class Degrees does Angle {
    submethod TWEAK { $!value %= 360 }
    method Degrees  () { self }
    method Radians  () { !!! } # needs to actually be implemented here
    method Gradians () { !!! }
}
class Radians does Angle {
    submethod TWEAK { $!value %= ? }
    method Degrees  () { !!! }
    method Radians  () { self }
    method Gradians () { !!! }
}
class Gradians does Angle {
    submethod TWEAK { $!value %= 400 }
    method Degrees  () { !!! }
    method Radians  () { !!! }
    method Gradians () { self }
}

 class Foo {
     has Angle $.bar is rw;
 }

 my $foo = Foo.new( bar => Degrees.new( 27 ) );
 $foo.bar = Degrees.new( 43 );

关于上一个版本，我希望您注意一些事情。
那里[几乎]没有代码。
它主要是声明性代码，当它出错时往往更引人注目。

（您需要用 填写这些部分!!!，但那里不应该有太多代码。）

无论如何，我的观点是，是的，您可以[使用Proxy]来做到这一点，但这是更困难的原因。
你是从一个在某种程度上违背 Raku 设计理念的方向来看待这个问题的。