Klassen-Attribute nur für einen Methodenaufruf überschreiben (Raku / Perl 6)

[thread]19949[/thread]

Klassen-Attribute nur für einen Methodenaufruf überschreiben

Tags: perl6 OOP Ähnliche Threads

Leser: 11

Articles: hide open all | hide show old branches

+7 replies

Kuerbis

2016-01-11 09:44

User since
2011-03-20
948 Artikel
BenutzerIn
[default_avatar]

Hallo!

Die Methode choose sollte die mit new gesetzten Attribute für ihren Aufruf überschreiben können, ohne diese global zu verändern.
Ist diese Art der Umsetzung OK?

Code (perl): (dl )

#!/usr/bin/env perl6
use v6;

class Term::Choose {
    has Str $.prompt = 'Your Choice';
    has Int @.mark;
    has     %!backup_opt;
    # ...

    method choose ( Array $orig_list, %opt? ) {
        for %opt.keys -> $key {
            when $key eq 'prompt' {
                %!backup_opt{$key} = $!prompt;
                $!prompt = %opt{$key};
            }
            when $key eq 'mark' {
                %!backup_opt{$key} = [ @!mark ];
                @!mark = |%opt{$key};
            }

        }
        say "prompt: $!prompt";
        say "mark  : @!mark[]\n";
        self!rest_attributes();

    }

    method !rest_attributes {
        for %!backup_opt.keys -> $key {
            when $key eq 'prompt' { $!prompt = %!backup_opt{$key} }
            when $key eq 'mark'   { @!mark   = |%!backup_opt{$key} }
        }
    }
}

my $n = Term::Choose.new( prompt => 'AAAAA', mark => [ 5, 6 ] );
$n.choose( [ 1 .. 10 ] );
$n.choose( [ 1 .. 10 ], { prompt => 'BBBBB', mark => [ 1 .. 4 ] } );
$n.choose( [ 1 .. 10 ] );

+5 replies
betterworld

2016-01-11 18:00

User since
2003-08-21
2614 Artikel
ModeratorIn

Wo genau ist da jetzt eigentlich der Unterschied zu deiner Frage von neulich?

Jedenfalls würden die Antworten vom letzten Mal fast alle immer noch zutreffen.
Last edited: 2016-01-11 18:02:12 +0100 (CET)
Lieblingsmodule: IPC::System::Simple, Path::Class
- +4 replies
- Kuerbis
  
  2016-01-12 08:50
  User since
  2011-03-20
  948 Artikel
  BenutzerIn
  Hier geht es darum, dass die an die Methode choose übergebenen Optionen nur für den einen Aufruf gültig sind, aber nicht die mit new gesetzten Attribute global überschreiben.
  
  Eine Alternative zu meinem obigen Beispiel - hier müsste ich aber die übergebenen Optionen von Hand validieren:
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
  
  #!/usr/bin/env perl6 use v6; class Term::Choose { has Str $.prompt = 'Your Choice'; has Int @.mark; has %!opt; method choose ( Array $orig_list, %!opt? ) { %!opt<prompt> //= $.prompt; say "prompt: %!opt<prompt>" with %!opt<prompt>; %!opt<mark> //= [ @.mark ]; say "mark : %!opt<mark>[]\n" with %!opt<mark>; } } my $n = Term::Choose.new( prompt => 'AAAAA', mark => [ 5, 6 ] ); $n.choose( [ 1 .. 10 ] ); $n.choose( [ 1 .. 10 ], { prompt => 'BBBBB', mark => [ 1 .. 4 ] } ); $n.choose( [ 1 .. 10 ] );
  - betterworld
    
    2016-01-12 09:38
    
    User since
    2003-08-21
    2614 Artikel
    ModeratorIn
    
    Ok, also das mit den backup-Optionen würde ich auf keinen Fall so machen. Dass da der State des Objekts immer hin- und hergeschaufelt wird, wirkt fürchterlich unschön. Allein schon, dass Du die Attribute Deines Objekts "global" nennst...
    
    Stattdessen würde ich eine Methode machen, die ein neues Objekt erzeugt, welches genau dieselben Attribute hat, bis auf die, die geändert werden sollen. Dann hast du ein unverändertes altes Objekt und ein neues.
    Das kannst du vielleicht sehr schnell zusammen bauen mit Benutzung von clone: http://doc.perl6.org/routine/clone
    Last edited: 2016-01-12 09:52:26 +0100 (CET)
    Lieblingsmodule: IPC::System::Simple, Path::Class
  - Muffi
    
    2016-01-12 09:56
    
    User since
    2012-07-18
    1465 Artikel
    BenutzerIn
    
    Soweit ich des Perl6 lesens mächtig bin:
    
    Ich würd da nicht irgendwelche Sachen im Objekt hin und herschalten.
    
    Also wenn dein Choose Optionen braucht, dann gib ihm die doch einfach.
    Dein Hauptobjekt speichert nur Defaultoptionen, dem Choose werden konkrete Optionen übergeben. Die Optionen, die dann benutzt werden sind ein Merge/Zusammenführen aus den Default- und konkreten Optionen. Also in der Methode nicht direkt auf die Defaultoptionen zugreifen.
    
    edit: Wenn du das dann noch default_<opt> oder so nennst sieht man sogar beim Code lesen recht schön, dass es wohl eine gute Chance gibt, dass die irgendwo überschrieben werden.
    Last edited: 2016-01-12 10:03:34 +0100 (CET)
    1 + 1 = 10
  - Kuerbis
    
    2016-01-13 13:13
    
    User since
    2011-03-20
    948 Artikel
    BenutzerIn
    
    Danke, werde mir die Vorschläge später noch einmal durchlesen, jetzt nach dem Essen kann ich nicht mehr denken.

