World: r3wp

BrianH: I won't be able to make an example (and maybe it's not possible 
now) .. but I was asking because of this maybe stupid idea for "poor 
mans continuations" 


that are built on top of language as a lib (because of rebol powerfull 
treatng of itself): 


- you have a function >>myfunc: func [ a /local b ] [ b: 5  return-cont 
 a + b ] <<
- at runtime when function is called you reach return-cont which:

  - you collect all it's local words and their values into a block 
  (with stack/args etc)  for example [ a 1 b 5  ]

  - you also get current position of a running block (already seems 
  to be possible with stack/block + next )  [ a + b ]

  - you generate a function at runtime that has >>does [a: 1 b: 5 a 
  + b ]<<
  - you return taht function as a normal return value.
this means that this would be possible:
>> cont: myfunc 5
... do some stuff
>> cont 
== 6

any thoughts :) ?

There is one programming language with unit such conversions built 
in, but the language needed to be built around them. We can only 
emulate that in REBOL with functions.

- you generate a function at runtime that has >>does [a: 1 b: 5 a 
+ b ]<<
That is the slow part, and for some code exponentially slow.

Continuations don't work too well in languages with modifiable state 
- look at Icon for the worst example of this.

yes, I know that this would not be anywhere near natively fast.. 
but do you think this would be theoretically possible?

I have to admit I don't know that much about continuations, just 
the surface stuff

do you need continuations to have coroutines?

The generation of a continuation function would only be possible 
with system support, including internal state of natives. Without 
system support it would only be possible for continuations at the 
top level of a function's code (no nested blocks).

aha yes.. you are right.. inside a loop or other nesting this all 
breaks ..

do you need continuations to have coroutines?

 It depends on the system - in some cases it is the other way around.

funy: func [spec body][
	funco spec append copy [
		probe words-of stack/func 1 
		probe stack/args 1
	] body
]

>>foo: funy [x y z][x + y + z]
>>foo 1 2 3
[x y z]
[1 2 3]

In theory you could have continuations in rebcode, using the pseudo-thread 
method.

something like coroutines or other ways to make cooperative multitasking 
would be really nice to have ... "real" threads / processes are just 
one side ot he concurrency IMHO

Steeve, in theory that could work but I've been having trouble getting 
stack/func 1 to work - I think it's buggy.

cool Steeve, I was trying but didn't succeed at that

Janko, you can have cooperative scheduling of real threads - all 
they have to do is cooperate, as long as a thread can pause.

in fact stack/func is useless, because u can use the variable spec 
to get parameters

same result with:

funy: func [spec body][
	funco spec append compose/deep [
		probe [(spec)]
		probe stack/args 1
	] body
]

Only if you know which function you are calling from. I figured out 
the stack/func 1 bug.

but isn't the main difference that coroutines can be made very light 
.. you can have 1000s of them, and with threads creatin of them and 
mem. is more expensive?

Only if the system is designed to support them. If not, then they 
are slower.

Erlang and stackless python which can create >100.000 "processes" 
surelly does not use uses native threads for this ... I imagine it 
has M(green processes) / N (OS processes)

(Erlang that is ... stackles py I think uses just green threads)

by system you mean the rebol runtime in our case or the OS?

The REBOL runtime.

aha, yes that I agree fully .. that's why I was hoping the makers 
would think about some form of lighter runtime threads/processes 
whatever they are :)

here is an example of how we could use the unit system if it where 
implemented.


ANY unit moniker could be used, and in fact the switch tables below, 
could be context-specific and dialect-configured, adding to the DSL 
power of  REBOL... 


ex: dm could be decimeter or deutchmark (the later should be DM anyways, 
no?) , based on context, the convertion units could mean either or... 
with a default convertion table explicitely defined.

a simple func could let us append or change the conversion tables 
used throughout the system.  


Imagine if the VID would use units directly.  you set your locale 
(or get it from OS) and see values as they should be for your locality.


unit-convert: func [
	in "unit value to convert"
	to-moniker "to what unit type to you want to convert to"
][
	; note: incompatible types set 'IN to value none
	in/value: switch to-moniker any [
		switch in/moniker [
			{mm} [
				[
					{m} [in / 1000]
					{dm} [in / 100]
					{cm} [ in / 10]
					{'} [in * 0.0032808399]
					{"} [in  * 0.0393700787]
				]
			]
			{"} [
				[
					{m} [ in * 0.0254]
				]
			]
		]
		; empty result set, switch on nothing
		[]
	]
	in/moniker: to-moniker
]


unit-convert 100mm "m"
== 0.1m

unit-convert 100" "m"
== 2.54m

unit-convert 2mm  {'}
== 0.0787401575'

Change /moniker to /unit.

just a label...  now find the more powerfull idea I added here  not 
readily obvious... but you should get it....  ;-)

It still wouldn't replace money!, because the international standard 
syntax for specifying money uses a prefix, not a suffix.

notice the inch handling ?

;-)

it would, if instead of switch functions we'll use parse

it's the same idea, of having computed/values (with accessors)

But Carl don't like the idea

no steeve, at that level, its the rebol lexical analyser.

we can't just but-in parser rules.  its a core level of the interpreter.

you can just use load/next in a parser rule... I've done it often 
and it works.

it has nothing to do with the lexical analyser, we just need a new 
data type, to construct computed variables

internally, those variables would be sort of objects with methods

but I would like a way to get invalid tokens loaded as invalid values... 
that way I'd use block parsing .  so far, I've been using string 
parsing about 90% of the time.  its a shame, since I'm loading stuff 
much more slowly than rebol could let me do it using its native loading.

but behaving like regular variables

we are talking about representing the lexical form of unit-like values 
here steeve, not the custom datatypes.

all OOP with accessors do exactly what you want.

i'ts the same thing, you just need a specific method (ie. dispalyed-as) 
for the computed vars

yes i can do it with OOP, but i don't want to have to code stupid 
things like my-var/set, my-var/get

But Carl don't like the idea

 - as I recall, changes in object semantics have been put off until 
 later, not permanently.

 those variables would be sort of objects with methods

  that is exactly WHAT an accessor-enabled variable IS  , also known 
  as a datatype   ;-)

the accessors are just events... you have to know WHEN and WHAT to 
do with a variable...   It would be fun if generic objects allowed 
us to set accessors per instance, just like python allows it, but 
alas, Carl doesn't realise just how often this could be used to simply 
a vast array of code.

simply = simplify