AltME groups: search

Knock your socks off?  No, perhaps just get rid of a lot of deep 
bugs completely, and enable us to move on to the next stage (applets, 
and applets written by people other than us).

There's something deep-down that is wider than View.

Run enough CGIs under Core and you'll get what seems to be the same 
sort of error.

Which is weird as each CGI is a separate incarnation (when not using 
fastCGI, anyway).

Agreed.  


But if I did not engage Graham, I would be ignoring an important 
part of our relationship, which is "aside" from the point you describe. 
 


You know guys……………its OK to disagree about stuff, have deep discussions 
about them, and even walk away disagreeing to the end.  Perhaps it 
is a cultural difference that causes people to worry about "upsetting" 
people.

like
  b: copy [] append/only b b copy/deep b

make object makes deep copies of all blocks. sure that crashes. crash 
should should be a softer?

base: [text (c) 40x20 effect [draw [text 20x0 (c)]]]

lay: [origin 0 space 1 across]
for i 16 31 1 [
	for j 0 7 1 [
		c: copy to-string to-char 8 * i + j
		append lay compose/deep base
	]
	append lay 'return
]
view layout lay

that's funny.  I've always used compose/deep [[()]]

'compose evaluates any parens in the block passed to it.  If you 
are passing 'compose a block containing blocks that contain values 
you would like composed then you need to use the /deep refinement 
of compose

