>> ? :w FOO/BAR/BAZ is an integer of value: 42
is the answer
>> arr: [a 42] == [a 42] >> select arr to-word "a" == 42 >> select arr probe to-word "a" a == 42 >> select arr probe to-get-word "a" :a == 42 >> select arr probe to-set-word "a" a: == 42 >> select arr probe to-lit-word "a" 'a == 42
When you set words to some values,
<word>: <value> (e.g.
<value> will be evaluated.
42) will give you
42(the value looks the same).
3.14) will give you
2x14) and some more - like above
There are some "special" cases:
foo/4) will be evaluated. For example you have
foo: [1 2 3 4], when you set value to some word,
val: foo/4, path
foo/4will be evaluated.
foo/4will be changed, in this case, to the 4th value of the
'foo/4) will be evaluated to
foo/4. As you know already, you can
get wwill give you
4(4th element of the
get-path!will get you value that it points to. It is like
path!. However with
path!you cannot get
function!s for example (
funs: #() funs/not-fibo: func [a] [ a - 10],
funs/not-fibowill try to call
funsmap, it will raise an error because you haven't provided an argument). You can get such value by using
my-fun: :funs/not-fibo. After this you can call it like any other function:
block! every value within a block will be "the same", it won't use "special" rules that govern
get-path!. For example you have a block
my-block: [42 3.14 "string" word :get-word 'lit-word set-word: [another block with a word]], you can see that
*-path are not evaluated:
foreach element my-block [ print "Value: " probe element print "Type: " print mold type? element print "####" ]
Value: 42 Type: integer! #### Value: 3.14 Type: float! #### Value: "string" Type: string! #### Value: word Type: word! #### Value: :get-word Type: get-word! #### Value: 'lit-word Type: lit-word! #### Value: set-word: Type: set-word! #### Value: [another block with a word] Type: block! ####
And last value
[another block with a word] will not evaluate words inside (you have no errors because there is no
a word defined).
Red for Windows version 0.6.3 built 26-Mar-2018/1:14:22+02:00
Maybe yesterday we were after midnight but my question was different:
This is your code:
foo: [bar [baz 42]] w: 'foo/bar/baz get w ; == 42 reduce w ; == 42
I need something like:
z: bar foo: [bar [baz 42]] w: 'foo/(z)/baz get w ; == 42 reduce w ; == 42
(I am just closing my day at work, I'll read it later)
follow up to an earlier question on storing/manipulating functions in series...
with this code:
a: function [x] [x + 1] b: function [x] [x * 2] c: function [x] [x * x] funcs: reduce [:a :b :c] foreach f funcs [ probe f 5] foreach f funcs [ print f 5] foreach f funcs [ print type? f 5]
I get different results via the interpreter
red test.red vs compiled
red -c -o test test.red
output with the interpreter:
6 10 25 6 10 25 integer integer integer
and with the compiled version:
func [ ] func [ ][ ] func [ ][ ] ?function? ?function? ?function? function function function
why the difference ?
unview/all view/no-wait layout/tight [ across space 0x0 my-panel: panel [across space 0x0 box 100x100 red box 100x100 blue return box 100x100 pink box 100x100 green ] ] foreach box my-panel/pane [box/text: form box/offset show box] do-events
origin 0x0to panel:
unview/all view/no-wait layout/tight [ across space 0x0 my-panel: panel [origin 0x0 across space 0x0 box 100x100 red box 100x100 blue return box 100x100 pink box 100x100 green ] ] foreach box my-panel/pane [box/text: form box/offset show box] do-events
@cprinos difference stems from the fact that current compiler supports only a limited set of language, and cannot handle dynamic constructs such as in your example. Try to compile with
-r -eflags instead.
Is there some complete documentation about these differences? its a big deal for my project.