801895_it-IT

liliconcom

Cosa c'è che non va? Problema di espressione in Formula()

Attenzione: JMP si bloccherà!!!

Names Default To Here( 1 );

f = Function( {}, 
/* ....  */ 
	ID = Associative Array( {{Name Expr(), 1}, {Expr(), 2}, {Function(), 3}}, 0 );<BR />/* ....  */ 
);
f();

rimuovendo function() dall'elenco si corregge l'errore.
L'errore viene risolto rimuovendo l'array associativo dalla funzione esterna.

[modifica] una motivazione per cui questo può essere utile:

come tabella di ricerca per parti di espressioni - identificate tramite Head() e Type():

myID = ID[Expr(function())]; //  expected: 3

code = Expr(g = function ({x},1));
Head(Arg(code,2)); // function()
myID = ID[Head(Arg(code,2))]; // expected: 3

Automazione e scriptingR: Cosa c'è che non va?

Di sicuro fa impazzire JMP. Hai appena inventato un nuovo modo veloce per uscire da una sessione JMP......

Questo deve andare al supporto JMP! Cose del genere non dovrebbero accadere.

R: Cosa c'è che non va?

Ne ho un altro:

Attenzione: JMP si bloccherà!!!

x = Expr(Function());

Show(name Expr(x) == Expr(Function()));
Print("not dead");

f = function({arg},
name Expr(arg) == Expr(Function()))

al di fuori della funzione il confronto di x con Function() è OK.

All'interno della funzione, JMP si bloccherà automaticamente quando vedrà il comando, senza bisogno di chiamare f .

R: Cosa c'è che non va?

dal supporto JMP (TS-00166834):


Esiste un problema noto per cui JMP si blocca quando si utilizza una funzione non valida in un'altra funzione.

Quindi, la causa principale può essere ridotta a
Attenzione: JMP si bloccherà!!!

f = Function( {}, 	Expr(Function()));

... con un'aria così innocente.

definizione di funzione malformata - sì. Ma è un'espressione JSL "ben formata" secondo

@joseph_morgan / Utilizzo di JSL per sviluppare applicazioni efficienti e robuste (EU 2018 415) .

Quindi è sorprendente che JMP non possa conviverci.

Una funzione dentro una funzione mi ricorda la stranezza di JMP Expr(), qualcuno può spiegarlo? / @ErraticAttack .
Quindi, oltre agli utenti, anche JMP ha problemi quando un'espressione viene visualizzata su livelli diversi. Quindi, forse Inserisci in: Appiattisci(0|1) o @Substitute First Occurence potrebbero essere d'aiuto a JMP?

I suggerimenti del supporto JMP:
Ci sono un paio di altre cose che puoi fare per evitare il crash. Una è inserire le parentesi graffe ({}) come argomento obbligatorio nella funzione interna. Un'altra è rimuovere le parentesi dopo la parola "Function" nella funzione interna.

purtroppo non c'è aiuto per il caso applicativo di cui sopra.

R: Cosa c'è che non va?

Una soluzione alternativa:

f = Function( {}, 
/* ....  */ 
	ID = Associative Array( {{"Name Expr()", 1}, {"Expr()", 2}, {"Function()", 3}}, 0 );
/* ....  */ 
);
f();
code = Expr(g = function ({x},1));
myID=ID[Char(Head(Arg(code,2)))]

ma "fa un po' male"...

R: Cosa c'è che non va?

Questo mi piace molto di più:

f = Function( {}, 
/* ....  */ 
	Eval (Eval Expr(ID = Associative Array( {{Name Expr(), 1}, {Expr(Parse("Expr()")), 2}, {Expr(Parse("Function()")), 3}}, 0 )));
/* ....  */ 
);
f;
code = Expr(g = function ({x},1));
myID=ID[Head(Arg(code,2))];

Non può funzionare, dopo l' eval expr sarà più o meno uguale a prima...
... Oh!

NB: Expr() non sopravviverà a Eval Expr , quindi deve essere protetto.

R: Cosa c'è che non va?

-

Re: Cosa c'è che non va? Problema di espressione in Formula()

In realtà ho appena inviato questo bug report qualche giorno fa! Ho scoperto che usare Expr(Function()) all'interno di una funzione causa un crash. Lo stavo usando nel contesto di

Substitute(my_expr, Expr(Function()), Expr(Method()))

Ma sono riuscito a cavarmela usando Expr(Function).

Per il tuo problema, un'altra possibile soluzione se non vuoi analizzare le stringhe è fare qualcosa del genere

y = Function({head_key},
	ID = Associative Array( EvalList({{Name Expr(), 1}, {Expr(), 2}, EvalList({Head(Expr(Function({},1))), 3})}), 0 );
    ID[NameExpr(head_key)]
);
Show(y(Expr(Function())));

Anche se non è ancora esattamente "bello".

Re: Cosa c'è che non va? Problema di espressione in Formula()

Head(Expr(Function()))

Carino!
molto meglio del mio Eval( ... Parse( ... soprattutto dopo aver citato Joseph's