; (i.e. 
test-case-test: make test-case compose/deep [
    ...
    test-result-formating: func [/local ed][
        ed: make (test-result)
        ...
    ]
]

I hope this is useful for someone

REBOL []

rest: func [s [series!]][skip s 1]

define-object: func [
	spec [block!] 
	/local 

  arg-spec ctx-spec object-name constructor-name predicate-name attributes
		spec-rule type-spec continue? w
][
	arg-names: copy []

	continue?: [none] ;used to stop parsing
	name-rule: [set w word! (insert tail arg-names w)]

 type-rule: [set w word! (unless datatype? attempt [get w] [continue?: 
 [end skip]])]

 spec-rule: [name-rule some [name-rule opt [into [some [type-rule 
 continue?]]]]]

	if any [
		not parse spec spec-rule
		arg-names <> unique arg-names
	][
		make error! "invalid spec"
	]

    object-name: to-string first arg-names
	constructor-name: to-word join 'make- object-name
	predicate-name: to-word join first arg-names '?
	attributes: rest arg-names

	arg-spec: copy []
	foreach itm attributes [
		insert tail arg-spec reduce [
			to-word join itm '-value
			either block? w: select spec itm [w][[any-type!]]
		]
	]

	ctx-spec: copy []
	arg-names: extract arg-spec 2 1
	repeat i length? attributes [

  insert tail ctx-spec reduce [to-set-word attributes/:i to-get-word 
  arg-names/:i]
	]

	;create constructor function
	set constructor-name make function! 

  compose [(reform ["Makes a new" uppercase object-name "object with 
  attributes" mold attributes]) (arg-spec)]
		compose/only [make object! (ctx-spec)] ;body

	;create predicate function
	set predicate-name make function! 

  compose [(reform ["Determines if value is a" uppercase object-name 
  "object"]) value [object!] /local types]
		compose/deep/only [
			either (attributes) = rest first value [
				foreach itm (attributes) [
					unless any [

      [any-type!] = types: select (arg-spec) to-word join itm '-value
						find types type?/word value/:itm
					][return false]
				]
				true
			][
				false
			]
		] 
]

a find/deep would be very useful... recursive searching of blocks 
and objects. it could allow you to find a value in large objects 
and blocks quickly

find/deep is long requested feature, but it was said as not being 
as trivial, as blocks can contain self-references etc ...

>> b: next next [1 2 3]
== [3]
>> head b
== [1 2 3]
>> head copy b
== [3]
>> c: [9]
== [9]
>> insert/only c b
== [9]
>> c
== [[3] 9]
>> d: copy/deep c
== [[3] 9]
>> head d/1
== [1 2 3]

So why does 'copy/deep don't ?

; Q1: copy/deep will give you new strings:
block: [none none none]
new-block: copy/deep replace/all block 'none {}

i guess you need copy/deep and poke ... copy pick ...

if the arrays have multiple dimensions, you need copy/deep. And if 
there are objects inside, those objects are not copied, then you 
need explicit work (copying all objects in a loop using 'make)

so, copy/deep, and, as volker suggests, you're likely to need to 
clone the objects too.

when you need a reduce/deep and there isn't one, what do you use 
instead?

reduce [ 'blah reduce [  to-word "desired-literal-word" reduce [to-word 
"deep-literal
-word"]] ]   ;ss this works...just talking to myself...nevermind

hmmn, reduce/deep or reduce/nested would be more elegant nonetheless.

is compose/deep/only an option? Also a reduce/deep would be short, 
if you need it.

trying to reduce a set of nested blocks ... compose/deep/only would 
not reduce the inner blocks, but leave them as they are...

compose/deep [ (a) [ (b) ] ] ; would work

I guess reduce/deep would not be very hard to implement...was just 
surprised there isn't one already...;-)

depends if ou code some themplate, then maybe compose/deep. if its 
data, maybe better reduce/deep.

sorry,
  compose/deep [ blah [  (to-word "desired-literal-word") ] ]

and to be defensive, compose/deep/only.

A first version:
reduce-deep: func[blk /local][
 blk: reduce blk
 forall blk[
  if block? blk/1[
   blk/1: reduce-deep blk/1
  ]
 ]
 blk
]

probe reduce-deep [ 1 + 2 [ 3 + 4 ] ]
probe reduce-deep [ a: [1 + 2] a/1] ; limitation, does not work

reduce-deep: func[blk /local][
 forall blk[
  if block? blk/1[
   blk/1: reduce-deep blk/1
  ]
 ]
 reduce blk
]
probe reduce-deep [ 1 + 2 [ 3 + 4 ] ]
probe reduce-deep [ a: [1 + 2] a/1] ; limitation, does not work
[3 [7]]
[[3] 3]

this breaks then, because inner blocks are evaluated first:
  a: 2 probe reduce-deep [ a: 1 [a]]

reduce-deep: func [
	block [block!]
	/local queue result file eval-state sub-result
][

	; Initialise
	queue: make list! 10
	result: reduce []


 ; Loop until we exhaust all unfinished blocks and we exhaust current 
 block.
	until [

		either empty? :block [
			; If finished this block, but more to process - add our
			; result to higher block result and set that block as current.
			if not empty? queue [
				set/any 'sub-result get/any 'result
				set [result block] queue/1
				insert/only tail result get/any 'sub-result
				queue: remove queue
			]
		][

			; Process current block item.

			either block? block/1 [
				; Save current level to process later,
				; set this new block as current.
				queue: head insert/only queue reduce [result next block]
				result: reduce []
				block: block/1
			][
				; Evaluate item.
				eval-state: do/next block
				insert/only tail result eval-state/1
				block: eval-state/2
			]
		]

		all [tail? block tail? queue]
	]

	; Return final result
	result
]

Or doesn't deep copy.

Chris was ahead of me there -- a working solution is
  block: copy/deep [do [a]]

You would need to copy/deep.

Should programmers concern about copy/deep when creating new objects 
from a spec? It seems strange that they do.

The easiest rule is to write make object! copy/deep spec instead 
of make object! spec

But is this appropriate, why not just have copy/deep by default on 
make object! ?

Perhaps it could come under 'Gotchas' -- it's not a bug so much as 
a 'feature' of Rebol values and contexts?  Just as much as 'copy 
does not automatically 'copy/deep...

regarding the behaviour: I think, that it might be optimal to have 
a function like CONTEXT deep copying by default with eventual /no-copy 
refinement?

My view is that Carl made this a conscious choice, knowing that advanced 
users could do their own copy/deep when they need to, and it won't 
come up most of the time anyway.

context: func [
    "Defines a unique (underived) object."
    blk [block!] "Object variables and values."
][
    make object! copy/deep blk
]

a similar issue exists for USE (use copy/deep spec) , and FUNC (solved 
by my CLOSURE)

closure, associative arrays, construct with deep copy, load on values 
that don't exist in system object, others. Some of the bugs that 
have been fixed are due to our need for more power, stable and predictable 
interpreter.

BrianH: do you think, that you could give a simple example using 
MAKE OBJECT! that would break using the deep copying variant of CONTEXT?

I can see, it must be hard to support these features on all platforms. 
It's rather deep down in the OS.

A way to go may be to make a deep analyse of, what a document is 
- what it consist of. There are basic elements like letters, dividers 
(<br/>), ... Then there are bigger elements (containers) like notes, 
tables, ... And we can talk about change of state like bold-on, bold-off, 
italic-on, italic-off, font change, etc. The containers should be 
strictly hierarchical. The basic elements and the containers will 
be represented in a sequence. The inside of a container is maybe 
also a sequence. Decisions should be made, if change of state can 
happen anywhere, or if going to one state and back is a container 
too. (I'm thinking loud here, you may notice.)

split-text: func [ txt n 
	/local frag result bl
][
    bl: copy []
    result: copy ""

    frag-rule: compose/deep [ copy frag (n) skip (print frag append result 
    frag) copy frag to #" " (if not none? frag [ print frag append result 
    frag ]
append bl copy result clear result) ]
    parse/all txt [ some frag-rule ]
    bl
]

compose/deep [ copy frag (n) skip (print frag append result frag) 
copy frag to #" " (if not none? frag [ print frag append result frag 
]
append bl copy result clear result) ]


looks suspicious to me - don't forget that your parens are there 
for two different purposes. My guess is, that you don't need compose?

I'm interested in that, too. :-) What I know is that Arno is making 
deep changes to the video driver framework to add backbuffering in 
the memory of the video cards. We think about AGG as a crossplatform 
rendering library, but Arno is considering the few simple drawing 
functions in Syllable. Things like line drawing are passed directly 
to the video drivers, and if a driver supports 2D acceleration, the 
draw is done in hardware by the video card. In our new framework, 
these drawing operations need to be able to work directly in the 
memory of the video card when necessary. It makes sense that crossplatform 
libraries are not suitable for this deep integration

The driver framework is going to be revamped with better use of the 
video card: backbuffering and integrated 2D drawing functions. The 
current discussion will also lead to deep integration of 3D. Both 
software rendering and hardware rendering are being worked on. This 
takes the kind of fundamental changes throughout the system that 
take many years on for example Linux, because no project has control 
over all the parts that need to be changed to coordinate everything 
in the best way possible

We have just a few rendering functions, but they're deeply integrated 
with the video driver framework, now with backbuffering. When we 
add more functions they may need the same deep integration for the 
best result, and then we can't use an existing library directly. 
Of course, you can still use existing libraries on top of our framework, 
but that's not the most efficient solution

Volker is suggesting this:

escape-metachars: func["escape metachars" s][
 replace/all s "'" "''"
 rejoin ["'" s "'"]
]

browse: func[url]compose/deep[

call rejoin ["screen -X screen -- " (view-root/bin/browser.sh) " 
" escape-metachars url]
]

I had the same problems with the last /view release 1.3 on my old 
Slackware machine.. the dependency libs where knowwhere to find... 
else then hidden deep inside gcc somewhere..

Cool stuff…


I don't find either QuickTime or Flash to be quite as pervasive as 
everyone would like to think.  We have found bugs amongst about 50% 
of the Mac users trying to display Flash media, and about 20% of 
PCs have some sort of trouble with QuickTime (not the least being 
they have not downloaded it yet).


The fact that Apple only supports Flash 4 is a pain.  I wish they 
could simple confirm their was no security holes, and that installation 
from all browns (like all four) was truly just a confirmation box. 
 Some times I will go to upgrade someone, and I will even be forced 
to reboot.  Deep shame.

Phil if you need an IMAP account on a server to test with, we can 
give you access to the one we set up to test Qtask's new Webmail 
interface.  The account contains lots of examples like large attachments, 
deep folders.  As we learn more, we fill it with ore examples.  Just 
shoot me a private message, and I will get you name and password.

I can't say I've been 'using' Rebol for long, but I've been playing 
for quite a while now.  I discover something new every time I open 
up the system.  It's too cool how RT has put something as wide and 
deep as the ocean into a cup, a cup with blinking lights no less.

Brian, right, so I have to workaround all the time, write slow code 
with deep parse recursions, and all those funny and nice things. 
Or, give up and pretend REBOL was PHP.

>> unmush/deep [rSfeCs[Nse[i1v5x10l50c100d500m1000]twCi~J[JnCN]Kk+elJn[alN-j 
N0]'jJn]pK+j]

== [r s fe c s [n: se [i 1 v 5 x 10 l 50 c 100 d 500 m 1000] tw c 
i ~ j [j: n cn] k: k + el j n [al n - j n: 0] 'j j: n] p k + j]

agree, COPY not needed - just an habit when I modify blocks, but 
here I did it two times wrong:
- the 'draw sub-block is modified, so it should be copy/deep 
- no 'copy needed with 'make, who does copy/deep

Volker: ( ) for actions - it will be a pain to use with compose/deep 
(needed because 'display evaluation is kept to minimal).

node-prototype: reduce [
    'type      0
    'namespace none
    'tag       none
    'children  []
    'value     none
    'parent    none
]

foobar: copy/deep node-prototype
foobar/type: 1
foobar/tag: "foobar"

bar: copy/deep node-prototype
bar/type: 1
bar/namespace "foo"
bar/tag: "bar"
bar/parent: :foobar

append foobar/children bar

text: copy/deep node-prototype
text/type: 3
text/value: "Some Text"
text/parent: :bar

append bar/children text

document: context [
    get-elements-by-tag-name: func [tag-name][
        remove-each element copy nodes [
            not equal? tag-name element/tag
        ]
    ]
    nodes: reduce [foobar bar text]
]

together with a bit unix for copy/deep test-directories and a diff 
later.

I'm having to create nested objects 7 levels deep ...

Let me understand this .. if I have an object that needs other objects 
more than 1 deep .. I can't use that to clone other objects without 
creating references instead of copies.

but note that your object's structure has to remain pretty static 
for any type of deep copy like this to be usefull.

deep copy

Ashley yes  !!! You noticed right I found them deep hided in the 
SVG format documentation on W3C dedicated pages to SVG format ....

Enjoy...REBOL, being light, is pretty deep wide and somewhat 'hidden' 
 :)

To everyone:

What characterize a good learning book? Do you prefer thick books 
with deep explanation and many examples, or do you prefer the thin 
book with the essentials? Look at your collection of technical book; 
about computer languages, OSs, databases or what you have. Which 
ones do you like, and which ones is no-good?

Sunanda;  I'm starting to take a deep interest in RitC.  But I have 
doubts.  Doubts that need to be squashed.  Sadly, Ontario (a fairly 
vast province) has standardised curriculum now.  It's all schools 
or no schools here.  I'm not a fan, the excuse was that some kids 
in some boards were getting sub-par educations, ignoring the fact 
that some boards were providing above-par educations and instead 
picking a middle-of-the-road bland education for all.

Gabriele, you might want to change the compose/deep call in the rewrite 
rules generated by rebcode-define to compose. The current version 
might trip up makers of rewrite rules, like it does in your first 
example rule above in the (either paren? ...) clause. Let any further 
composition be up to the rule makers, just in case they actually 
need to use parens themselves.

about the compose/deep, i think that's what most people will want. 
note that my either paren? has nothing to do with it (it is to handle 
parens in the expressions, not to workaround compose/deep)

how would compose without /deep help there?

Compose would just compose the parens directly in the production; 
compose/deep composes all of the inner parens inside the code as 
well.

>> compose/deep [([something (something)])]
== [something (something)]

if you have either or if or while or something like that in your 
production, you'll need /deep, and you'll be screaming if you don't 
have it ;)

OK then, I thought /deep meant /deep, my mistake :)

I thought you needed the extra compose since it was to be applied 
later, at rewrite time.

That makes compose/deep more useful than I thought.

Well finding an example is simple: Just convert to stack code and 
figure out when the stack would be used more than one deep between 
ops. That means more than one temp var. What we get for going to 
a register machine in a stack language :)


This would all be solved by a built-in USE directive with literal 
blocks that acts like USE in REBOL except only binding at rebcode 
creation time. It could be implemented as a built-in rewrite rule, 
changing the temporary variables to local variables, renaming if 
necessary. This rewrite would be done after the user-defined rewrites 
were done, but before the binding to the opcodes.


Let me think about how this could be implemented - I am late for 
a class.

Im following this project now for some years (because its java im 
not very deep into it) but just nice to see what it does -> http://www.processing.org/

Not deep enough toin Erlang to judge about problems, but if you can 
explain :)

maybe there is some setting for that, dunno .... Windows denerves 
me sometimes with so called - rought czech translation - delayed 
write was not successfull. Not sure how it happens, but somewhere 
deep in your profile there is a dir for such a feature, and if there 
is some file, you can see annoying messages each time Windows starts.

jaime, how deep can you go with it? I don't feel too inclined to 
dive into objC programming right now

I watched a program recently about crossing the street there.  The 
trick being to begin to cross, and keep your speed exactly the same 
at all times.  Which they demonstrated.  Two women holding hands 
(one was a westerner) cross the very wide street with motorcycles 
and mopeds and tiny cars whizzing by.  Scared me to simply watch 
it.


I suspect he paused, which would be something most of us that are 
not used to that might do.


It is a deep shame, as an absent minded professor, one of my big 
fears is being hit by a car.  I used to walk home at about 3:00 a.m 
almost every night.  My office and home were 3k apart.  The streets 
were completely empty, and so I felt somewhat safe from cars.  One 
night in deep thought I crossed the street (totally ignoring the 
state of the light) and was almost hit by a racing car.  Often, when 
I would arrive at home I simply could not remember walking at all, 
I was so deep in thought.

Also note that many join operations can be rewritten as sub-selects, 
as in:

	sql compose/deep [
		select * from a where [
			col < (
				sql [select max [col] from b]
			)
		]
	]

or:

	sql compose/deep/only [
		select * from a where [
			find (sql [select [col] from b]) col
		]
	]

Thanks guys, I've had a good look at both implementations and I've 
got ideas from both for a future full JOIN implementation; but at 
the moment my master/detail code has come along nicely. I've now 
enhanced the db-select function to accept statements in these additional 
forms:


 select * from master joins [select * from details where &id] on id

 select * from master joins [select * from details where [all [master-id 
 = &id master-date = &date]] on [id date]


which works exactly like a normal join with the following differences:

	a) It can only join one table to another

 b) Detail columns are always joined to the right of master columns

 c) Table.column prefixes are not supported so all columns in the 
 join must be uniquely named


Apart from that you get all the benefits of db-select (can replace 
* with specific column combinations, order and group by on the final 
result set, etc) *and* it's significantly faster than even the raw 
REBOL code example I gave before (as the SQL is parsed once within 
db-select and all loop sub-selects are done in-line).

I've also implemented “lookups” with the following form:

	select * from table replaces id with name
	select * from table replaces [id-1 id-2] with [table-1 table-2]


which performs a highly optimized db-lookup for each replaced value, 
but has the following restrictions:


 a) The lookup expects lookup tables in the form [id label other-column(s)]
	b) Only single-key lookups are supported
	c) A lookup that fails will replace the column value with none!


