Re: Plans for Euphoria
D. Newhall wrote:
>
> It's only been a few hours and I already have a list of stuff I'm going to do
> with the code. Go figure. Anyways here's what I'm planning to add and would
> like feedback on whether it'd be a good or bad idea.
>
>
> perform
> -------
>
> Syntax:
>
> <variable> = perform <code> end perform
>
> Description:
>
> Keyword to allow pseudo-anonymous functions. It is essentially a
> self-contained
> body of code that is run once and returns a value.
>
> Example:
>
> -- Read all the text from the config file
> constant CONFIG_FILE_CONTENTS = perform
> sequence result
> object line
> line = gets(config_fn)
> while sequence(line) do
> result = append(result, line)
> line = gets(config_fn)
> end while
> end perform
>
>
> foreach
> -------
>
> Syntax:
>
> foreach <variable> in <sequence> do <code> end foreach
>
> Description:
>
> Same as:
> for i=1 to length(string) do
> char = str[i]
> if char ...
> end for
> Loops through each element of a sequence and allows you to use the variable
> to refer to that element. 95+% of all for loops in Euphoria do essentially
> this
> except with more typing. Element variable will most likely be read only to
> mirror
> the for loop variable.
>
> Example:
>
> -- Go through a list of people and make a list of the names of all adults
> sequence legal_adults
> foreach person in client_list do
> if person[AGE] >= 18 then
> legal_adults = append(legal_adults, person[NAME])
> end if
> end foreach
>
>
> sequence of
> -----------
>
> Syntax:
>
> sequence of <type> <variable>
>
> Description:
>
> Allows you to define a sequence where every element sequence must be of a
> specific
> type.
>
> Example:
>
> -- Get the name of a file and open it saving the file handle in a list
> sequence of integer file_handles
> integer fn
> file_handles = {}
> while length(file_handles) < 30 do -- Only 30 files can be opened
> fn = open(prompt_string("Name of next file:"), "r")
> if fn > -1 then
> file_handles &= fn
> end if
> end while
>
>
> Local Constants
> ---------------
>
> Syntax:
>
> [function|procedure] <name>(<arguments>)
> constant <name> = <value>
> <code>
> end [function|procedure]
>
> Description:
>
> I want to allow users to declare constants locally inside functions and
> procedures.
> This is something that I have constantly found limiting because I've wanted
> to declare sequence indeces as constants for use in one function but have to
> declare them for use in all following code. Plus, it's logical. Why can you
> declare local variables but not local constants since they are practically the
> same?
>
> Example:
>
> -- `distance` returns the distance between two points
> function distance(point a, point b)
> constant X = 1, Y = 2
> return sqrt(power(b[X] - a[X], 2) + power(b[Y] - a[Y], 2))
> end function -- distance
>
>
> Those are the only things I'm currently thinking about adding to the language.
> I've needed foreach so much that I wrote my own pre-parser to do it for me
> which
> has a big overhead. perform came to me during all those times I've defined a
> constant and needed to check every element of a sequence before setting it (if
> you can do it in Lisp why not Euphoria?).
>
> Besides trying to add stuff I'm going to port Euphoria to as many OSes as
> possible.
> My first platform is going to be the PowerMac so I can use it at work followed
> by hopefully either ZETA and/or the BSDs (ZETA would require more work but I
> don't have a OpenBSD or NetBSD computer right now). A Mac port is essentially
> guaranteed at this point because even if I don't have the time to do it I know
> other people that really want Euphoria on the Mac as well who would be quite
> happy to do it.
foreach is desperately needed. However, I see a problem with the way you explain
it.
For this to be useful, you need both an index, because you may have decisions
to make on the index, and the element value. So perhaps something like
foreach char [at idx [from start_index ][to somewhere ][by some_step]] in string
do
-- code where idx incrementing and char=string[idx] always
end foreach
You may forget idx if you don't need it. If some_step is negative, I'd expect
idx to start at length(string). Both char and idx would look like current
for loop indexes I bet (undeclared, local to the for loop).
Also, do you plan to care for the case where string gets modified in
structure during the process?
Local constants are just fine.
As for perform, why not just write:
constant my_computed_constant(perhaps with parameters)
-- some code here
end constant
This would make my_computed_constant a constant, initialised the first time
the routine code inside the block is run. Isn't that simpler?
CChris
|
Not Categorized, Please Help
|
|
