World: r3wp

thanks for the input.  I'll see what I can do.

how to prevent binary data from spanning multiple lines?

this

 #{
    3A
    18
    92
    56
}

should be this

#{3A189256}

is this possible?

Afaik, binaries don't keep the info about how they were laid out 
on the page like blocks do. The whitespace won't be preserved when 
they are printed out. And there is no whitespace internally in the 
binary, just binary data.

according to the above example I would like to store the binary via 
a tcp.

any other possibility to transform the binary? while  using enbase 
I have 
also todo a dehex after retrieving. would like to avoid this.

the best would be if I could store just 3A189256 and then reform 
ist back to a binary.
is this in general possible brian?

tombon, the binary is not spanning mulitiple lines .. that's just 
 a display issue?

unforunatly not. when I compose the value pairs to transmit there 
occur a crlf within. so the key/value just store #{

for example:

the store sequence is this

{key^-1
value^-#{
789CCBCA2E4EC9485348CC2ECE82D059C53960460E9005666465E74018C559D9
296919501A48A50000B5BE16913C000000
}

to lines separated by a tab for the key/value

is there any other compression which returns a string instead a binary?

You can just form a binary ... to get a string

Mind blank ..anyone got a routine to trim a particular character 
from the end of a string?  I want to remove trailing pipe characters

I could reverse the string and then parse it using a charset .. but 
that seems crude ( any reason why the parse direction can not be 
made an option ? )

That's one of the proposals that hasn't been implemented yet.

Why not use FIND with the charset?

All trailing pipe characters? Do you want to remove any other characters 
other than | ?

>> b: charset [not "|"]
== make bitset! [not bits #{00000000000000000000000000000008}]
>> find/reverse/tail tail "abc|||" b
== "|||"

looks like R3 to me!

I want to remove trailing |

For R2 you might need to complement the charset rather than using 
not.

I didn't know you could use find with a charset

>> b: complement charset "|"
== make bitset! #{
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
}
>> next find/reverse tail "abc|||" b
== "|||"
>> head clear next find/reverse tail "abc|||" b
== "abc"

FIND/reverse/tail doesn't work in R2.

I'll give it a go... ta

So you might need to do a bit of tweaking for the R2 version, but 
it's a start.

is this being backported to R2?

FIND/reverse/tail works in R2, but not with charsets. It's a bug.

as I thought ... no find with charsets

oh ... ooops

FIND works with charsets in R2, but the /tail option doesn't. It's 
a newly discovered (just now) bug.

just now ??

Yeah. By me, just now, while I was doing this experiment.

neat

Thanks :)

find/reverse tail a b only finds the first |

>> a
== "abcd|as|dsf|||||"

>> index? find/reverse tail a b
== 16

oops ...

no sleep :(

That's where the CLEAR comes in :)

By George I think I've got it!

BTW, I think trim/with/tail should actually do this .. but trim/with 
removes characters inside the string.

Yeah, for TRIM /with implies /all.

replace/all does the same ... so perhaps trim/with should be changed

>> map-each a [] [1]
** Throw Error: Return or exit not in function
** Where: map-each
** Near: return any [output make block! 0]

>> system/version
== 2.7.8.4.2

Darn, my bad. It's the [throw] function attribute. Don't worry, there's 
a way to reorganize the code so no RETURN is necessary.

Thanks for the report. I'll fix it in R2/Forward right away.

Here's a working version:

map-each: func [

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

 '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 [any-block! any-string!] "The series to output to" ; Not image!
	/local init len x
][
	; Shortcut return for empty data
	either empty? data [any [output make block! 0]] [
		; BIND/copy word and body
		word: either block? word [
			if empty? word [throw make error! [script invalid-arg []]]

   copy/deep word  ; /deep because word is rebound before errors checked
		] [reduce [word]]
		word: use word reduce [word]
		body: bind/copy body first word
		; Build init code
		init: none
		parse word [any [word! | x: set-word! (
			unless init [init: make block! 4]
			; Add [x: at data index] to init, and remove from word
			insert insert insert tail init first x [at data] index? x
			remove x
		) :x | x: skip (

   throw make error! reduce ['script 'expect-set [word! set-word!] type? 
   first x]
		)]]
		len: length? word ; Can be zero now (for advanced code tricks)
		; Create the output series if not specified
		unless into [output: make block! divide length? data max 1 len]
		; Process the data (which is not empty at this point)

  until [ ; Note: output: insert/only output needed for list! output
			set word data  do init

   unless unset? set/any 'x do body [output: insert/only output :x]
			tail? data: skip data len
		]
		; Return the output and clean up memory references
		also either into [output] [head output] (
			set [word data body output init x] none
		)
	]
]

I'm studying the RIP archive format and am wondering:


Why does LOAD allow binary "junk" at the end of a file, if it has 
a REBOL [] header, while it does not, when the header is omitted?

I don't think that LOAD allow binary "junk"

afair, LOAD allows REBOL scripts to be embedded in "junk"