I'm now in the process of benchmarking these changes against sqlite 
to see where the bottlenecks (if any) are. Feedback on the design 
decisions is welcome.


While I was doing this, I was once again reminded how cumbersome 
it is to construct SQL statements (not just for RebDB, same goes 
for the other SQL protocols), as the heavy use of 'compose, 'rejoin, 
etc adds noise that reduces legibility. The design goal is to provide 
alternatives to:


 sql compose/deep [select * from table where [all [col1 = (val1) col2 
 = (val2)]]]


so for a start the 'sql function should probably accept a string, 
to allow:

	sql join “select * from “ table


type constructs; but this doesn't make the first example easier. 
So how about the 'sql function accept a block containing a string 
statement followed by a number of substitution variables, as in:


 sql reduce [“select * from table where [all [col1 = &1 col2 = &2]]” 
 val1 val2]


which makes things a bit more readable (and shortens the expression 
if longer word names are used multiple times). So the two questions 
here are:

	a) Is this a good idea?

 b) If so, what substitution character (& % $ @ other) will cause 
 the least conflict with REBOL and/or SQL?

wrt simplyfing the use of "noise"  ... why not just call compose/deep 
by default within the 'execute call of the client on ALL sql calls? 
 it could be a global option and IMHO the use of parens within the 
