¿Head evalúa su argumento?De Uso de JSL para desarrollar aplicaciones robustas y eficientes (EU 2018 415) , aprendí que hay algunas funciones que evalúan su argumento y otras que no:
Me preguntaba acerca de Head. Aquí todo parece lógico...
f= Expr(x=2);
Substitute(NameExpr(f),Expr(x), Expr(y));
Head(f);
Head no es como Substitute, puedo usar directamente el nombre de la función como argumento y Head devuelve el encabezado de la expresión: Assign()
Después de comprobar algunas otras funciones que "no evalúan su argumento":
Expr(x=2); // x=2
Name Expr(x=2); // x=2
comprobemos el resultado para
Head(x=2)
¿Cuál es "2", es decir, el resultado después de evaluar el argumento?!?! ¿Por qué no se asigna() ?
Automatización y secuencias de comandosRe: ¿Head evalúa su argumento?
Names Default To Here(1);
{a, b, c} = {1, 2, 3};
Head(Expr(Sum(a, b, c)));
HeadExpr(Sum(a, b, c)); // Deprecated
Head(Sum(a, b, c));
https://www.jmp.com/support/help/en/17.2/#page/jmp/advanced-expressions-macros-and-lists.shtml#
Re: ¿Head evalúa su argumento?Ah, está bien, el índice de secuencias de comandos es muy claro.
Entonces, el comportamiento hoy en día es diferente al indicado en la lista. No hay ningún secreto escondido detrás de esto.
En general, podría facilitar mucho la creación de secuencias de comandos si el editor JSL usara algo de resaltado para distinguir entre los argumentos que se evalúan y los argumentos que no se evalúan antes de que se ejecute la función:
Resaltado de sintaxis avanzado en JSL Editor
Re: ¿Head evalúa su argumento?Lo mismo para Narg : el argumento se evalúa (1x, como con Name Expr()
(adaptado de la guía de secuencias de comandos)
aExpr = {a+b,c,d,e+f+g};<BR />
Show(NArg(aExpr)); //4
Show(NArg(Arg(aExpr,4))); // 3
Show(NArg(Add(1,2,3,4))); // 0
Show(NArg(Expr(Add(1,2,3,4)))); //4
Show(Head(aExpr)); //List()
Show(Head(Arg(aExpr,4))); // Add()
Show(Head(Add(1,2,3,4))); // 10
Show(Head(Expr(Add(1,2,3,4)))); //AddRe: ¿Head evalúa su argumento?este comportamiento similar a Name Expr es especialmente útil para los casos con
- Como columna(...)
- referencia de columna mediante variable ( col )
como argumento.
dt = Open("$SAMPLE_DATA/Big Class.jmp");
col = Name Expr(As Column("age"));
Head(As Column("age"));
Head(col);
dt << Recode Column(AsColumn("age"),{1},Target Column(AsColumn("age")));
dt << Recode Column(col,{1},Target Column(col));
dt << Graph Builder(Variables( X( As Column ("age") ) ),Elements( Points( X ) ));
dt << Graph Builder(Variables( X( col) ),Elements( Points( X ) ));
por otro lado: funciones que no funcionan si se ingresa una columna mediante As Column() :
dt = Open("$SAMPLE_DATA/Big Class.jmp");
col = Name Expr(As Column("age"));
Distribution(Column(As Column("age")));La solución fácil: envolver como columna con nombre Expr :
Distribution(Column(Name Expr(As Column("age")))); ... o utilice Column() en lugar de Como columna cuando corresponda:
Distribution(Column(Column("age")));
Para distinguir entre ambos casos, puedes poner un print(1); al comienzo del argumento:
dt << Graph Builder(Variables( X( Print(1);As Column ("age") ) ),Elements( Points( X ) )); // fails
Distribution(Column(Print(1);Column("age"))); // worksRe: ¿Head evalúa su argumento?
@hogi escribió:
El argumento se evalúa (1x, como con Name Expr())
Lo siento:
Al igual que con Name Expr()
Cabeza():
significa: "la expresiónArg puede ser
1) un nombre que contiene una expresión - y Head usará la expresión,
2) una expresión - y Head la evaluará y utilizará el resultado como entrada
3) o una expresión literal citada por Expr() - y Head tomará la expresión literal".
Nombre Expr():
"the expressionArg can be
1) un nombre que contiene una expresión - y Name Expr utilizará la expresión,
2) una expresión - y Name Expr tomará la expresión".
Name Expr(1+2); // 1 + 2
Head(1+2); // 3
Re: ¿Head evalúa su argumento?Otras funciones como Head()[ID=7]
- Cabeza()
- NArg()
- Argumento()
- Está vacío()
- Imprimir()
- Espectáculo()
- Escribir()
Re: ¿Head evalúa su argumento?Funciones que evalúan sus argumentos:
[ID=2]
casi todas las funciones...
La mayoría de las funciones "es...":
- ¿Es Expr()?
- ¿Es Matrix()?
- Es Lista()
- Es numero()
- ¿Es Namespace()?
- El espacio de nombres existe()
Bueno saber:
- Igual() (==)
- Analizar gramaticalmente()
- Matriz asociativa()
evaluar argumentos > 1º:
- Sustituir en()
- Insertar en()
- Quitar de()
- Asignar()
- Argumento()
Re: ¿Head evalúa su argumento?Funciones que se comportan como Name Expr() :
[ID=3]
"el expresiónArg Puede ser
1) un nombre que contiene una expresión - y Name Expr utilizará la expresión,
2) una expresión - y Name Expr tomará la expresión".
- Name Expr()
- NArg()
- Extraer Expr() [ambos argumentos] *)
*) ¡Qué genial!
x= Expr(Print(1));
Extract Expr(x, x) // Print(1)
Re: ¿Head evalúa su argumento?Otras funciones como Head()
[ID=7]
"el expresiónArg Puede ser
1) un nombre que contiene una expresión - y Head usará la expresión,
2) una expresión - y el Jefe evaluará y utilizará el resultado como entrada
3) o una expresión literal citada por Expr() - y Head tomará la expresión literal".
- Cabeza()
- NArg()
- Argumento()
- Está vacío()
- Imprimir()
- Espectáculo()
- Escribir()
Re: ¿Head evalúa su argumento?#Inspector de expresiones
Re: ¿Cabeza evalúa su argumento?Otra pregunta:
¿Por qué Type evalúa su argumento?
Type(Char(1)) // String !!
