Extract Expr

[#1]

I am a big fan of Eval(Substitute(Expr(...), Expr(..), Expr(.)))

: )

The only disadvantage: the Expr(...), Expr(..), Expr(.)

... which brought me to the idea of subst() - substitute() 2.0  ... a function which doesn't evaluate it's arguments.

While playing around with Expression Handling, I noticed that the desired logic for Subst() is quite close to the one of Extract Expr(): no need to use Expr(), and Name Expr() is applied wherever it is possible:

Names Default to here(1);
// direct mode, no Expr necessary
Extract Expr(x^2 + y, x);// -> x
Extract Expr(x^2 + y, c);// no c in x^2 + y ->  empty

// Name Expr mode
c=Expr(x^2);
Extract Expr(x^2 + y , c);// looks up c = x^2, find "x^2"" in x^2 +y

Wonderful!

 ... till:

Extract Expr(cc * d , cc); // -> cc
cc=Expr(x^2);
Extract Expr(cc * d, cc);// looks up cc = x^2 , so doesn't find cc in cc * d anymore

Dangerous ...

after defining cc as a symbol with a name expr, is it still possible to use c "literally" in Extract Expr ? 

Extract Expr(cc * d , Expr(cc)); // doesn't work
Extract Expr(Expr(cc) , Expr(cc)); // finds Expr(cc)
Extract Expr(cc , Name Expr(Expr(cc))); // -> empty
Extract Expr(Name Expr(Expr(cc)) , Name Expr(Expr(cc))); // finds Name Expr(Expr(cc)), argh!

even:

cc=Expr(x^2);
clear symbols(cc);
Extract Expr(cc * d , cc); //->  empty()

[#2]

maybe:

use a custom function as a wrapper for Extract Expr

Names default to here(1);
dummy=Function ({expression, pattern},
Extract Expr(expression, pattern);
);

cc = Expr(x^2);
dummy( Expr(cc+d), Expr(cc)); // -> cc

[#3]

Is there something you are looking answers for? Also have you read Scripting Guide about expressions Scripting Guide > Programming Methods > Advanced Expressions, Macros, and Lists - Advanced Expressio... and especially the parts how they get evaluated?

[#4]

On the linked page I did not find further info about Match Expr 

@jthi wrote:

Is there something you are looking answers for? 

---

how to make sure JMP searches for cc in the expression cc * d ?
... even if cc is used as a name for another expression, like of x^2.

Extract Expr(cc * d , cc); // -> cc
cc=Expr(x^2);
Extract Expr(cc * d, cc);// looks up cc = x^2 , so doesn't find cc in cc * d anymore

and more general:
A custom function ALWAYS evaluates its arguments - and via Expr() one can prevent it from doing so.
Match Expr ALWAYS retrieves the unevaluated expression behind a name (if there is one)  before using it - can the user prevent it from doing so?

Platform commands often get disturbed when names are used as arguments - and Eval might fix the issue.

How many categories of handling arguments are there in JSL in total? Is there any red line behind?

[#5 · Accepted solution]

Why would you use same variable name in multiple places like that?

Delete Symbols() and Clear Symbols() are not same

Names Default To Here(1);

cc = Expr(x ^ 2);
Delete Symbols(cc);
Extract Expr(cc * d, cc);

[#6]

Thanks for the link.

View more...

It looks like Extract Expr() works differently depending on how cc is defined. To use cc literally, avoid reassigning it with Expr() or use Name Expr() to manage symbols carefully and prevent evaluation issues. I was struggling with a challenging paper, so I turned to https://domypaper.com/ The service was excellent. The writer was knowledgeable, followed my instructions carefully, and delivered a well-organized, high-quality paper. The communication was smooth, and the paper was delivered on time. I’m extremely satisfied with the results and would definitely use this service again for future assignments.