code is quite obvious and is used in many dialects. and its less 
cumbersome than to add the reduce word in your code, a string and 
then variables out of context of the sql statement.

Deliberate design that. The last line of 'sql is simply:

	buffer

not:

	copy/deep buffer


This is important when dealing with a large number of values as you 
want to pass a reference not double the amount of memory used with 
a redundant copy/deep! I'll add this "gotcha" to the documentation 
I'm writing.

Actually, there is no need to copy/deep buffer.
Just change 
	clear buffer
to
	buffer: copy []

there is no problem with integer, decimal, and none values regarding 
sharing.
Blob data is debased, which implicitly creates a new string.

Strings are normally loaded, which creates a new string. only when 
you use /raw, you are dependend on the sqlite.dll having a sane interface 
and not reusing the returned string data. You could add this as a 
possible gotcha.

clear buffer

 is also an optimization as it defaults to 32K values (make block! 
 1032 * 32) and I don't won't to reallocate it each SQL call. The 
 following benchmarks (Transactions Per Second) give some backround 
 to the design decisions I made:

	buffer				1744718
	copy buffer			282
	copy/deep buffer		76

	clear buffer			1144733
	buffer: copy []			824352
	buffer: make block! 32768	387


So the approach I took optimizes for large result sets by allocating 
a large buffer once up-front and then just referencing it thereafter.

