AltME groups: search

GMail's not letting me post at the moment. Can someone post this 
reply for me


Jeff Kries, did a zine article called "Dining with Dynamic Interpreters"

http://www.rebolforces.com/zine/rzine-1-02/#sect5.which covers some 
of the same ground.

--Allen K

on 10/4/05, Glenn M. Lewis <[glenn-:-hometot-:-com]> wrote:

Hi all!

       Has anyone done anything like this for REBOL:
http://www.rubyquiz.com/quiz49.html

       If so, I would love to hear about it!  Thanks!
-- Glenn

in that case, you might get it a few times.. It kept giving me a 
javascript alert saying it was unable to send

I wonder if there can be some refinement to 'read so that when it 
reads a directory, it returns the full path for each file rather 
than just the file name.

At work we have an issue with supporting extremely large pst (outlook 
personal folder files).  The issue is that we wont to make sure these 
files get backed up when the sales force connects with the network. 
 Problem is that the M$ solutions built into Windows XP cause problems 
because if it sees a changed file it then trys to copy the entire 
file - I believe this to be the case with offline folders files and 
briefcase files also.  What I would like to see is a solution whereby 
only certain contents of the file detected as changed are copied 
over the network and update the master file.  It occurred to me that 
 this should be a capability of any X-Internet application that deals 
with significant file sizes.  So my question is - does anyone know 
of any method's, algorithms or such that currently do such work?

Paul:try talking to Graham as his mailing list reader only dls the 
new mail and saves to the master.Probaly a way to modify for your 
task ? Graham ?

I guess it's whether one wishes to write a generalised solution, 
or one to solve the problem at hand.

yep... in the case at hand it's a very good solution

though a printf type of solution would be handy :)

Graham  I think it is a slick solution to the question asked

Gabriele -- Is 'format something Carl has hinted RT have in development?
Otherwise, no reason it couldn't be a small community exercise...

Thanks.....Obviously, it'd be much faster to run as a native.

But it may be much faster to develop as a mezzanine -- and would 
be (with a little care) backward compatible with existing and older 
versions of REBOL.

What would be useful  is some agreement on the dialect......The RT 
could schedule work on the native while others do it mezzanine as 
a usual (and b/w compatible) prototype.

Pekr  that 1E-2 is a windows areifact , sure it should be fixed to 
be sane but the right place to fix it is the OS

it does not wound like a windows problem, have you tried the calculator 
? :-)

I know carl deivated a little bit from the IEEE spec in the past 
to make things a little more neewbie friendly

#
 is a digit, gives numbers like 123.45e67

how about using that for a pad-function?

if BCD was decided to be replaced by other solution, maybe we should 
ask Ladislav to comment a bit what will happen in that regard?

hmm, i see its a path. so [pad n ###.##] would work without quotes 
:)

maybe it should be a dialect

for a comma seperated list

Pekr: "I did not find an easier way, so I parse for E, then I distinguish 
the sign, the number -5 in above case, and then I compose the string 
:-)"
!> a: 123.456 reduce[to integer! a remainder a 1]
== [123 0.456000000000003]

Maybe the base for something better (dont know how easy that parsing 
is?)

Petr: <I wrote generalised solution in the past.>
Is that published?

Eric Long also did some nice work on a format.r function....I'm trying 
to find out if it is still available to the public (I have a copy 
of it)

Looks good, Volker.
One problem: more than 9 leading zeroes:
 epad1 0 10 0
** Math Error: Math or number overflow

(There is a much larger limit on trailing zeroes after the decimal 
sign)

tricky. hmm, money should have a bigger scope?

Nine *should* be enough for most people -- I didn't have a specific 
case in mind. I was just testing the limits.

i need to make a function wich can take n optional arguments, n can 
be from 1 to many arguments any help

Otherwise supply it as a block :)

supply it as a block
 is the proper solution I think

Question: <Unix Time>..   I found several functions on the web that 
show you how to create a unix-timestamp from a rebol time (now). 
 However, I am looking for the ability to convert a unix-timestamp 
back into rebol-time.  I started writing my own function but I think 
that leap-years might mess me up.  Anyone have any thought on the 
matter?

i guess you can refine that for conversion. a unix-timestamp is an 
integer based on some date?

The unix-timestamp could be any date/time.. so I think I have to 
work top down.. first find the year then month, day, hour, min, sec. 
    Kind of like building a binary number from a decimal.. top-down.

Little casio watches know all of this info (Year/month/day/time). 
 I suspect it is in a static table inside the watch.  I have been 
looking for something like this on the web.

I could easily build a table for month lengths.. it is the leap-year 
that I just don't want to think about.

That should be inbuild. i guess rebol stores internally just a big 
integer too.

