I feel someone ready to call me out for cat chat.
>> files: [%app.red %backup.txt %r1.r %r2.r %r3.r]
== [%app.red %backup.txt %r1.r %r2.r %r3.r]
>> list-of-rules: []
== []
>> foreach f files [if equal? suffix? f ".r" [append list-of-rules f]]
== [%r1.r %r2.r %r3.r]
Use
collect/keep.
I know how to use it inside red parse, but have not ideas how work with it in classic red. Something like?
l: foreach f files [if equal? suffix? f ".r" [collect keep f]]And it's seems that keep can't use outside red parse:
>> ? keep
No matching values were found in the global context.
But why
keep works outside parse?
Like if I wanted to use refinement or not depending on some condition, without repeating all other function arguments?
like
f/:cond xyz
probably just construct the call dynamically, then
do?
:point_up: January 24, 2020 1:48 AM @bubnenkoff each dialect defines its own rules. Sometimes the same names will be used, e.g.
copy, collect, and keep so they align with standard Red functions, but they may behave differently. It may seem strange at first, but it becomes natural before too long for most people.
@bubnenkoff Carl, the creator of Rebol, wanted to create a system that allowed people to create dialects for domain-specific tasks. This would be like if you went to a conference and in one room, there were a number of astronomers. In another room, there were doctors. And in another room, there were lawyers. Another room had stock analysts. They might all be speaking the same language, but they would be using dialects to more efficiently communicate with others in the same specialty.
We could live without
parse. But we wouldn't be as effective without it, and our code would be more complicated.
Also, in the military, they may use the word
asset. The military's meaning of asset would be different than the financial analyst's meaning of asset.
``` apt
```git clone https://github.com/anonymouXnash
@GiuseppeChillemi re: starter example
Can't write you one, but here's some ideas:
Can't write you one, but here's some ideas:
- call a function with the code (which is data) in question
- have 2 states - do-evaluation or parse-evaluation - there
- in do-mode, use
do/nextand check the mode again (switch if needed) - in parse-mode, define a rule
exitthat sets the position and breaks out of parse, then after a break (in do-mode again), continue from that position
The biggest headache will be to support (if you need it) this in inner nested blocks and when leaving those
Neither in pre-load nor (reliably) after lexing. You need to evaluate your code, to be aware of definition changes since the initial boot-up. E.g. you think
+ is an operator, but at some point it may change into a value or a function and you need to be up to date with this change. The only way to be up to date is to evaluate ;)
If your switch is static enough that you pretty much know the outcome in advance, then just resort to macros (#if, #either, #switch, #case).
Well, I do not have enough knowledge to understand the pre lexer and after lexer and macros level but the do/next and switching to parse is at my reach.
pre-lexer is just a big string, system/lexer/pre-load thing abuses that
after lexing it's a block of Red values, there goes preprocessor and expands macros
then goes do on the result
Also, seeking docs and examples on pre lexer, could you point me to something?
search wiki for pre-load, there must be something