Stranezza di JMP Expr(), qualcuno può spiegare?Questo è principalmente solo un post di frustrazione per la seguente incoerenza con l'inserimento delle espressioni "IF" in un'espressione "IF".Mi risulta che i linguaggi di programmazione non dovrebbero essere altro che coerenti (e sono a conoscenza di molte altre incoerenze di JMP: è solo che questa non ha alcun senso per me).
/*
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) )
*/
Se qualcuno ha qualche intuizione, o soprattutto se conosci un modo per inserire in modo affidabile qualsiasi espressione in qualsiasi altra espressione (non utilizzando "Eval Insert" o stringhe), sarebbe fantastico!Grazie!
Modellazione statistica avanzataRi: Stranezza di JMP Expr(), qualcuno può spiegare?esiste una soluzione alternativa per eseguire l'attività richiesta, ma la domanda reale: PERCHÉ?!? non è ancora stata data risposta.
aggiunto a Piccole trappole in Jmp e JSL
Ri: Stranezza di JMP Expr(), qualcuno può spiegare?Ulteriori esempi che smentiscono facilmente alcune ipotesi e aggiungono ulteriori approfondimenti:
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) (!!)
Ri: Stranezza di JMP Expr(), qualcuno può spiegare?Ciao,
Anche se non ne sono sicuro, mi chiedo se questo comportamento sia dovuto al fatto che lo snippet "IF (a)" non è un'espressione JSL ben formata. Cioè, la funzione SE accetta 2 argomenti, non uno. JMP non ha modo di sapere se "notAnIf( a )" è un'espressione ben formata, quindi forse alza le spalle e procede ( ? ) Ipotesi totale da parte mia.
Il fatto che quanto segue funzioni come intendi sembra aggiungere un po' di supporto a questa idea, ma questo non spiega il perché @ben_ph funziona, poiché inserisce con successo REPLACE_ME dove manca un file.
expr = Expr( If( a, . ) );
Substitute Into( expr, expr(.), expr( If( b, c ) ) );
Show( Name Expr( expr ) );
Saluti,
Brady
Ri: Stranezza di JMP Expr(), qualcuno può spiegare?Come soluzione alternativa senza utilizzare le stringhe potresti fare qualcosa di simile
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 ) )
Ri: Stranezza di JMP Expr(), qualcuno può spiegare?Questo è strettamente correlato a lo stesso di Come inserire una lista in un'altra lista . Con la tua domanda, ora sospetto che esista un'eccezione speciale per i nomi delle funzioni integrate che mostra questo comportamento.
expr = Expr( not an If( a ) );
equivale a
expr = Expr( NotAnIf( a ) );
facendo in modo che NotAnIf (o non un if) sia un nome di funzione che JMP non riconosce come incorporato. Nell'esempio { list }, {...} è uguale a List(...) e È un nome di funzione incorporata.
espressione = Espr( somma( a ) );
Inserisci in( espressione, Espr( somma( b, c ) ) );
Mostra (Nome Espr (espr));
/*:
Nome Espr(espr) = Somma(a, b, c);
//:*/
espressione = Espr( somma1( a ) );
Inserisci in (espr, Espr( somma1( b, c ) ) );
Mostra (Nome Espr (espr));
/*:
Nome Espr(espr) = somma1(a, somma1(b, c));
Non piace neanche a me.
@XanGregg
Ri: Stranezza di JMP Expr(), qualcuno può spiegare?Anche la coerenza da una versione all'altra è importante. Ogni lingua presenta alcuni difetti di progettazione che vengono rilevati all'inizio. Qualcuno (in genere uno sviluppatore e uno specialista del supporto tecnico o un tecnico delle vendite) decide se
LongTerm GainFromFixing - CostsOfFixing > CostOfDoingNothing
CostsOfFixing è davvero complicato, tempo di sviluppo + tempo di test + tempo di documentazione + tempo di supporto tecnico a breve termine + irritazione del cliente per il fatto che JSL che funzionava prima ora fallisce + opportunità mancate + il rischio di peggiorare le cose.
Anche CostOfDoingNothing è complicato: quanto supporto tecnico è necessario, per sempre nel futuro, numero di utenti che affronteranno il problema e quanto è difficile comprenderlo e risolverlo. Altre supposizioni.
Questo forum, il forum della lista dei desideri, il rappresentante JMP e le riunioni dei gruppi di utenti contribuiscono tutti a orientare tale decisione. Grazie @hogi per aver aiutato a guidare!
@giuliano
Ri: Stranezza di JMP Expr(), qualcuno può spiegare?Questo è un problema interessante.Potresti creare la tua funzione per eseguire l'inserimento in cui funziona come previsto [penso], per tutti i casi tranne l'ultimo da @hogi .In quel caso, tuttavia, la funzione restituisce lo stesso risultato di quando l'espressione viene chiamata utilizzando direttamente Name Expr, quindi si potrebbe sostenere che questo è il risultato "corretto".
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))
Ecco la stessa funzione senza il materiale di debug:
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 );
) );
Ri: Stranezza di JMP Expr(), qualcuno può spiegare?Ciò risolve il problema con 2 volte lo stesso tipo di espressione. SÌ.
Ma temo che non sia un sostituto così universale per Inserire come si potrebbe desiderare.
Show( New Insert Into( Expr( If( a )), Expr( List( b,c )) ) ); // If(a,b,c)
Ri: Stranezza di JMP Expr(), qualcuno può spiegare?Tuttavia, la mia intenzione principale qui:
Capire PERCHÉ Inserire appiattisce la struttura, in modo tale che ogni volta che utilizzerò la funzione in futuro, potrò essere sicuro e fiducioso che farà la cosa giusta.
Per 2 elenchi, sembra una funzione utile: genera automaticamente un elenco appiattito.
Uhm, utile quanto la regolazione automatica dell'intervallo nel Costruttore di grafici, ovvero: nel 93% dei casi sarà utile, negli altri casi...
Mappa termica - opzione: spaziatura Tick fissa (area di aggregazione)
Dietro c'è qualcosa di più del semplice tentativo di essere "di aiuto"?
Una novità per me è che non si tratta solo di cercare di essere utile con l'elenco...
Per quanto riguarda le "soluzioni" per Inserire con il caso speciale di 2x lo stesso tipo di espressione:
- Forse c'è un'opzione nascosta: non appiattire(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 );
è meraviglioso 
NB:
@ih ha scritto:
... solo la prima istanza dovrebbe essere sostituita..
Ho avuto un problema simile qualche giorno fa e mi è venuta l'idea: Indicizzazione delle espressioni: accesso in lettura e scrittura.
Potrebbe portare la gestione delle espressioni in Jmp/JSL a un nuovo livello. Se lo trovi utile potresti votarlo...
[Ho aggiunto un commento con un collegamento a questo post.]
Ri: Stranezza di JMP Expr(), qualcuno può spiegare?
@hogi ha scritto:
Per quanto riguarda le "soluzioni" per Insert Into con il caso speciale di 2x lo stesso tipo di espressione:
- Forse c'è un'opzione nascosta: flatten(0|1) ?
Non sembra così...
Ecco il desiderio di ottenere tale opzione: Insert Into: Flatten(0|1)
