Comment conserver (imprimer le texte) lorsqu'il disparaît lors de l'utilisation de composer?

s: {hello test1 parse test2}
t1: "test1"
t2: "test2"

rule: compose [ thru (t1) mark: copy text to (t2) (print text)]
parse s rule

Même question pour composer / deep si c'est une réponse différente:

s: {hello test1 parse test2. hello second test for test1 parse test2.}
t1: "test1"
t2: "test2"

rule: compose/deep [ any [thru (t1) mark: copy text to (t2) (print text)]]
parse s rule
red
2
user310291 23 mai 2018 à 11:26

3 réponses

Meilleure réponse

Vous pouvez soit convertir block en paren, soit citer paren:

>> compose [something here (to paren! [print text])]
== [something here (print text)]
>> compose [something here (quote (print text))]
== [something here (print text)]

C'est la même chose pour compose/deep.

4
rebolek 23 mai 2018 à 12:06

Comme les blocs protègent leur contenu de l'évaluation de composer , vous pouvez également utiliser

>> rule: compose [ thru (t1) mark: copy text to (t2) (first [(print text)] )]
== [thru "test1" mark: copy text to "test2" (print text)]
1
sqlab 24 mai 2018 à 05:58

Vous n'êtes pas limité à ce qui est dans la boîte, vous pouvez donc créer votre propre construction de type COMPOSE qui fait d'autres modèles.

Par exemple, voici un composeII qui ne remplace que les cas où il y a des parenthèses imbriquées. Il laissera donc (x) seul mais évaluera ((x)) .

composeII: function [block /only /deep] [
    collect [
        foreach item block [
            case [
                all [
                    paren? :item
                    1 = length? item
                    paren? first item
                ][
                    either only [
                        keep/only do first item
                    ][
                        keep do first item
                    ]
                ]

                all [
                    deep
                    block? :item
                ][
                    either only [
                        keep/only composeII/deep/only item
                    ][
                        keep/only composeII/deep item
                    ]
                ]

                true [
                    keep/only :item
                ]
            ]
        ]
    ]
]

Donc pour votre cas:

>> t1: "test1"
>> t2: "test2"

>> composeII/deep [
    any [thru ((t1)) mark: copy text to ((t2)) (print text)]
]

== [
    any [thru "test1" mark: copy text to "test2" (print text)]
]
6
HostileFork says dont trust SE 23 mai 2018 à 13:33