Voilà, c'est une réflexion à deux balles : J'ai un programme avec
de nombreuses fonctions, qui elles-même prennent de nombreux paramètres.
Cependant beaucoup de ces paramètres sont toujours les mêmes.
Pour éviter de passer ces paramètres systématiquement et d'alourdir mes
appels de fonctions, je mets ces données dans des variables globales...
C'est pas propre et puis ça ne fonctionnera pas si je mets mes
fonctions dans des modules ... Comment faire autrement? Peut-être est-il
possible de passer des paramètres de façon implicite?
Je dois dire que je ne comprends pas du tout ce que tu veux démontrer l à :-( Tu peux expliquer?
l'idée est d'avoir une sub avec des arguments déjà défini pour év iter de surcharger la pile ? je t'ai donc donné un exemple de fermeture par la création d'une fonction anonyme.
donc la fonction &a prend 3 arguments dans mon exemple et retourne une fonction anonyme stocké ici dans $b. après tu appelles la fonction anonyme dans $b comme tu veux, cette fonction pourra accéder aux premiers arguments.
j'admets que mon exemple était pas du genre très explicite.
par rapport à ton problème de passage de variable, soit une approche objet est envisageable, soit tu t'arrange pour avoir des fermetures.
.s'nuoM
/! /! /! /! /! /! /! /! je ne sais pas si ce qui suit est utile ... /! /! /! /! ... c plus pour le fun d'ailleurs :) /! /! /! /!
une idée d'intermédiaire ( un melange de fermeture et de pseudo objet ) pourrait être :
use strict; our( $AUTOLOAD, $hash1, $hash2 );
sub AUTOLOAD { my $a = shift; $AUTOLOAD =~ s/[^:]+:://g; goto &{$a->{$AUTOLOAD}} if $a->{$AUTOLOAD}; print "$AUTOLOAD indefinin"; }
sub hash_de_fonctions { my @common_args = @_; return { toto => sub { my @args = @_; print join( " + ", "toto", @common_args, @args, "n" ); }, tata => sub { my @args = @_; print join( " + ", "tata", reverse( @common_args ), @args, "n" ); } }; }
Je dois dire que je ne comprends pas du tout ce que tu veux démontrer l à
:-( Tu peux expliquer?
l'idée est d'avoir une sub avec des arguments déjà défini pour év iter de
surcharger la pile ? je t'ai donc donné un exemple de fermeture par la
création d'une fonction anonyme.
donc la fonction &a prend 3 arguments dans mon exemple et retourne une
fonction anonyme stocké ici dans $b. après tu appelles la fonction
anonyme dans $b comme tu veux, cette fonction pourra accéder aux
premiers arguments.
j'admets que mon exemple était pas du genre très explicite.
par rapport à ton problème de passage de variable, soit une approche
objet est envisageable, soit tu t'arrange pour avoir des fermetures.
.s'nuoM
/! /! /! /!
/! /! /! /! je ne sais pas si ce qui suit est utile ...
/! /! /! /! ... c plus pour le fun d'ailleurs :)
/! /! /! /!
une idée d'intermédiaire ( un melange de fermeture et de pseudo objet )
pourrait être :
use strict;
our( $AUTOLOAD, $hash1, $hash2 );
sub AUTOLOAD {
my $a = shift;
$AUTOLOAD =~ s/[^:]+:://g;
goto &{$a->{$AUTOLOAD}} if $a->{$AUTOLOAD};
print "$AUTOLOAD indefinin";
}
sub hash_de_fonctions {
my @common_args = @_;
return {
toto => sub {
my @args = @_;
print join( " + ", "toto", @common_args, @args, "n" );
},
tata => sub {
my @args = @_;
print join( " + ", "tata", reverse( @common_args ), @args, "n" );
}
};
}
Je dois dire que je ne comprends pas du tout ce que tu veux démontrer l à :-( Tu peux expliquer?
l'idée est d'avoir une sub avec des arguments déjà défini pour év iter de surcharger la pile ? je t'ai donc donné un exemple de fermeture par la création d'une fonction anonyme.
donc la fonction &a prend 3 arguments dans mon exemple et retourne une fonction anonyme stocké ici dans $b. après tu appelles la fonction anonyme dans $b comme tu veux, cette fonction pourra accéder aux premiers arguments.
j'admets que mon exemple était pas du genre très explicite.
par rapport à ton problème de passage de variable, soit une approche objet est envisageable, soit tu t'arrange pour avoir des fermetures.
.s'nuoM
/! /! /! /! /! /! /! /! je ne sais pas si ce qui suit est utile ... /! /! /! /! ... c plus pour le fun d'ailleurs :) /! /! /! /!
une idée d'intermédiaire ( un melange de fermeture et de pseudo objet ) pourrait être :
use strict; our( $AUTOLOAD, $hash1, $hash2 );
sub AUTOLOAD { my $a = shift; $AUTOLOAD =~ s/[^:]+:://g; goto &{$a->{$AUTOLOAD}} if $a->{$AUTOLOAD}; print "$AUTOLOAD indefinin"; }
sub hash_de_fonctions { my @common_args = @_; return { toto => sub { my @args = @_; print join( " + ", "toto", @common_args, @args, "n" ); }, tata => sub { my @args = @_; print join( " + ", "tata", reverse( @common_args ), @args, "n" ); } }; }
l'avantage d'un truc comme ca est visible pour une migration d'un modèle procedural vers un modèle objet ou pour une restructuration de code.
Emmanuel Florac
Le Tue, 19 Oct 2004 04:13:17 +0200, Samuel Mouniee a écrit :
l'idée est d'avoir une sub avec des arguments déjà défini pour éviter de surcharger la pile ? je t'ai donc donné un exemple de fermeture par la création d'une fonction anonyme.
donc la fonction &a prend 3 arguments dans mon exemple et retourne une fonction anonyme stocké ici dans $b. après tu appelles la fonction anonyme dans $b comme tu veux, cette fonction pourra accéder aux premiers arguments.
A y est, j'ai compris :)
-- Si ça a l'air facile, c'est difficile. Si ça a l'air difficile, c'est carrément impossible. Si ça a l'air impossible, c'est un compilateur Ada. Théorème de Stockmayer.
Le Tue, 19 Oct 2004 04:13:17 +0200, Samuel Mouniee a écrit :
l'idée est d'avoir une sub avec des arguments déjà défini pour éviter de
surcharger la pile ? je t'ai donc donné un exemple de fermeture par la
création d'une fonction anonyme.
donc la fonction &a prend 3 arguments dans mon exemple et retourne une
fonction anonyme stocké ici dans $b. après tu appelles la fonction
anonyme dans $b comme tu veux, cette fonction pourra accéder aux
premiers arguments.
A y est, j'ai compris :)
--
Si ça a l'air facile, c'est difficile. Si ça a l'air difficile, c'est
carrément impossible. Si ça a l'air impossible, c'est un compilateur
Ada.
Théorème de Stockmayer.
Le Tue, 19 Oct 2004 04:13:17 +0200, Samuel Mouniee a écrit :
l'idée est d'avoir une sub avec des arguments déjà défini pour éviter de surcharger la pile ? je t'ai donc donné un exemple de fermeture par la création d'une fonction anonyme.
donc la fonction &a prend 3 arguments dans mon exemple et retourne une fonction anonyme stocké ici dans $b. après tu appelles la fonction anonyme dans $b comme tu veux, cette fonction pourra accéder aux premiers arguments.
A y est, j'ai compris :)
-- Si ça a l'air facile, c'est difficile. Si ça a l'air difficile, c'est carrément impossible. Si ça a l'air impossible, c'est un compilateur Ada. Théorème de Stockmayer.
