World: r3wp

I know what you mean, as appending none to a block does add a "none". 
 Though APPEND [A B] NONE currently seems to do the same thing as 
APPEND [A B] 'NONE.  I would be interested to know the side effects 
of saying APPEND [A B] NONE gave [A B] while APPEND [A B] 'NONE gave 
[A B NONE].

What you said to do is append none to a string. By your reaction, 
you wanted to append an empty string to the string. That means this 
(assuming that you don't know that the none is there):
>> append "mystring" any [none ""]
== "mystring"

The need for none to be explicitly converted to other values, rather 
than implicitly, is an intentional design choice that has been applied 
to a great deal of R3. It is not an error.

It wasn't Fork , it was DavidE

Sorry, you're right, I was using Fork's example code.

As for the side effects of not appending none, Fork, that woulld 
ruin blocks that contain fixed-length records of positionally accessed 
data, a common useage pattern. If nothing is appended, the positions 
of the subsequent stuff would be off.

<<Note: Though it's weird to be called Fork (blame Reichart, he made 
this account for me)... I think it would be more confusing with another 
Brian.>>

I see your point.  Hmm.

Ever consdier an operator which converts none! types into none words 
and passes everything else through unmodified?

>> join "a" any [ find "x" "abc" copy "" ]
pretty common idiom (though, you don't need of the copy)

Why would we need to convert #[none] to 'none ? The value #[none] 
is more useful; because of ANY and DEFAULT. Neither of those will 
convert 'none to a default value, but they will convert #[none].

when seeing the "NONE stuff" discussed, the expression like


 parse "123" [(r: copy "result: ") copy s any "x" (append r s) to 
 end]


looks as the situation, where the result obtained from R3 is more 
useful.

>> join "a" any [ find "x" "abc" copy "" ] 

I will use this idiom, thanks. 

But still I think that having "idioms" in programming language  is 
a  symptom of something not really correct.

All programming languages are inherently limited. You have a limited 
number of built-in words and concepts. Because of this there will 
only be a limited number of concepts that can directly be supported 
by the language without combining words. To form other concepts, 
you need to combine words - aka composing functions. As more concepts 
are shared, the best combination of words to express them will be 
shared and refined as well. These combinations of words are idioms. 
Idioms are not a symptom of something which is not correct, quite 
the opposite. The ability to form idioms is a sign of a healthy language 
that is more powerful, able to handle more complex concepts. Idioms 
are always an inherently good thing.

Ladislav, for PARSE yes.

The trick for language design is not to get rid of idioms, but instead 
to do whatever you can to make possible to make simple idioms more 
powerful. This is usually done by making the different parts of the 
language fit together better, and and more flexibly. You get more 
flexibility by making the core concepts simpler, and then making 
them as widely and consistently applicable as you can without breaking 
them. Consistency is key here, and not just key in a positive way. 
More consistency means that you can fit more of the parts of the 
language together better. However, you have to limit consistency 
to places where it makes sense, and has real benefits. False consistency 
can get in your way.

Added bug#1626 (LENGTH?) and bug#1627 (APPEND and INSERT) about #[none] 
passthrough. #1627 was added to be dismissed.

>> append #{} 15
== #{3135}
>> append #{} "15"
== #{3135}


Why if I append an integer to a binary it is first converted to an 
ascii string?

IMHO it should be like this:
>> append #{} to-char 15
== #{0F}

R3 has the kind of behaviour you want. R2 won't be changed as it 
will break many scripts. I agree with you that R3 method is more 
logical.

It is consistent with to-binary:
    to-binary 15
    == #{3135}
    to-binary "15"
    == #{3135}

Yes, R3 seems more logical !

>> append #{} 10
== #{0A}

This could be handy :

>> head insert #{} [1 2 3 4]
** Script error: invalid argument: [1 2 3 4]
** Where: insert
** Near: insert #{} [1 2 3 4]

Yes. If it's not in CureCode, you should put it there.

R3 has that behavior as well. Don't know how likely it would be to 
add to R2, but if it is added with R3 behavior it would be helpful.

Or rather, R3 has the ability to insert blocks into binaries, not 
the ability to complain about it and trigger an error as in your 
example :)

>> head insert #{} [1 2 3 4]
== #{01020304}

We don't yet have a CureCode project for R2.

Alternative way R2/R3
>> to-binary to-tuple [1 2 3 4]
== #{01020304}

Nice! But you have to do it in sections of 10 or less, due to the 
length of tuples; not a complaint, a gotcha to look out for.

12 for R2

11, sorry

now i'm wrong, 10

... look at the red light.
FLASH !!!!!!!!!!!!!!!!!!!

Hello - hope someone can find the newbie mistake I'm making here. 
 Wanted to use REBOL to tackle a need to get data from Salesforce 
using their SOAP API.  New to SOAP, WSDL and Salesforce, but using 
SoapUI mananged to do this POST (edited only to hide personal info):