note: "variable" is a global value still i get no results from this 
:(

I rarely change values by reference, only series/objects. values 
i simply assign new.
 f: func[variable][100]
 variable: variable 100
If not, i at least mark the word, like
 f: func[variable][ set variable 100]
 f 'variable

Its style, but in rebol i rarely see a function changes a word, so 
i am avoiding to be surprised.

O.K.
Thanks to everyone for their help.

I offer my final (not that it's the best) rendition of these conversion 
functions.


to-unix-time: func [
  "Create unix-timestamp.  Author: Gabriele_3-Aug-2002."
  date [date!] "Rebol-format date. (non-Milisecond type)."
][
  date/date - 1-1-1970 * 86400 + to-integer date/time
]

from-unix-time: func [

  "Create rebol-timestamp from unix-timestamp.  Author: Rebolers-Altme_2005."
  utime [integer!] "Unix timestamp."
][
  unixTimestampConstant + to-time utime
]  

-- OR an all-in-one --

unixTimestamp: func [

  "Rebol date to/from unix timestamp conversion.  Authors: Many rebolers.."

  varIn "Enter either a Date!type or Integer!type to convert to/from 
  unix/rebol."
][

   unixTimestampConstant: 1970-01-01/00:00:00           ;Reference.
   varOut: "ERR"

   if ((type? varIn) = date!) [                         ;from rebol, 
   to unix.

     varOut: varIn/date - 1-1-1970 * 86400 + to-integer varIn/time
   ]

   if ((type? varIn) = integer!) [                      ;from unix to 
   rebol.

     if (varIn >= 0) [                                  ;B.U.  (before 
     Unix.)
       varOut: unixTimestampConstant + to-time utime
     ]
   ]
   return varOut
]

John.

BIG TYPO on the last post.. 

unixTimestamp: func [

  "Rebol date to/from unix timestamp conversion.  Authors: Many rebolers.."

  varIn "Enter either a Date!type or Integer!type to convert to/from 
  unix/rebol."
][

   unixTimestampConstant: 1970-01-01/00:00:00           ;Reference.
   varOut: "ERR"

   if ((type? varIn) = date!) [                         ;from rebol, 
   to unix.

     varOut: varIn/date - 1-1-1970 * 86400 + to-integer varIn/time
   ]

   if ((type? varIn) = integer!) [                      ;from unix to 
   rebol.

     if (varIn >= 0) [                                  ;B.U.  (before 
     Unix.)
       varOut: unixTimestampConstant + to-time varIn
     ]
   ]
   return varOut
]

John.
BIG TYPO on the last post.. 

unixTimestamp: func [

  "Rebol date to/from unix timestamp conversion.  Authors: Many rebolers.."

  varIn "Enter either a Date!type or Integer!type to convert to/from 
  unix/rebol."
][

   unixTimestampConstant: 1970-01-01/00:00:00           ;Reference.
   varOut: "ERR"

   if ((type? varIn) = date!) [                         ;from rebol, 
   to unix.

     varOut: varIn/date - 1-1-1970 * 86400 + to-integer varIn/time
   ]

   if ((type? varIn) = integer!) [                      ;from unix to 
   rebol.

     if (varIn >= 0) [                                  ;B.U.  (before 
     Unix.)
       varOut: unixTimestampConstant + to-time varIn
     ]
   ]
   return varOut
]

John.

Is there a way to have small decimal numbers shown, as you write 
them, when converted to a string? Instead of this:
>> to-string 0.08
== "8E-2"
I would like the output to be "0.08".

wait a bit - will look into my flash disk if I have it here, otherwise 
I have it at my work on my PC ...

first one did not take into account 1E-2, simply a version, where 
there is no "." in it ....

On 6-October Volker posted this reply:


Pekr: "I did not find an easier way, so I parse for E, then I distinguish 
the sign, the number -5 in above case, and then I compose the string 
:-)"
!> a: 123.456 reduce[to integer! a remainder a 1]
== [123 0.456000000000003]

Maybe the base for something better (dont know how easy that parsing 
is?)

Maybe there should be a
n: form n
in the beginning to support more datatypes.

Louis, multi-user friendly!? What do you mean? That one user can 
lock a file for some time, so others can't access it? Or what?

Louis, in Core or View ? In View, you can read/write to the public 
cache.

This is VIEW-ROOT (the directory you selected during install, by 
default it is in a windows user profile directory).

When you click on an app from a rebsite, it is saved (by READ-THRU, 
PATH-THRU) into the public cache before running.
So, if it is your app, say at 
http://yoursite.com/app.r
then it could save prefs files to
path-thru http://yoursite.com/app-prefs.r
eg.
	save path-thru http://yoursite.com/app-prefs.r[my prefs data]

Geomol, I have written accounting software, and I would like for 
two or three people on a lan to be able to be intering data at once.

Louis: I solved ths by having a separate Rebol task running that 
manages the file in question. It's a simple databaseserver that accepts 
requests from various clients on a LAN using Rugby. Performance is 
surprisingly good.

Henrik, so the data from different computers is sent to your dbserver 
which saves the records one at a time?

I could... but I'm going out the door in a few minutes so it's going 
to have to be later this evening.

Yes, I did play around with Rugby a while back, but could think of 
any way to use it at the time. Now I have a use.

Louis, I'm doing something similar as Henrik with a DB, I made in 
REBOL a couple of years ago. A REBOL task is listening on a TCP port 
and is handling the multiuser functionality. The clients could update 
the data in the DB themselves, or a task could do that too. My DB 
(NicomDB) isn't a product yet, but I could make it a product, if 
you're ready to pay for it?

isn't it a bug that start: now wait 5 print (now - start) returns 
zero?

Isn't this a bit strange?
>> 3 // 3
== 0
>> 3 // 2
== 1
>> 3 // 2.6
== 0.4
>> 3 // 3.4
== 3.0

yes, it is, try MOD and MODULO functions, if you need a different 
behaviour

I guess, I was just surprised, that it worked with decimals. Then 
it can maybe be argues, if 3 // 3.4 should return an integer or a 
decimal.

the definition is as follows: if r = a // b, then a - r // b should 
be zero

other formulation: if r = a // b, then a = some-integer * b + r

In rebcode, I guess the upcode rem is remainder. It works a little 
different there:
set a 3
rem a 3

now a is 0. If doing this:
set a 3.0
rem a 3

then a is 3.0.

will it be possible to do easy types conversion with rebcode? regard 
me being stupid, but I regard following being  bug or at least inconsistence:

type? #{77}
== binary!    ; so no excuse it is a string later!

to-integer #{77}
== 119

to-binary to-integer #{77}
== #{313139}

If pure functions which serve datatype conversion work one way, it 
is imo inconsistent that it does not work the same way in the reverse 
mode ....a

If you want to convert a number to binary, number must be enclosed 
in brackets, to binary! [119] , not to binary! 119

This is not a workaround, that's in the documentation :)

To convert an integer into its binary value, pass it in a block

Kru: thanks a lot, adding to-block to the code solves it ;-)

