时间戳

首页 > 解决方案 > raku 内置访问器方法可以被子类覆盖吗？

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

问题描述

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

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, *%_)

您的指导将非常有帮助！

标签： oopraku

解决方案

当您使用 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不是像is 这样的左值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 );

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

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

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

推荐阅读