depth is how deep links should be gathered for downloading. Values 
above 3 or 4 can be dangerous. :-)

I think, PS is good for printing too. I haven't looked deep into 
it, so I can't say, if PDF is enough. Does printers understand PDF 
directly, as they do PS? If not, PS is the way.

Yes, i mean that cauto-onfig-script. IIRC  it was not accessible. 
But digged not very deep.

I haven't delved deep enough to understand if this'd be better written 
as a Cheyenne handler, though that would require forking the cgi 
script, which for the time being, also has to run under Apache.

what was the mention of deep copying of function?

R3 now deep copies by default... but its at mezz so you can revert 
if you need.

Thanks. Affected tickets modified accordingly. Here's the new criteria 
for applying the "not a bug" severity:

- If the ticket is a Bug or Issue and the behavior is by design and 
intention, it gets marked as "not a bug" and dismissed.

- If there is some question, comments are added saying so and the 
ticket is marked as "waiting" or "problem", depending on whether 
the question is more of a group thing or a Carl thing, with some 
leeway either way.

- If the ticket isn't deep enough it will be rewritten to reflect 
the real problem, or maybe a new ticket will be made.

- If the ticket is too broad or general, it will be marked "problem" 
and split into multiple narrower tickets.

I've started working on the "POST data lost when session times out" 
issue, but that requires some deep changes in the RSP engine, so 
this enhancement is currently postponed.

