t: 0 view [
box 200x200 rate 10 draw [matrix [0 0 0 0 100 100] box -50x-50 50x50]
on-time [t: t + 1
face/draw/2/1: cosine t
face/draw/2/2: negate sine t
face/draw/2/3: sine t
face/draw/2/4: cosine t
]]
Here is matrix
rotation combined with scaling...:
t: 0 view [box 200x200 rate 10 draw [matrix [0 0 0 0 100 100] box -50x-50 50x50]
on-time [t: t + 1
face/draw/2/1: cosine t face/draw/2/2: 1.5 * negate sine t
face/draw/2/3: 1.5 * sine t face/draw/2/4: cosine t
]]
...skewing...:
t: 0 view [box 200x200 rate 10 draw [matrix [0 0 0 0 100 100] box -50x-50 50x50]
on-time [t: t + 1
face/draw/2/1: .5 * cosine t face/draw/2/2: negate sine t
face/draw/2/3: sine t face/draw/2/4: 1.5 * cosine t
]]
... and translation:
t: 0 view [box 200x200 rate 10 draw [matrix [0 0 0 0 100 80] box -50x-50 50x50]
on-time [t: t + 1
face/draw/2/1: cosine t face/draw/2/2: negate sine t face/draw/2/3: sine t
face/draw/2/4: cosine t face/draw/2/6: face/draw/2/6 + 10 - (t % 21)
]]
t: 0 view/tight [box 200x200 rate 10 draw [rotate 180 100x100 matrix [0 0 0 0 100 80] box -50x-50 50x50]
on-time [t: t + 1
face/draw/5/1: cosine t face/draw/5/2: negate sine t face/draw/5/3: sine t
face/draw/5/4: cosine t face/draw/5/6: face/draw/5/6 + 10 - (t % 21)
]]
Hi,
if I have a function which accepts a block of block like:
blk: [[a] [b]]
and I want to include this data in a bigger block like:
blk2: [one [[a] [b]] two [[c][d]]]
And provide to the function a block of my choiche without picking (copying) it
If I move the index of the series to the block next to ONE
myblock: find/tail blk2 'one
>> probe myblock
= [[[a] [b]] two [[c][d]]]
I whish to
>> probe myblock
= [[a] [b]]
Without anything which involves a (memory) copy
select
returns a value that follow the key (if any), find/tail
searches for the first occurence of a value and returns a series past that value.
Another question: is where a way to have a subseries of a bigger one in a static way ?
Example:
a: [a b c d e f g h]
The subseries should be:
b: [d e]
But [d e] are just part of "A"
So if you change the B: to "[z e]"
>>> a
= [a b c z e f g h]
>> a: [a b c d e f g h]
== [a b c d e f g h]
>> b: reduce [at a 4 2]
== [[d e f g h] 2]
>> head change/part b/1 [z e] b/2
== [a b c z e f g h]
>> a: [a b c d e f g h]
== [a b c d e f g h]
>> subseries: 4x2
== 4x2
>> head change/part at a subseries/x [z e] subseries/y
== [a b c z e f g h]
@nedzadarek If you consider pnly figures, then almost. In addition, optional set-word may also precede the block
view [box draw [b: box 10x10 50x50 c: circle 30x30 30]]
view [box draw [[b: box 10x10 50x50][c: circle 30x30 30]]]
view [box draw [[[[[[[b: box 10x10 50x50]]] circle 30x30 30]]]]]
view [box draw [b: [box 10x10 50x50]]]
view [box draw [b: [b2: box 10x10 50x50]]]
view [box draw [b: b2: b3: box 10x10 50x50]]
view [box draw [b:]]
So, it is more like
<draw-command>: (<command> <arguments> | '['<command> <arguments>']')
<draw-expression>: <set-word>* <draw-command>
<draw>: <draw-expression>*
apply
, but you can use tricks similar to the above one.
Well, thanks, I was just imaging if there where a simple way to load code words/values at the current program execution position. So, it FOO expected X and Y then something like
(I assume "<" mean: "insert the result of the code between parens at this point")
FOO <(BAR)
Print "A"
Would be interpreted like
FOO 1 2
Print "A"
>> foo: func [x y][x + y]
== func [x y][x + y]
>> bar: does [[1 2]]
== func [][[1 2]]
>> compose [foo (bar)]
== [foo 1 2]
>> do compose [foo (bar)]
== 3
Macros is not what you want, I guess. They can't operate on values that are presented at run-time (i.e. you can't evaluate function bar
, because it doesn't exist yet).#do [bar: [1 2]]
#macro ['< paren!] func [start end][
get in preprocessor/exec start/2/1
]
probe expand [
foo <(bar)
foo #do keep [[1 2]]
]