Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?Il s'agit principalement d'un message de frustration concernant l'incohérence suivante concernant l'insertion d'expressions « IF » dans une expression « IF ».Je crois comprendre que les langages de programmation ne devraient être que cohérents (et je suis conscient de nombreuses autres incohérences de JMP - c'est juste que celle-ci n'a aucun sens pour moi).
/*
What I want is to generate an expression such as the one below programmatically. There of course is a straight-forward work around, I just don't like dealing with special cases especially when they make no sense.
Expr( If( a, If( b, c) ) )<BR />
*/
expr = Expr( If( a ) );
Insert Into( expr, Expr( If( b, c ) ) );
Show( Name Expr( expr ) );
/*
If( a, b, c)
*/
expr = Expr( not an If( a ) );
Insert Into( expr, Expr( If( b, c ) ) );
Show( Name Expr( expr ) );
/*
not an If( a, If( b, c) )
*/
Si quelqu'un a des idées, ou surtout si vous connaissez un moyen d'insérer de manière fiable n'importe quelle expression dans n'importe quelle autre expression (sans utiliser « Eval Insert » ou des chaînes), ce serait génial !Merci!
Modélisation statistique avancéeRe : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?il existe une solution de contournement pour accomplir la tâche demandée - mais la vraie question : POURQUOI?!? n'a pas encore de réponse.
ajouté à Petits pièges dans Jmp et JSL
Re : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?Autres exemples qui réfutent facilement certaines hypothèses - et ajoutent quelques informations supplémentaires :
expr = Expr( If( a, x ) );
Insert Into( expr, Expr(If( b,c )) );
Show( Name Expr( expr ) ); // if(a,x,b,c)
expr = Expr( If( a ) );
Insert Into( expr, Expr(If( b )) );
Show( Name Expr( expr ) ); // if(a,b)
expr = Expr( List( a ) );
Insert Into( expr, Expr(List( b )) );
Show( Name Expr( expr ) ); // List(a,b)
expr = Expr( Graph Builder( a ) );
Insert Into( expr, Expr(Graph Builder ( b )) );
Show( Name Expr( expr ) ); // Graph Builder(a,b)
expr = Expr( Head( a ) );
Insert Into( expr, Expr(Head( b )) );
Show( Name Expr( expr ) ); // Head(a,b) (!)
expr = Expr( Not( a ) );
Insert Into( expr, Expr(Not( b )) );
Show( Name Expr( expr ) ); // Not(a) (!!)
Re : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?Bonjour,
Bien que je ne sois pas sûr, je me demande si ce comportement est dû au fait que l'extrait "IF ( a )" n'est pas une expression JSL bien formée. Autrement dit, la fonction IF prend 2 arguments, pas un. JMP n'a aucun moyen de savoir si "notAnIf( a )" est une expression bien formée, alors peut-être hausse les épaules et continue ( ? ) Supposition totale de ma part.
Le fait que ce qui suit fonctionne comme vous le souhaitez semble ajouter un certain soutien à cette idée, mais cela n'explique pas pourquoi @ben_ph L'idée de fonctionne, car elle insère avec succès REPLACE_ME là où j'ai un élément manquant.
expr = Expr( If( a, . ) );
Substitute Into( expr, expr(.), expr( If( b, c ) ) );
Show( Name Expr( expr ) );
Acclamations,
Brady
Re : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?Pour contourner le problème sans utiliser de chaînes, vous pouvez faire quelque chose comme
expr = Expr( If( a ) );
Insert Into( expr, Expr( REPLACE_ME ) );
Substitute Into( expr, Expr( REPLACE_ME ), Expr( If( b, c ) ) );
Name Expr( expr );
// If( a, If( b, c ) )
Re : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?C'est étroitement liée à le même que Comment insérer une liste dans une autre liste . Avec votre question, je soupçonne maintenant qu'il existe une exception spéciale pour les noms de fonctions intégrées qui montre ce comportement.
expr = Expr( not an If( a ) );
est le même que
expr = Expr( NotAnIf( a ) );
faire de NotAnIf (ou pas un if) un nom de fonction que JMP ne reconnaît pas comme intégré. Dans l'exemple { list }, {...} est identique à List(...) et est un nom de fonction intégré.
expr = Expr( somme( a ) );
Insérer dans( expr, Expr( sum( b, c ) ) );
Afficher( Nom Expr( expr ) );
/* :
Nom Expr(expr) = Somme(a, b, c);
//:*/
expr = Expr( somme1( a ) );
Insérer dans( expr, Expr( sum1( b, c ) ) );
Afficher( Nom Expr( expr ) );
/* :
Nom Expr(expr) = sum1(a, sum1(b, c));
Je n'aime pas ça non plus.
@XanGregg
Re : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?La cohérence d’une version à l’autre est également importante. Chaque langage présente des défauts de conception qui sont détectés dès le début. Quelqu'un (généralement un développeur et un spécialiste du support technique ou un ingénieur commercial) décide si
LongTermGainFromFixing - CostsOfFixing > CostOfDoingNothing
CostsOfFixing est vraiment compliqué, temps de développement + temps de test + temps de documentation + temps de support technique à court terme + irritation des clients face à l'échec de JSL qui fonctionnait auparavant + opportunités manquées + risque d'aggraver la situation.
CostOfDoingNothing est également compliqué : quelle quantité de support technique est nécessaire, pour toujours dans le futur, nombre d'utilisateurs qui seront un jour confrontés au problème et à quel point est-il difficile à comprendre et à contourner. Plus de conjectures.
Ce forum, le forum des listes de souhaits, votre représentant JMP et les réunions du groupe d'utilisateurs contribuent tous à orienter cette décision. Merci @hogi pour avoir aidé à diriger !
@julien
Re : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?C'est un problème intéressant.Vous pouvez créer votre propre fonction pour effectuer l'insertion dans laquelle fonctionne comme prévu [je pense], dans tous les cas sauf le dernier de @hogi .Dans ce cas, bien que la fonction renvoie le même résultat que lorsque cette expression est appelée directement en utilisant Name Expr, on pourrait donc affirmer qu'il s'agit du résultat « correct ».
Names default to here(1);
// Make a new function to show each step of Insert Into:
New Insert Into = function( {exp, newarg, debug = 0 }, local({hd, ar, ne},
//Get the outermost function
hd = Head(exp);
if(debug, show(name expr( hd ) ) );
//Replace that function with a list so insert into works as expected
ar = substitute(name expr( exp ), name expr( hd ), {});
if(debug, show(name expr( ar ) ) );
//Now add the new argument
Insert Into( ar, name expr( newarg ) );
if(debug, show(name expr( ar ) ) );
//and put the orignial function back
ne = substitute(name expr( ar ), {}, name expr( hd ));
if(debug, show(name expr( ne ) ) );
Name expr( ne );
) );
// Test with the examples in the original post, note that they match:
Show( New Insert Into( Expr( If( a ) ), Expr( If( b, c ) ) ) ); // If(a, If(b, c))
Show( New Insert Into( Expr( Not an If( a ) ), Expr( If( b, c ) ) ) ); // Not an If(a, If(b, c))
// Additional examples from hogi post
Show( New Insert Into( Expr( If( a, x ) ), Expr( If( b, c ) ) ) ); // If(a, x, If(b, c))
Show( New Insert Into( Expr( If( a ) ), Expr( If( b ) ) ) ); // If(a, If
Show( New Insert Into( Expr( List( a ) ), Expr( List( b ) ) ) ); // List(a, b)
Show( New Insert Into( Expr( Graph Builder( a ) ), Expr( Graph Builder( b ) ) ) ); // Graph Builder(a, Graph Builder(b))
Show( New Insert Into( Expr( Head( a ) ), Expr( Head( b ) ) ) ); // Head(a, Head(b))
Show( New Insert Into( Expr( Not( a ) ), Expr( Not( b ) ) ) ); // !a
// The last one doesn't seem right but that it is actually being 'fixed' after as it is created:
Show( New Insert Into( Expr( Not( a ) ), Expr( Not( b ) ), debug = 1 ) ); // !a
// This is the same result as if you just call that directly, so I think this is the 'correct' result
Name Expr( Not(a, !b) ); // !a
// This function replaces all the Head expressions, which I think is okay, note this line:
// Name Expr(ar) = {a, {b, c}}
Show( New Insert Into( Expr( If( a, If( b, c ) ) ), Expr( If( d, e ) ), 1 ) ); // If(a, If(b, c), If(d, e))
Voici la même fonction sans les éléments de débogage :
New Insert Into = function( {exp, newarg }, local({hd, ar, ne},
hd = Head(exp);
ar = substitute(name expr( exp ), name expr( hd ), {});
Insert Into( ar, name expr( newarg ) );
ne = substitute(name expr( ar ), {}, name expr( hd ));
name expr( ne );
) );
Re : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?Cela résout le problème avec 2x le même type d'expression. Oui.
Mais je crains que ce ne soit pas un substitut aussi universel à Insérer dans comme on pourrait le souhaiter.
Show( New Insert Into( Expr( If( a )), Expr( List( b,c )) ) ); // If(a,b,c)
Re : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?Néanmoins, mon intention principale ici :
Comprendre POURQUOI Insérer dans aplatit la structure - de telle sorte que chaque fois que j'utiliserai la fonction à l'avenir, je peux être sûr et confiant qu'elle fera la bonne chose.
Pour 2 listes, cela ressemble à une fonction utile : elle génère automatiquement une liste aplatie.
Hm, aussi utile que l'ajustement automatique de la plage dans Graph Builder - c'est-à-dire : pour 93 % des cas, cela aidera, pour les autres cas...
Heatmap - option : espacement fixe des ticks (zone d'agrégation)
Y a-t-il autre chose derrière cela que d’essayer d’être « utile » ?
Ce qui est nouveau pour moi, c'est qu'il ne s'agit pas seulement d'essayer d'être utile avec la liste...
Concernant les « solutions » pour Insérer dans avec le cas particulier de 2x le même type d'expression :
- Il y a peut-être une option cachée : ne pas aplatir(0|1) ?
expr = Expr( If( a ) );
Insert Into( expr, Expr( REPLACE_ME ) );
Substitute Into( expr, Expr( REPLACE_ME ), Expr( If( b, c ) ) );
Name Expr( expr );
est merveilleux 
Attention :
@ih a écrit:
... seule la première instance doit être remplacée.
J'ai eu un problème similaire il y a quelques jours et j'ai eu l'idée : Indexation d'expression : accès en lecture et en écriture.
Cela pourrait amener la gestion des expressions dans Jmp/JSL à un nouveau niveau. Si vous le trouvez utile, vous pourriez voter pour...
[J'ai ajouté un commentaire avec un lien vers ce post.]
Re : Bizarre de JMP Expr(), quelqu'un peut-il expliquer ?
@hogi a écrit :
Concernant les "solutions" pour Insert Into avec le cas particulier de 2x le même type d'expression :
- Peut-être y a-t-il une option cachée : flatten(0|1) ?
Il ne semble pas que ce soit le cas...
Voici le souhait d'obtenir une telle option : Insert Into : Flatten(0|1)
