AltME groups: search

Another issue. Looks like global word SUFFIX-MAP is supposed to be 
local to CTX-VIEWTOP.

Just checked, Rebol/Link does not have SUFFIX-MAP global.

Thanks.  btw
I saw this on MAP on the Rebol3 group
>> map [where:] [1 2 3 4 5 6] [take/part where 2]

== [[1 2] [3 4] [5 6]]          ; Graham said not too intuitive - 
I prefer the solution you suggested to me a few days back

; Will we have FOLD in Rebol3?  If so, it should be intuitive, as 
should any MAP  imho   TAKE inside a MAP is counter-intuituve to 
me cuz MAP should not ;be slice-n-dice ... PARTITION/pairs   PARTITION/triples 
    partition/4   etc

i don't think one would use TAKE often with MAP or FOREACH.

usually you just do something like map [a b] [1 2 3 4] [a + b]

Hi, 
Pekr,

I appreciate that the concept for parsing is different to the use 
of regular expressions, but there are some things that do map from 
one to the other & I wondered if any table of those things existed. 
 As a noob sometimes the hardest questions to get answered are the 
ones where the answer is that there is no concept such as that sought 
by the noob. e.g. how do you grow strawberries in the sea?
 

The first match must be at the begining of the line. If it was the 
first line in the set then it would not be after a new line, but 
other cases it would be.


I will use parse/all from now, I like the extra control you describe.


here a few lines of a test input, the script I am hoping to develop 
is to parse the config files from Cisco devices in order to extract 
the layer 2 & 3 information together with the interface names & descriptions.

lines: {interface FastEthernet0
 description The connection to the printer
!
interface FastEthernet1
!
interface Vlan1
 description User vlan (only 1 vlan allowed)
 no ip address
!
interface Dialer0
 description Outside
 ip address negotiated
!
interface BVI1
 description Inside
 ip address 192.168.0.1 255.255.255.0
!
ip sla 3
 icmp-echo 217.0.0.1 source-interface Dialer0

ip route 0.0.0.0 0.0.0.0 Dialer0

interface ATM0.1 point-to-point
 no ip redirects
 no snmp trap link-status
 pvc 0/38
  pppoe-client dial-pool-number 1
 !
}


; sqlab, your change to use "thru newline" does what I wanted in 
this case which is good.

; my next step is to try & understand the "or" construct properly 
as the code below dosn't quite cut it.

