Perform localized, evaluation-leak free replacements












9














Consider the following expression:



expr = Hold[

   {

    f[

     {1, {Print@1}}

     ],

    g[

     {{{Print@1}}}

     ]

    }

   ];


I'm looking for a way to apply a replacement rule to the contents of all expressions with head f. To give a more concrete example, let's say I want to replace Print by Echo, but only inside f.



Restrictions: I have no knowledge about the exact structure around and inside f - there could be more or less nesting going on. This means the replacement rule can't capture the wrapper with Hold attribute, nor can it capture the individual parts of f[…]. (And the evaluation of Print should be prevented of course)






evaluation replacement hold







share|improve this question





























    9














    Consider the following expression:



    expr = Hold[
    
   {
    
    f[
    
     {1, {Print@1}}
    
     ],
    
    g[
    
     {{{Print@1}}}
    
     ]
    
    }
    
   ];


    I'm looking for a way to apply a replacement rule to the contents of all expressions with head f. To give a more concrete example, let's say I want to replace Print by Echo, but only inside f.



    Restrictions: I have no knowledge about the exact structure around and inside f - there could be more or less nesting going on. This means the replacement rule can't capture the wrapper with Hold attribute, nor can it capture the individual parts of f[…]. (And the evaluation of Print should be prevented of course)






    evaluation replacement hold







    share|improve this question



























      9












      9








      9


      1





      Consider the following expression:



      expr = Hold[
      
   {
      
    f[
      
     {1, {Print@1}}
      
     ],
      
    g[
      
     {{{Print@1}}}
      
     ]
      
    }
      
   ];


      I'm looking for a way to apply a replacement rule to the contents of all expressions with head f. To give a more concrete example, let's say I want to replace Print by Echo, but only inside f.



      Restrictions: I have no knowledge about the exact structure around and inside f - there could be more or less nesting going on. This means the replacement rule can't capture the wrapper with Hold attribute, nor can it capture the individual parts of f[…]. (And the evaluation of Print should be prevented of course)






      evaluation replacement hold







      share|improve this question















      Consider the following expression:



      expr = Hold[
      
   {
      
    f[
      
     {1, {Print@1}}
      
     ],
      
    g[
      
     {{{Print@1}}}
      
     ]
      
    }
      
   ];


      I'm looking for a way to apply a replacement rule to the contents of all expressions with head f. To give a more concrete example, let's say I want to replace Print by Echo, but only inside f.



      Restrictions: I have no knowledge about the exact structure around and inside f - there could be more or less nesting going on. This means the replacement rule can't capture the wrapper with Hold attribute, nor can it capture the individual parts of f[…]. (And the evaluation of Print should be prevented of course)






      evaluation replacement hold




      evaluation replacement hold






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited yesterday









      Kuba♦

      103k12201517




      103k12201517










      asked 2 days ago









      Lukas LangLukas Lang

      6,4401929




      6,4401929






















          3 Answers
          3






          active

          oldest

          votes


















          10














          Here's a way making use of Block to cause f to be inert:



          Block[{f},
          
 SetAttributes[f, HoldAllComplete];
          
 expr /. f[args__] :>
          
   RuleCondition[f[args] /. Print -> Echo]
          
 ]
          

          
Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}]


          Note of course that this only works if you have a pattern of the form _Symbol[...]






          share|improve this answer





























            8














            [Edit: For most situations, @Kuba's answer is better]



            I can think of one (ugly) way to do it:



            Attributes[myHold] = {HoldAll};
            

            
expr /.
            
 f[args__] :> With[
            
   {res = myHold[args] /. Print -> Echo},
            
   f @@ res /; True
            
 ] /.
            
  HoldPattern[f_ @@ myHold[args__]] :> f[args]
            
(* Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}] *)


            The idea is to wrap the contents of f inside a function with HoldAll attribute (not Hold, to be able to identify it uniquely later on). In a first step, the expression is returned with myHold[…] still in place. In a second round of replacements, myHold is stripped out again.






            share|improve this answer



















            • 2




              +1. If we use the vanishing macro defined in (43096), we can write vanishing[{h}, expr /. x_f :> RuleCondition[h[x] /. Print -> Echo]].
              – WReach
              2 days ago



















            6














            Alternatively:



            expr /. 
            
  foo_f :> RuleCondition[Hold[foo] /. Print -> Echo] /. 
            
  Hold[foo_f] :> foo


            We can safely perform the second replacement because we just wrapped every f[..] with Hold.






            share|improve this answer























            • +1 - In general, this is definitely better than my solution - the only potential issue is the fact that the pattern _f has to be written twice - so for complex patterns, this might lead to some code-duplication/performance cost
              – Lukas Lang
              yesterday










            • @LukasLang yes, consider this a quick solution to a specific problem. In general something like b3m2a1 shows is needed or a dummy vanishing head.
              – Kuba♦
              yesterday











            Your Answer





            StackExchange.ifUsing("editor", function () {
            return StackExchange.using("mathjaxEditing", function () {
            StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
            StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
            });
            });
            }, "mathjax-editing");

            StackExchange.ready(function() {
            var channelOptions = {
            tags: "".split(" "),
            id: "387"
            };
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function() {
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled) {
            StackExchange.using("snippets", function() {
            createEditor();
            });
            }
            else {
            createEditor();
            }
            });

            function createEditor() {
            StackExchange.prepareEditor({
            heartbeatType: 'answer',
            autoActivateHeartbeat: false,
            convertImagesToLinks: false,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: null,
            bindNavPrevention: true,
            postfix: "",
            imageUploader: {
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            },
            onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            });


            }
            });














            draft saved

            draft discarded


















            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f188887%2fperform-localized-evaluation-leak-free-replacements%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            3 Answers
            3






            active

            oldest

            votes








            3 Answers
            3






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            10














            Here's a way making use of Block to cause f to be inert:



            Block[{f},
            
 SetAttributes[f, HoldAllComplete];
            
 expr /. f[args__] :>
            
   RuleCondition[f[args] /. Print -> Echo]
            
 ]
            

            
Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}]


            Note of course that this only works if you have a pattern of the form _Symbol[...]






            share|improve this answer


























              10














              Here's a way making use of Block to cause f to be inert:



              Block[{f},
              
 SetAttributes[f, HoldAllComplete];
              
 expr /. f[args__] :>
              
   RuleCondition[f[args] /. Print -> Echo]
              
 ]
              

              
Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}]


              Note of course that this only works if you have a pattern of the form _Symbol[...]






              share|improve this answer
























                10












                10








                10






                Here's a way making use of Block to cause f to be inert:



                Block[{f},
                
 SetAttributes[f, HoldAllComplete];
                
 expr /. f[args__] :>
                
   RuleCondition[f[args] /. Print -> Echo]
                
 ]
                

                
Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}]


                Note of course that this only works if you have a pattern of the form _Symbol[...]






                share|improve this answer












                Here's a way making use of Block to cause f to be inert:



                Block[{f},
                
 SetAttributes[f, HoldAllComplete];
                
 expr /. f[args__] :>
                
   RuleCondition[f[args] /. Print -> Echo]
                
 ]
                

                
Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}]


                Note of course that this only works if you have a pattern of the form _Symbol[...]







                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered 2 days ago









                b3m2a1b3m2a1

                26.9k257156




                26.9k257156























                    8














                    [Edit: For most situations, @Kuba's answer is better]



                    I can think of one (ugly) way to do it:



                    Attributes[myHold] = {HoldAll};
                    

                    
expr /.
                    
 f[args__] :> With[
                    
   {res = myHold[args] /. Print -> Echo},
                    
   f @@ res /; True
                    
 ] /.
                    
  HoldPattern[f_ @@ myHold[args__]] :> f[args]
                    
(* Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}] *)


                    The idea is to wrap the contents of f inside a function with HoldAll attribute (not Hold, to be able to identify it uniquely later on). In a first step, the expression is returned with myHold[…] still in place. In a second round of replacements, myHold is stripped out again.






                    share|improve this answer



















                    • 2




                      +1. If we use the vanishing macro defined in (43096), we can write vanishing[{h}, expr /. x_f :> RuleCondition[h[x] /. Print -> Echo]].
                      – WReach
                      2 days ago
















                    8














                    [Edit: For most situations, @Kuba's answer is better]



                    I can think of one (ugly) way to do it:



                    Attributes[myHold] = {HoldAll};
                    

                    
expr /.
                    
 f[args__] :> With[
                    
   {res = myHold[args] /. Print -> Echo},
                    
   f @@ res /; True
                    
 ] /.
                    
  HoldPattern[f_ @@ myHold[args__]] :> f[args]
                    
(* Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}] *)


                    The idea is to wrap the contents of f inside a function with HoldAll attribute (not Hold, to be able to identify it uniquely later on). In a first step, the expression is returned with myHold[…] still in place. In a second round of replacements, myHold is stripped out again.






                    share|improve this answer



















                    • 2




                      +1. If we use the vanishing macro defined in (43096), we can write vanishing[{h}, expr /. x_f :> RuleCondition[h[x] /. Print -> Echo]].
                      – WReach
                      2 days ago














                    8












                    8








                    8






                    [Edit: For most situations, @Kuba's answer is better]



                    I can think of one (ugly) way to do it:



                    Attributes[myHold] = {HoldAll};
                    

                    
expr /.
                    
 f[args__] :> With[
                    
   {res = myHold[args] /. Print -> Echo},
                    
   f @@ res /; True
                    
 ] /.
                    
  HoldPattern[f_ @@ myHold[args__]] :> f[args]
                    
(* Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}] *)


                    The idea is to wrap the contents of f inside a function with HoldAll attribute (not Hold, to be able to identify it uniquely later on). In a first step, the expression is returned with myHold[…] still in place. In a second round of replacements, myHold is stripped out again.






                    share|improve this answer














                    [Edit: For most situations, @Kuba's answer is better]



                    I can think of one (ugly) way to do it:



                    Attributes[myHold] = {HoldAll};
                    

                    
expr /.
                    
 f[args__] :> With[
                    
   {res = myHold[args] /. Print -> Echo},
                    
   f @@ res /; True
                    
 ] /.
                    
  HoldPattern[f_ @@ myHold[args__]] :> f[args]
                    
(* Hold[{f[{1, {Echo[1]}}], g[{{{Print[1]}}}]}] *)


                    The idea is to wrap the contents of f inside a function with HoldAll attribute (not Hold, to be able to identify it uniquely later on). In a first step, the expression is returned with myHold[…] still in place. In a second round of replacements, myHold is stripped out again.







                    share|improve this answer














                    share|improve this answer



                    share|improve this answer








                    edited yesterday

























                    answered 2 days ago









                    Lukas LangLukas Lang

                    6,4401929




                    6,4401929








                    • 2




                      +1. If we use the vanishing macro defined in (43096), we can write vanishing[{h}, expr /. x_f :> RuleCondition[h[x] /. Print -> Echo]].
                      – WReach
                      2 days ago














                    • 2




                      +1. If we use the vanishing macro defined in (43096), we can write vanishing[{h}, expr /. x_f :> RuleCondition[h[x] /. Print -> Echo]].
                      – WReach
                      2 days ago








                    2




                    2




                    +1. If we use the vanishing macro defined in (43096), we can write vanishing[{h}, expr /. x_f :> RuleCondition[h[x] /. Print -> Echo]].
                    – WReach
                    2 days ago




                    +1. If we use the vanishing macro defined in (43096), we can write vanishing[{h}, expr /. x_f :> RuleCondition[h[x] /. Print -> Echo]].
                    – WReach
                    2 days ago











                    6














                    Alternatively:



                    expr /. 
                    
  foo_f :> RuleCondition[Hold[foo] /. Print -> Echo] /. 
                    
  Hold[foo_f] :> foo


                    We can safely perform the second replacement because we just wrapped every f[..] with Hold.






                    share|improve this answer























                    • +1 - In general, this is definitely better than my solution - the only potential issue is the fact that the pattern _f has to be written twice - so for complex patterns, this might lead to some code-duplication/performance cost
                      – Lukas Lang
                      yesterday










                    • @LukasLang yes, consider this a quick solution to a specific problem. In general something like b3m2a1 shows is needed or a dummy vanishing head.
                      – Kuba♦
                      yesterday
















                    6














                    Alternatively:



                    expr /. 
                    
  foo_f :> RuleCondition[Hold[foo] /. Print -> Echo] /. 
                    
  Hold[foo_f] :> foo


                    We can safely perform the second replacement because we just wrapped every f[..] with Hold.






                    share|improve this answer























                    • +1 - In general, this is definitely better than my solution - the only potential issue is the fact that the pattern _f has to be written twice - so for complex patterns, this might lead to some code-duplication/performance cost
                      – Lukas Lang
                      yesterday










                    • @LukasLang yes, consider this a quick solution to a specific problem. In general something like b3m2a1 shows is needed or a dummy vanishing head.
                      – Kuba♦
                      yesterday














                    6












                    6








                    6






                    Alternatively:



                    expr /. 
                    
  foo_f :> RuleCondition[Hold[foo] /. Print -> Echo] /. 
                    
  Hold[foo_f] :> foo


                    We can safely perform the second replacement because we just wrapped every f[..] with Hold.






                    share|improve this answer














                    Alternatively:



                    expr /. 
                    
  foo_f :> RuleCondition[Hold[foo] /. Print -> Echo] /. 
                    
  Hold[foo_f] :> foo


                    We can safely perform the second replacement because we just wrapped every f[..] with Hold.







                    share|improve this answer














                    share|improve this answer



                    share|improve this answer








                    edited yesterday

























                    answered yesterday









                    Kuba♦Kuba

                    103k12201517




                    103k12201517












                    • +1 - In general, this is definitely better than my solution - the only potential issue is the fact that the pattern _f has to be written twice - so for complex patterns, this might lead to some code-duplication/performance cost
                      – Lukas Lang
                      yesterday










                    • @LukasLang yes, consider this a quick solution to a specific problem. In general something like b3m2a1 shows is needed or a dummy vanishing head.
                      – Kuba♦
                      yesterday


















                    • +1 - In general, this is definitely better than my solution - the only potential issue is the fact that the pattern _f has to be written twice - so for complex patterns, this might lead to some code-duplication/performance cost
                      – Lukas Lang
                      yesterday










                    • @LukasLang yes, consider this a quick solution to a specific problem. In general something like b3m2a1 shows is needed or a dummy vanishing head.
                      – Kuba♦
                      yesterday
















                    +1 - In general, this is definitely better than my solution - the only potential issue is the fact that the pattern _f has to be written twice - so for complex patterns, this might lead to some code-duplication/performance cost
                    – Lukas Lang
                    yesterday




                    +1 - In general, this is definitely better than my solution - the only potential issue is the fact that the pattern _f has to be written twice - so for complex patterns, this might lead to some code-duplication/performance cost
                    – Lukas Lang
                    yesterday












                    @LukasLang yes, consider this a quick solution to a specific problem. In general something like b3m2a1 shows is needed or a dummy vanishing head.
                    – Kuba♦
                    yesterday




                    @LukasLang yes, consider this a quick solution to a specific problem. In general something like b3m2a1 shows is needed or a dummy vanishing head.
                    – Kuba♦
                    yesterday


















                    draft saved

                    draft discarded




















































                    Thanks for contributing an answer to Mathematica Stack Exchange!


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid …



                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.


                    Use MathJax to format equations. MathJax reference.


                    To learn more, see our tips on writing great answers.





                    Some of your past answers have not been well-received, and you're in danger of being blocked from answering.


                    Please pay close attention to the following guidance:


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid …



                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.


                    To learn more, see our tips on writing great answers.




                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function () {
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f188887%2fperform-localized-evaluation-leak-free-replacements%23new-answer', 'question_page');
                    }
                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown







                    -

                    Popular posts from this blog

                    Mario Kart Wii

                    Image
                    Please consider supporting The Cutting Room Floor on Patreon. Thanks for all your support! Mario Kart Wii From The Cutting Room Floor Jump to: navigation, search Mario Kart Wii Developer : Nintendo Publisher : Nintendo Platform : Wii Released in JP : April 10, 2008 Released in US : April 27, 2008 Released in EU : April 11, 2008 Released in AU : April 24, 2008 Released in KR : April 30, 2009 This game has unused animations. This game has unused areas. This game has unused code. This game has unused objects. This game has unused modes / minigames. This game has unused graphics. This game has unused models. This game has unused items. This game has unused music. This game has regional differences. This game has a notes page This game has a prerelease article Mario Kart Wii is the sixth game in the series (not counting Arcade editions), which intro...
                    Read more

                    The Binding of Isaac: Rebirth/Afterbirth

                    Image
                    Please consider supporting The Cutting Room Floor on Patreon. Thanks for all your support! The Binding of Isaac: Rebirth/Afterbirth From The Cutting Room Floor < The Binding of Isaac: Rebirth Jump to: navigation, search This is a sub-page of The Binding of Isaac: Rebirth . Afterbirth is the first expansion pack for Rebirth and features a variety of improvements. Contents 1 Unused Graphics 1.1 Old Man Keeper 1.2 Skinless Hush 1.3 Miscellaneous Unused Hush Sprites 1.4 Generosity achievement 1.5 Afterbirth+ Room Editor 1.6 Bearded Ultra Greed 1.7 Early Ultra Greed 1.8 Unused Brownie Expression 1.9 Frail's Spinning Head 1.10 Mom's Dead Hand Alt 2 Unused Audio 2.1 Unused Dead Womb Layer 2.2 Unused Hush Battle Outro 2.3 The Stain Grunt Unused Graphics Old Man Keeper Image file: gfxuimain me...
                    Read more

                    What does “Dominus providebit” mean?

                    Image
                    5 Does "Dominus providebit" mean "The Lord will provide" or "The Lord provides"? I once had a bit of an argument with a guy who studied Latin over that. It's an inscription that appears on the rim of some old Swiss coins that I have. meaning latin-to-english-translation grammar-identification share | improve this question edited Jan 18 at 15:27 V2Blast 105 4 asked Jan 17 at 22:49 Donald K. Donald K. 26 1 ...
                    Read more