POST https://login.salesforce.com/services/Soap/u/19.0HTTP/1.1
Accept-Encoding: gzip,deflate
Content-Type: text/xml;charset=UTF-8
SOAPAction: ""
User-Agent: Jakarta Commons-HttpClient/3.1
Host: login.salesforce.com
Content-Length: 525


<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:urn="urn:partner.soap.sforce.com">
   <soapenv:Header>
      <urn:CallOptions>
         <urn:client></urn:client>
         <urn:defaultNamespace></urn:defaultNamespace>
      </urn:CallOptions>
   </soapenv:Header>
   <soapenv:Body>
      <urn:login>
         <urn:username>[jort-:-xxxxxxxxxxxxx-:-com]</urn:username>

         <urn:password>xxxxxxxxxx78l6g7iFac5uaviDnJLFxxxxx</urn:password>
      </urn:login>
   </soapenv:Body>
</soapenv:Envelope>

and get the desired response:

HTTP/1.1 200 OK
Server: 
Content-Encoding: gzip
Content-Type: text/xml; charset=utf-8
Content-Length: 736
Date: Fri, 02 Jul 2010 20:32:14 GMT


<?xml version="1.0" encoding="UTF-8"?><soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns="urn:partner.soap.sforce.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><soapenv:Body><loginResponse> 
......

Then using SoapUI I am able to send a successful Logout message.


Using REBOL 2.7.7.3.1, I created an "upload" string containing the 
POST block above without the "POST " at the beginning, set my url 
to:

>> url
== https://login.salesforce.com/services/Soap/u/19.0

and tried this:

>> response: read/custom url reduce ['POST upload]

but consistently get a Server 500 error:


** User Error: Error.  Target url: https://login.salesforce.com:443/services/Soap/u/19.0 
could not be retrieved.  Se
rver response: HTTP...
** Near: response: read/custom url reduce ['POST upload]

For completeness, here's the upload value:

>> print mold upload
{https://login.salesforce.com/services/Soap/u/19.0HTTP/1.1
Accept-Encoding: gzip,deflate
Content-Type: text/xml;charset=UTF-8
SOAPAction: ""
User-Agent: Jakarta Commons-HttpClient/3.1
Host: login.salesforce.com
Content-Length: 525


<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:urn="urn:partner.soap.sforce.com">

   <soapenv:Header>
      <urn:CallOptions>
         <urn:client></urn:client>
         <urn:defaultNamespace></urn:defaultNamespace>
      </urn:CallOptions>
   </soapenv:Header>
   <soapenv:Body>
      <urn:login>
         <urn:username>[jort-:-researchpoint-:-com]</urn:username>

         <urn:password>metrics12378l6g7iFac5uaviDnJLFVprDl</urn:password>
      </urn:login>
   </soapenv:Body>
</soapenv:Envelope>}

Would appreciate any help you can give!

Why is there a one byte difference in the cotent-lengths?

And why is the soap body formatted that way?  Anytime I've had to 
send soap messages I had to strip out all unnecessary newlines etc 
from the soap body.

Hi Graham - sorry to be dense - how did you determine there was a 
1 byte difference in length?


Re. the soap body format, I just copied/pasted from the SoapUI screen....I 
will have to test and see if the newlines are the problem - Thanks 
for the suggestion!

sorry ... I misread it.

But ... the saleforce.com api also allows http login for testing 
thru proxies.  I suggest you test against that and use wireshark 
to trace the transaction.

Maybe the soapui screen is just reformatting for readibility and 
it's not actually what is sent.

See also the soap response you posted ... has no newlines, tabs etc

I also see a 1 byte difference in length - all I did was open Rebol 
and use length? - and it returned 526.

Oh yeah .. that's what I did :)

Just forgot ...

LOL

Thought I'd see this question asked before, but couldn't find it. 
 Using makdedoc2 to create a simple table, I cannot figure out how 
to present an empty cell.  Following the table example from http://www.rebol.net/docs/makedoc/fastmd.html:

===Table

\table

Column 1

Column 2

Column 3

=row

Row 1, col 1

Row 1, col 2

Row 1, col 3

=row

Row 2, col 1

Row 2, col 2

Row 2, col 3

/table


But an extra blank row will not give you a blank cell - consequently, 
my cell values are shifting to the left to fill in the empty cells.


Is there a solution to this?  Many thanks in advance for your help!

Can't test, but what happens when you use ""?

Hi Henrik!


the "" hold the place, so that my cells no longer shift over, but 
that value gets displayed in my output as a pair of double quotes, 
when I'd prefer to see a blank.  This output is headed to an Excel 
spreadsheet, for what that's worth.

are the values really separated by commas in the syntax?

(I don't remember)

commas not part of the syntax.  In this example, they are part of 
the cell value itself.  So the first cell displays "Row 1, col1"


blank lines are what separates one cell value from the next, as far 
as I can tell.