Meh, just create a custom header...

Be careful of using the BCC feature with emails.  I sent mails at 
one time were the BCC recipients were viewable in the header information 
from within Outlook.  A disgruntled recepient then SPAMMED all who 
were BCC'd using my companies email address as the from Address.... 
Corporate Security didn't like me very much.

SEND does not take the recipients from the header, so it has no reason 
to preprocess it. if you include a BCC header, it's because you want 
it to pass... otherwise, why do you include it?

Seems there are two scenarios, both of them should not send the complete 
list of the BCC'd users in the mail message....
The 
Bcc:" field (where the "Bcc" means "Blind Carbon Copy") contains

   addresses of recipients of the message whose addresses are not to 
   be

   revealed to other recipients of the message.  There are three ways 
   in

   which the "Bcc:" field is used.  In the first case, when a message

   containing a "Bcc:" field is prepared to be sent, the "Bcc:" line 
   is

   removed even though all of the recipients (including those specified

   in the "Bcc:" field) are sent a copy of the message.  In the second

   case, recipients specified in the "To:" and "Cc:" lines each are 
   sent

   a copy of the message with the "Bcc:" line removed as above, but 
   the

   recipients on the "Bcc:" line get a separate copy of the message
   containing a "Bcc:" line.  (When there are multiple recipient

   addresses in the "Bcc:" field, some implementations actually send 
   a
   separate copy of the message to each recipient with a "Bcc:"
   containing only the address of that particular recipient.)"

Carl had talked about allowing some set-word functions but I'd rather 
have a full set of accessors (set get pick poke skip, etc)

in a specific context (not by default)

this allows you to remove the complexity of an API and integrate 
it within the normal flow of a language.

I understand that this raises some points as to the loading part, 
but within an application this is not an issue, it does not change 
REBOL itself, it changes the application of a type within a specific 
use.

In the blog and here I was in favor of adding property accessors 
to object types (think get and set handlers). There was much debate 
as to whether such a concept would be added to REBOL 3 - I was in 
favor.


If what you want is general redefinition of the actions associated 
with a type, what you are really asking for is user-defined types, 
and those have already been promised for REBOL 3.

Maxin, I like that there are two models for types, with different 
semantics:

- Datatypes: Classes with polymorphic methods handled by dynamic 
dispatch.