There's a lot to that.  I was kind of using the DevCon '05 as a model 
(my fav so far) where all the info is knee deep on the front page 
with more detail on sub pages.

rebol [
	title: "explore.r"
	version 1.0
	date: 2009-03-19
	author: "Maxim Olivier-Adlhoch"
	copyright: "2009(c)Maxim Olivier-Adlhoch"
	tested: "win xp"

 notes: "Add any dir to the dirs block.  options are self explanatory"
]

dirs: [
	%/C/ []
	%"/C/program files/" [expand]
	"%tmp%" [label "temp dir"]
	"" [ label "my documents"]
]

blk: []

explore-dir: func [path expand? /local cmd][

 call/shell rejoin [" explorer " either expand? ["/n,/e,"]["/n,"] 
 path ]
]

ctr: 1
foreach [item opts] dirs [
	ctr: ctr + 1
	expand?: found? find opts 'expand
	label: any [select opts 'label to-local-file item]
	append blk compose/deep [ 
		pad 20 
		(to-set-word setw: rejoin ["dir" ctr]) check (expand?) 
		pad 20 

  btn 200 left (label) [ explore-dir to-local-file item get in (to-word 
  setw) 'data ]
	]
	append blk 'return
]


view layout compose [across vtext right "expand?" vtext "folder" 
 return (blk)]