wanted: copy []
interface: ["interface" [to #"^/" | to "point-to-point"]]

parse lines [any [[copy temp interface (insert tail wanted temp)] 
| thru newline ]]
foreach line  wanted [print line]

; thanks very much for your help, /\/\

the "comprehension" of those simple things is essential, simply knowing 
about them is useless... cause in real life, you will have to "SEE" 
the whole recursive structure of the parse rules played in your head. 
 


if you don't fully grasp what is going on, you can't really create 
that essential mental map.   that is what kept me from understanding 
parse for 6 yess... SIX years :-(   and suddenly over the course 
of 2 days, I finally "GOT" it and a week later I was building a 700 
line parse rule for a real-time server doing signal convertion from 
one data format to another through two network ports.

I haven't played with unix for so long I'm a bit (very :-)  rusty.

when doing an 'ls -al'

I get:

total 20
drwxr-xr-x  2 root root 4096 May 16 05:37 .
drwxr-xr-x 21 root root 4096 May 16 12:10 ..
-rw-------  1 root root  437 May 17 09:35 .bash_history
-rw-r--r--  1 root root  412 Dec 15  2004 .bashrc
-rw-r--r--  1 root root  140 Nov 19  2007 .profile


I can't remember what the "total 20" stands for. 

it doesn't map to file numbers, block counts used by files, or anything 
I can gather... is this some type of millisecond count of time it 
took to perform the file list?

if you add fonts I believe you have to rebuild the font map ie. fonts 
can be scattered over different directories.

If it is a full disk, you'll need to mount the proper partition within 
the disk. There are various approaches possible, depending on your 
actual scenario. You could loop-mount with an offset, if you now 
your disk layout fairly well. Alternatively, use losetup to set up 
a loop device bound to the disk image. Then use kpartx to have the 
kernel read the partition table from this new device and map the 
partitions to their own devices. Finally mount the device corresponding 
to the partition you want to access.

Pekr: the SVG Demo is just a quick and dirty prototype. I'm just 
going to get it to the stage where it can display simple SVG icons 
(for RebGUI). If someone else wants to write an SVG viewer that is 
fully SVG 1.1 (with 1.2 around the corner) compatible then good luck 
... I'm *not* going to be doing that! ;)


yeksoon: see above comments. I'm tweaking the SVG Demo code on an 
SVG icon by icon basis. As long as it works for the icons I use (or 
intend to use) I'm happy - I don't guarantee the code will work with 
anything other than the specific SVG files I have tested it on.


Cyphre: SVG is such a "flexible" standard isn't it? :) One question; 
how did you map SVG "path d" commands (e.g. <path style=... d="M 
10 10 C 20 20 ... z") where there is no "z" command to close the 
"shape" (i.e. the AGG shape command closes by default).


shadwolf: Having our own SVG icons is a good idea as we don't have 
to worry about licence / distribution issues and we can tweak the 
generation to make it as AGG compatible as possible. To do that we 
need to settle on *one* tool so as we generate consistent SVG code, 
and we should generate SVG that uses a single unit of measure, preferably 
pixels, as it's a real pain trying to handle multiple units of measure 
within the same file. I'll continue this discussion in the RebGUI 
group.

fovsz: 450x450

layout compose [starfield: image (fovsz) black]

starfield: to-image starfield

loop 1000 [
	col: random 255
	starcol: to-tuple reduce [col col col]
	poke starfield random fovsz/x * fovsz/y starcol
]

view/new layout compose [
	b: image starfield
]

hvector: func [x y v][

 (fovsz/x / fov) * (fov / 2 + either zero? pos/2 - y [90][arctangent 
 (pos/1 - x) / (pos/2 - y)])
]

vvector: func [y z v][

 (fovsz/y / fov) * (fov / 4 + either zero? pos/2 - y [90][arctangent 
 (pos/3 - z) / (pos/2 - y)])
]

map: [
	"A New Beginning"
	""
	"Rebol HQ, led by their jedi leader,"
	"Carl Sassenrath, has begun"
	"preparations to strike back against"
	"Darth Gates at the Redmond system"
	"during a time of growing unrest"
	"among the netizens of the Empire."
	""
	"As the Empire works to complete"
	"construction of their hailed"
	"planetary domination device, code"
	{named "Longhorn Death Star", small}
	"centers of resistance continue to"
	"gain support among the"
	"oppressed masses."
	""
	"Even with mounting support, only"
	"One is powerful enough to overcome"
	"the dark side of the Force --"
	""
	"Rebol/View 1.3"
]

mapimg: copy []

foreach line map [

 b1: layout/origin compose/deep [text (line) 840 center font-size 
 48 sky black (either any [line = map/1 line = last map]['bold][])] 
 0x0
	append mapimg to-image b1
]

pos: [0 30 20]
dir: [0 0]

fov: 45

for l pos/2 200 .1 [
	agg: copy []
	x: 0 y: 0
	foreach item mapimg [
		y: y + 5
		if y < pos/2 [
			append agg compose [
				image (item)
				(to-pair reduce [hvector x + 15 y dir/1 vvector y 0 dir/2])
				(to-pair reduce [hvector x - 15 y dir/1 vvector y 0 dir/2])

    (to-pair reduce [hvector x - 15 y + 5 dir/1 vvector y + 5 0 dir/2])

    (to-pair reduce [hvector x + 15 y + 5 dir/1 vvector y + 5 0 dir/2])
				black
			]
		]
	]
	b/effect: compose/deep [draw [(agg)]]

	show b

	pos/2: l
]

How about exposing the math? To map mouse back to faces, as in Antons 
demo?

basically... the event gives you the window gob and the offset in 
it. then there's a native that can map an offset inside the window 
to the gob it belongs too. so the mezz code just uses that, then 
maps the gob to the feel, eg via gob/data (user data field)

since gob/data can be whatever... you can map any gob to any feel, 
gob b inside gob a may map to gob c which is elsewhere.

(map to same feel as gob c)

or you don't map the offset to the gob at all, but use a bitmap to 
map the offset to something else, like max does in elixir etc.

map readers etc

This latest rendering was just a test to see what the triangle speed 
limits were using a height map and a colour map.

yeah .... events applyed directly on draw elements or draw able to 
"map" and show directly other graphical organised video layers who 
be so awsome that way from example what is rendered on sub engine 
external like opengl one could then be applyed to a regular vid area 

In one hand you will have an easy way to interface events and on 
the other hand you can map rendering any kind of sub rendering

maybe a way to solve this and introducing in the area something new 
could be to map directly events t o draw  text idiom. the way you 
create one and for all a event handler you apply it to the text idiom 
 and any time you use i t in your draw definition then the event 
mapping is avaible.

Which leads to the question of why map the words in the do dialect 
at all, and not just derebmu the whole thing before execution.  (I 
think it's just a different way of thinking about what to do with 
the word map, not a tremendously big deal.)

Anyway, the idea is to map characters in the URL that are unallowed 
by the local filesystem to something else (probably the hex representation 
?)

This type of mapping could cause collisions (there might be a url 
with a %3F already in place of the ?) but I think this imperfect 
system is better than not being able to map at all.

So the initial goal for me is just to map the ? character, then later 
I will see about other non-allowed characters. I think it is ? who 
is causing all or most of the problem.

I suspect you will have to look up the ip address in an ip map and 
guess from there

and there is the main function temple-map-data, which in combination 
with above functions finds particular element (e.g. table) and in 
repetitive manner maps data into structure - it replaces those elements 
...

so - my deisnger e.g. does table, assigns it 'id or not, does e.g. 
two rows as an example of the design, and via temple-map-data you 
map it ....

Gabriele just admitted, it can be slow ... you simply has template.html 
- your designer is completly free to replace it not knowing single 
line of REBOL, then you have your engine - temple, and then your 
temple script (those map-data find-by-class etc. instructions)

Search engines like to index things a user can see.

Thye get suspicious of anything that appears to be built just for 
the.....No surprising given how much they have been gamed by SERPS 
spammers.

Having a human-readable site map has the same effect as a crawler 
page *and* taks you a long way towards having a site that is navigable 
by people under any conditions.
***

The google-approved method of doing a crawler page is to use what 
they call a sitemap:
http://www.google.com/support/webmasters/bin/topic.py?topic=8476

Someone could easily modify Carl's site-checker to emit a google 
sitemap:

http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=site-check.r

Ah, I missed that part. Just need to map GetFileVersionInfo then 
I guess.

I'd've written it the same way too -- though on the test dataset, 
the find could be a equality test:
    if row/2 = map/1 [change row/4 map/2]

I think he's hoping for a more set-related way rather than procedural 
method.

transform: func [
	block [block!] "Datatset to transform"
	cmds  [block!] "Transformation commands to perform"
	/local
		run-map-transform
		main= map-blk= src= dest=
		      =map-blk =src =dest
][

 run-map-transform: func [src [integer!] dest [integer!] map [any-block!] 
 /local val] [
		foreach item block [
			if val: select/skip map item/:src 2 [change item/:dest val]
			;print [val mold item]
		]
	]
	map-blk=: ['using set =map-blk word!] 
	src=: ['field set =src integer!]
	dest=: ['into opt 'field set =dest integer!]
	map-cmd=: [
		['map src= map-blk= dest= | map-blk= 'map src= dest=]
		;(print [=map-blk =src =dest])
		(run-map-transform =src =dest get =map-blk)
	]
	main=: [some map-cmd=]

 either parse cmds main= [dataset] [none] ; decide how to handle bad 
 cmd scenario
]


transform copy dataset [map field 2  using glcodehash into field 
4]

transform copy dataset [using glcodehash  map field 2 into field 
4]

I wondered this for long time, and never found it... does rebol have 
a native equivalent of HL functions like map, reduce, filter ?

functions that take functions as parameters, map, reduce, filter 
are basic functions for functional programming

no specific language I will write map in rebol and show you , it 
should be a simple function

but what is your reference ? map can have many implementations depending 
the language...

So R3 has a MAP, but it takes a word and a block of code as parameters 
instead of a function.

if you are using blocks which seems fine as it's even shorter and 
more agile (and similar to quotations in factor), but how do blocks 
define which parameter is which , in case of map it must take 1 parameter 
in case of reduce 2 ?

So R3's MAP takes 3 parameters:
- The data

- The word or block of words that will serve as "parameters" for 
the block.
- The block of code.

>> help map
USAGE:
        MAP 'word data body

DESCRIPTION:

        Evaluates a block for each value(s) in a series and returns them 
        as a block.
        MAP is a native value.

ARGUMENTS:

        word -- Word or block of words to set each time (local) (word! block!)
        data -- The series to traverse (block!)
        body -- Block to evaluate each time (block!)

>> map x [1 2 3] [x * x]
== [1 4 9]

>> map [x y] [1 2 3 4 5 6] [x * y]
== [2 12 30]

great, well map and fold are the most used ones by far

this seems to work as simple map   fpmap: func [ series mod ] [ new: 
copy [ ] foreach item series [ append new mod item ] new ]

well your R3 map will surelly be more powerfull, but it's nice to 
know I can make simple HOFs in R2 too

I mean map that you made examples off

You can make REBOL-style control functions like R3's MAP in R2 too.

in R2:

map: func [vars list exec /local res][res: copy [] do reduce [:foreach 
vars list compose [append res (exec)]] res]
>> map [a b][1 2 3 4][a * b]
== [2 12]
>> map [a][1 2 3 4][a * a]
== [1 4 9 16]

and if you always use the same vars (like x, y and z) you can simplify:

 map: func [list exec /local res][res: copy [] do reduce [:foreach 
 intersect [x y z] exec list compose [append res (exec)]] res]
>> map [1 2 3 4][x * x]
== [1 4 9 16]
>> map [1 2 3 4][x * y]
== [2 12]

map: func [vars list exec /local res][res: copy [] do reduce [:foreach 
vars list compose [append (res) (exec)]] res]
is that ok now ?

map: func [vars list exec /local res][res: copy [] do reduce [:foreach 
vars list compose [(:append) (res) (exec)]] res]

Start with this spec from R3:
map: func [

    {Evaluates a block for each value(s) in a series and returns them 
    as a block.}

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
] [...]

>> map [a b] [1 2 3] [a * b]
** Script error: * does not allow none! for its value2 argument
** Where: map
** Near: map [a b] [1 2 3] [a * b]

simpler:

map: func [vars list exec][do reduce [:foreach vars list reduce [:append 
[] :do exec]]]

>> map [x][1 2 3 4][x * x]
== [1 4 9 16]
>> map [x y][1 2 3 4][x * y]
== [2 12]

and finaly, we can use a single var:

map: func ['vars list exec][do reduce [:foreach to-block vars list 
reduce [:append [] :do exec]]]

>> map [x][1 2 3 4][x * x]
== [1 4 9 16]
>> map x [1 2 3 4][x * x]
== [1 4 9 16]

For that matter, the to-block is also unnecessary. Try this:

map: func ['vars list exec][foreach :vars list reduce [:append [] 
to-paren exec]]

at the end you two will have just map: func [ ] [ ] and it will work 
:)

map: func [

    {Evaluates a block for each value(s) in a series and returns them 
    as a block.}

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
] [
    foreach :word data reduce [:append [] to-paren body]
]

and I just wrote the code with double map instead of double foreach 
and it looks much more elegant ... no collector values no explicit 
returning then , it would be great if this would be in rebol IMHO

Not too much overhead compared to native MAP. We could cut down on 
memory overhead by preallocating the destination.

map: func [

    {Evaluates a block for each value(s) in a series and returns them 
    as a block.}

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
] [

    foreach :word data reduce [:append make block! either word? word 
    [length? data] [divide length? data length? word] to paren! body]
]

map: func [
    [throw]

    {Evaluates a block for each value(s) in a series and returns them 
    as a block.}

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
] [
    foreach :word data reduce [

        :append make block! either word? word [length? data] [divide length? 
        data length? word] to paren! body
    ]
]

Brian, i wonder what will be the overhead if map was a mezzanine 
in R3 (you should test that too) ?

Here's the fastest version for R2:
map: func [
    [throw]

    "Evaluates a block for each value(s) in a series and returns them 
    as a block."

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
] [
    head foreach :word data reduce [

        :insert :tail make block! either word? word [length? data] [divide 
        length? data length? word] to paren! body
    ]
]

btw: python was recieving criticism because guido made it more and 
more awkward to use functional programming , which wasn't handeled 
that well previoulsly either. The way you added a powerful (with 
variable number of params) map that looks like native in other languages 
really speaks something about a language. Interestingly this article 
about python also mentions REBOL http://lambda-the-ultimate.org/node/2302

(thanks for interesting discussion and code, I have to go to sleep 
it's almost morning here), I will use map a lot :)

an /keep refinement on map ?

do you mean by default map should do change ?

Let me show you MAP with /into.

map: func [
    [throw]

    "Evaluates a block for each value(s) in a series and returns them 
    as a block."

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
    /into "Collect into a given series, rather than a new block"
    output [series!] "The series to output to"
] [

    unless into [output: make block! either word? word [length? data] 
    [divide length? data length? word]]

    foreach :word data reduce [:insert :tail output to paren! body
    output
]

REBOL is so nice, that if you miss some cool feature found in some 
other language, like the MAP function, you can make it in a line 
of code. We should add a wiki with such cool things from other languages, 
and how you do it in REBOL.

map: func [
    [throw]

    "Evaluates a block for each value(s) in a series and returns them 
    as a block."

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
    /into "Collect into a given series, rather than a new block"
    output [series!] "The series to output to"
] [

    unless into [output: make block! either word? word [length? data] 
    [divide length? data length? word]]

    head foreach :word data compose [output: (:insert)  output (to paren! 
    body)]
]
>> map x [1 2 3 4][x + x]
== [2 4 6 8]
>> map [x y][1 2 3 4][x + y]
== [3 7]
>> map/into [x y][1 2 3 4][x + y][10 11 12]
== [3 7 10 11 12]

But still a problem with the output var collision

still on map, should be faster with /into


    len: to integer! either word? word [length? data] [divide length? 
    data length? word]

    either into [insert/dup output none len][output: make block! len]

    head foreach :word data compose [output: (:change)  output (to paren! 
    body)]

Here's a version of MAP with the /into semantics and no variable 
capture problems. I had to add a local function, though it is only 
created once per call. Binding issues prevent the use of a literal 
function. While i was at it I added unset! handling like the R3 version.

map: func [
    [throw]

    "Evaluates a block for each value(s) in a series and returns them 
    as a block."

    'word [word! block!] "Word or block of words to set each time (local)"
    data [block!] "The series to traverse"
    body [block!] "Block to evaluate each time"
    /into "Collect into a given series, rather than a new block"
    output [series!] "The series to output to"
] [

    unless into [output: make block! either word? word [length? data] 
    [divide length? data length? word]]
    foreach :word data reduce [func [val [any-type!]] [
        if value? 'val [output: insert output :val]
    ] to paren! body]
    either into [:output] [head :output]
]

I added the last MAP with the insert/only fix to DevBase. We'll see 
if it gets accepted. All we're missing now is fold.

just a thing Brian...

i don't like how map evolved. It lost his simplicity and inner speed.
Some gain like (either vs to-block) have been over rated.

some other bringing major speed regression  have been under rated.


i prefer the throw of an error during initialisation (ie. if find 
word  'output) instead of using the tricks of the embedded builded 
function.

perhaps we should have 2 distinct foreach block or 2 distinct functions 
(map and map-into)

The /into option is not just for MAP. It is intended to be added 
to a lot of series generating functions. The point of it is to allow 
those functions to optionally use INSERT semantics, so that we can 
make it easier to use buffers in a lot of places for memory savings. 
It's part of an overall strategy to reduce the memory overhead of 
REBOL code. INSERT semantics were chosen because INSERT is the most 
basic function here. CHANGE and APPEND can be implemented with INSERT 
(and REMOVE, HEAD and TAIL), but not so easily the other way.

Brian, your last function is 2 time slower (on big series) just to 
avoid the collision with the 'result var and because you don't want 
2 distinct foreach blocks (one for /into, one for default).

You also forget to pre-insert void spaces when using the /into option, 
so that your implementation is incoherent with your initial statement 
of the need to avoid memory overhead

Actually, It's your choices (not the best ones to my mind) so i don't 
follow you. 

Finally, i don't see the interest to have not the fastest implementation 
of map in R2 just to have a strict retrocompatibilty with R3.

Brian, is the R3 map function dealing with unset! values too ?

faster when using default map

its rough code.... map for level should be made from tiles, and the 
moving should be twice smoother.... than it would be same as on atari....

And it uses atari resolution.... and I did scaling in software... 
each atari pixel is actually 4x4 pixels in image....
Is there a way to scale image using hardware in rebol?

Where is the map data coming from?

hum... its possible that some values just don't map directly to precise 
values (floating point errors)

There is no standard I know of for mapping data to faces. A number 
of us have rolled our own systems over time, each with our own critieria 
and design aesthetic.


As a simple starting point, consider setting up declarative mappings 
and driving a data-exchange loop. e.g.

face-field-map: [
    lname 2 fname 3 spouse 4 
    email 5 hphone 6 cphone 7 
    addr 8 city 9 state 10 zip 11
]

foreach [face-name field-index] face-field-map [
    set-face get face-name  pick db/:counter field-index
]

I think I know what trouble novices have though .... when you look 
at C or java-script like languages, it is clear what is happening, 
even if you don't know exact meaning of function name ... but imo 
with rebol - novice is looking into longer sequences of lots of english 
words, without parens, so the programmer can't immediatelly map to 
what is done and when .... :-)

Sigh .. looks like I need a better way to map postscript points to 
the draw coordinate system.

I map the standard postscript fonts to the free GNU postscript equivalents 
in that zip file I mentioned.

one reason is that it doesn't map 1:1  plugs are both edges and nodes, 
for example.

Another way to put it.. I want to map all urls to a single module

Then if you want to process URI that do not map directly to the filesystem, 
you can either use ALIAS (untested) : ALIAS "/" %rest-dispatcher.rsp

tomorrow you'll see globs, which actually seem like a 100% map to 
R3 gobs so far  :-)

are you seeing how complex the problems he is mapping? trying to 
map this into databases, means queries which scrub piles of data, 
in relavance, there no "scrubing"

each levels can map to a specific type of hw/sw structure.

Which is sad because the drawing capabilities of Rebol are pretty 
cool. I got tile based map rendering and scrolling working in 5 minutes 
tops :)

wrt the second choice... its the same mission, I think it only changes 
the win rules and spawning rules.   I helped the doctor.  my guess 
is that when you help the protoss,you have to destroy the settlements 
before they all leave.

in the ghost mission, its a completely different map IIRC.

This may be of interest to those of you who need to [quickly] create 
hexagonal game maps ... but don't want to master a complex CAD program. 
My QAD attempt at a declarative solution yields results like this:

	http://dl.dropbox.com/u/8269768/ACW.png

The prototype code can be found here:

	http://dl.dropbox.com/u/8269768/MapMaker.zip


No documentation, but the sample map file (ACW.r) shows how the PNG 
above was generated. Note you can drag the map around by click-moving 
it. Map, game and software still WIP.

Thanks. ACW.r coded by hand, but helped by the fact that I used a 
real map as a background image to trace over (the compass rose method 
of indicating paths is really easy ... "start in Cairo, go 3 hexes 
north, etc"). By comparison, I spent days trying to get the same 
results with CC3 (Campaign Cartographer 3) ... but I'm only a casual 
CC3 user.

well, what can I say... Ashley is directly responsible for my failure 
to resist getting Civ V.... yes... your tile map tilted me into buying 
Civ V   

;-)