Kuerbis

2016-01-13 13:09

User since
2011-03-20
948 Artikel
BenutzerIn
[default_avatar]

Vielleicht werde ich es so machen:

Code (perl): (dl )

#!/usr/bin/env perl6
use v6;

class Term::Choose {
    has %.opt_global;
    has %!opt;

    method new ( %opt_global? ) {
        validate_options( %opt_global );
        %opt_global<prompt>  //= 'AAAAA';
        %opt_global<justify> //= 1;
        self.bless( :%opt_global );
    }

    sub valid_options {
        return {
            justify => '<[ 0 1 2 ]>',
            lf      => 'Array',
            mark    => 'Array',
            prompt  => 'Str',
        };
    };

    sub validate_options ( %opt ) {
        return without %opt;
        my $valid = valid_options();
        for %opt.kv -> $key, $value {
            when $valid{$key}:!exists {
                die "'$key' is not a valid option name";
            }
            when ! defined $value {
                next;
            }
            when $valid{$key} eq 'Array' {
                die "$key => not an ARRAY reference." if ! $value.isa( Array );
                die "$key => invalid array element"   if $value !~~ /^<[0..9]>+$/; # Int;
                die "$key => too many array elemnts." if $key eq 'lf' && $value.elems > 2;
            }
            when $valid{$key} eq 'Str' {
                die "$key => not a string." if ! $value.isa( Str );
            }
            when $value !~~ m/^{$valid{$key}}$/ {
                die "$key => '$value' is not a valid value.";
            }
        }
    }

    method choose ( Array $orig_list, %!opt? ) {
        validate_options( %!opt );
        for %!opt_global.kv -> $key, $value {
            %!opt{$key} //= $value;
        }
        printf "%-7s: %s\n", .key, .value for %!opt.pairs;
        print "\n";
        # do something with $orig_list

    }
}

my $n = Term::Choose.new(  { mark => [ 4 .. 7 ] }  );
$n.choose( [ 1 .. 10 ] );
$n.choose( [ 1 .. 10 ], { prompt => 'BBBBB', mark => [ 1 .. 3 ] } );
$n.choose( [ 1 .. 10 ] );

Eventuell ist das besser, als das obige new:

Code (perl): (dl )

method new ( %opt_global? ) {
    self.bless( :%opt_global );
}

submethod BUILD( :%opt_global ) {
    %!opt_global := %opt_global;
     validate_options( %!opt_global );
     %!opt_global<prompt>  //= 'AAAAA';
     %!opt_global<justify> //= 1;
}

View all threads created 2016-01-11 09:44.