- Objects: Unique objects with methods directly associated, where 
you can emulate class-based or delegation-based systems at your whim.

The advantage of having two models is that you can balance efficiency 
versus flexibility. The only disadvantages are that there is a fixed 
set of datatypes (to be fixed with user-defined types), and that 
the usage patterns for objects are somewhat limited (which would 
be fixed by the get/set handler proposal if implemented properly).

Ladislav, another to add to the For list:

- Lets programmers used to imperative programming code using algorithms 
they already know, rather than having to adopt a functional style.

That may be one for the Against list as well, depending on your attitude 
towards such things.

The speed of datatypes comes from the fixed action list. It allows 
the dispatch to be a simple retrieval from a fixed offset into a 
function table, no lookup required. It is not the same thing as general 
class-based methods, which in a language with dynamically typed variables 
would need to do a lookup to figure out where to find the method 
to call, same as with instance-based methods.

A new deci! datatype for storing floating point numbers in BCD (Binary 
Coded Decimal) format.

hah! A percent datatype as well. :-)

Oldes, how spooky, I have a Queen song running in the background!

pekr, I think you're going to have to book a flight to paris... to 
much of what you and I have criticised about  for you not to show 
up.  ;-)

Make sure you comment on the relaxed lexical parsing.  I've been 
working around this one for a long time...but it may hold traps my 
giddy little mind is missing today.

I guess I'm getting annoying with all my comments  ;-)  this really 
is a subject I have been wishing for about 5 years and am constantly 
reminded how usefull extending lexical analysis would be.

Sorry to take so long to reply - I was sidetracked. I've put an alternate 
idea to relaxing the lexical rules on the comments. Take a look.

The idea is to add a LOAD directive to the PARSE string dialect. 
LOAD would treat the sequence of characters at the current position 
as a REBOL value, and then check it against a block-dialect rule. 
If it is not a valid REBOL value or if the check fails, the directive 
fails and triggers any appropriate backtracking. If you are not interested 
in checking the value, just use SKIP for the rule. If you want the 
value, use SET (or COPY perhaps?) before the LOAD to assign it to 
a word.

The problem with relaxing the lexical rules of the LOAD function 
is that REBOL can't handle natural language syntax, particularly 
punctuation. You would need to convert a word to a string to tell 
the similarity between "Hello" and "Hello,", at which point you are 
doing string parsing again, but slower.

Nonetheless, I can see the advantage to having a comma! datatype 
that would be a syntactical noop, so you can put one anywhere in 
REBOL code and it would be ignored by the standard dialects. Then 
we can give these commas meaning in our own dialects, or ignore them 
too.

I just posted a second vote with an example of how brian's idea actually 
is exactly like the load/extension.

the issue with learning Parse is that you have to implement everything, 
from scratch... just escaping strings is not trivial for many parse 
newcommers... so all the rest becomes such a mountain.

block parsing is easier, obviously, but then you need a lot of REBOL 
knowledge about binding, evaluation (and how NOT to evaluate ;-) 
 so even that becomes a bit hard for most newbies...

As Carl noted handling the different quoting possibilis  is going 
to be a problem, specially those that intefere with REBOL native 
lexical values.

It is very limited. After you get some input you want to be able 
to operate on the input as value. So alien should be just a flag 
in transition to a conversion to either a native value or an extended 
value.

The extended value should then belong to a class where you can define 
its MOLDIN and the operations that you can excercise over this value.

but user types are still a mystery... there is no information leading 
use to beleive we will be able to complement the in-memory data with 
a molded form,  which can be loaded too.

I think datatypes is not enough as charaterization. You still want 
to encapsulate the methods related to a type.

they can really all be one and the same, if the core system allows 
us to play with the internal accessors.   python does this beautifully. 
  you can make prototypes out of classes by implementing the accessors 
so they created a dict on each allocation, for example.

So this new lazy LOAD is kind of a PARSER of REBOL values + foreign. 
I think it maybe easier to provide  *rebol value rules*, so you can 
construct your PARSER as desired instead of triggering exceptions.

I look at this problem from two views.  wanting a forth style block 
editor and wanting to let a construction boss sit at home and edit 
his own data blocks.  The forth style CLI just needs strings...any 
string including something like  p [   putting an open bracket on 
a line by itself.  This can be done with string parsing and a dialect 
pass, but hey.  The other issue is a lot deeper.  I want the boss 
to type in $1,000,000 and not have to call me when load kakks and 
(when I'm not careful enough) breaking a script.

My reasoning is that the new feature is a mixed but I am afraid it 
doesn't really buy much.

which is what Brian and I are suggesting on the R3 blog.  brian's 
idea is to include LOAD within the parser as a directive.

btiffin, You can always make a parser that stops at an invalid value.