OpenEuphoria

2. Re: named array

• Posted by BRyan Sep 02, 2013
• 2286 views

Because this forum is not a Ruby or Erlang forum; you will have to describe what you are trying to accomplish in Euphoria.

If you are trying to use maps a developer maybe able to help you.

You can not just say Euphoria's maps don't suit me because of side effects and not explain what you mean by that statement.

4. Re: named array

• Posted by andi49 Sep 02, 2013
• 2209 views

Hi

I'am not sure if my english is good enough, but i will try to explain somethings. If someone knows it better i will be happy if he/she helps with this.

What you do in ruby is very different to what you do in Euphoria. In Ruby you give an 'Object a Name' this name is only valid in the context of the object.

object = { :x => 100, :y => -200, :z => 300 }  
puts object[ :z ]  
object1= { :z => 100, :y => -200, :x => 300 }  
puts object1[ :z ]  

include std/console.e -- for any_key() 
enum X, Y, Z -- I need to name coordinates externally (in public? not very useful)  
sequence Object = {0, 0, 0} -- I can't say Object = {}, because sequences not able to auto-expand  
Object[X] = 100  
Object[Y] = -200  
Object[Z] = 300  
puts(1, sprintf("%d",Object[Z])&"\n") 
 
sequence o2= {100,-200,300} 
puts(1, sprintf("%d",o2[Z])&"\n") 
 
sequence o3={} 
o3 &= 100 
o3 &= -200 
o3 &= 300 
puts(1, sprintf("%d",o3[Z])&"\n") 
 
sequence o4={} 
o4=append(o4,Object) 
o4=append(o4,o2) 
o4=append(o4,o3) 
 
puts(1, sprintf("%d",o4[X][Y])&"\n") 
 
print (1,o4) 
puts(1,"\n") 
 
 
sequence o5={} 
for i = 1 to Z do 
	o5=append(o5,o4) 
end for 
 
puts(1, sprintf("%d",o5[X][Y][Z])&"\n") 
 
print (1,o5) 
puts(1,"\n") 
 
 
any_key() 
 

What i try to say is, you are comparing different Programming paradigm, this will not really work.
From the Programming paradigm, you maybe better compare Euphoria to 'C' or 'Pascal' not to an OO Language (if I'am wrong feel free to correct me).

Andreas

6. Re: named array

• Posted by DerekParnell (admin) Sep 02, 2013
• 2180 views

What 'side effects' are a concern to you? Using the map library it's simply ...

include std/map.e 
 
map Object = map:new() 
 
map:put(Object, 'X') = 100 
map:put(Object, 'Y') = -200 
map:put(Object, 'Z') = 300 
 
puts(1, map:get(Object, 'Z'))  
 

Or if the 'ugliness' of showing all the detailed assignments is too much for you ...

Create a map helper library such as ...

include std/map.e 
 
function mapset(sequence vals) 
    object o 
 
    o = map:new() 
 
    for i = 1 to length(vals) do 
       map:put(o, vals[i][1], vals[i][2]) 
    end for 
 
    return o 
end function 
 
function mapget(object o, object k) 
    return map:get(o,k) 
end function 

Then use it to emulate for favourite slow interpreter, such as Erlang or Ruby ...

include maphelp.e 
 
object Object = mapset( {{'X',100}, {'Y',-200}, {'Z',300}}) 
 
puts(1, mapget(Object, 'Z'))  
 

8. Re: named array

• Posted by TheresNoTime Sep 03, 2013
• 2152 views

A side effect is that the function is changing something outside of themselves. Functions without side effects named "pure functions". Sometimes side effects are necessary, because the display and the hard drive is also part of the outside world. However, it should by all means avoid impurity, if possible. When I'm going to use the maps, I can not write a pure function. Example:

include std/map.e 
include std/math.e 
 
map JohnSmith = map:new() 
map:put(JohnSmith, "Expenses", {1000, 2000, 3000, 4000}) 
 
function getSumExpenses(map Client) 
	sequence Expenses = map:get(Client, "Expenses") 
	return sum(Expenses) 
end function 
 
function getHistory(map Client, integer Months) 
	sequence Expenses = map:get(Client, "Expenses") 
	return head(Expenses, Months) 
end function 
 
function getSumHistoryExpenses(map Client, integer Months) 
	map:put(Client, "Expenses", getHistory(Client, Months)) 
	return getSumExpenses(Client) 
end function 
 
puts(1, "Sum of Expenses from January to March = ") 
print(1, getSumHistoryExpenses(JohnSmith, 3)) 
puts(1, "\nAll expenses, must be present up to April = ") 
print(1, map:get(JohnSmith, "Expenses")) 
puts(1, "\nFAIL!!! Map has changed forever, even though we changed it inside the function.") 

10. Re: named array

• Posted by TheresNoTime Sep 03, 2013
• 2212 views

Very nice idea. I tried to do something similar, but with the sequences. It turned out well, I'm ALMOST satisfied. Today I made ​​the feature even closer to the way of Ruby. It turned out that Ruby keeps the symbols (I remind you that a symbol in Ruby is something like a key of the map in Euphoria) within a single table, shared by entire program. This can cause problems when the table is full. However, I find it hard to imagine a scenario where this happens. If the symbols are generated in some way, this is extremely bad programming style. I tried to do something similar to symbols possible. I hope it will be helpful not only to me. Мemory usage isn't effective, but it is the price paid for the convenience. I hope such "rubinish" thing will help someone else.

narr.e

include std/map.e 
 
map Symbols = map:new() 
integer Index = 0 
 
function nextIndex() 
	Index += 1 
	return Index 
end function 
 
export function new() 
	return repeat(0, Index) 
end function 
 
export function get(sequence Narr, sequence Symbol) 
	return Narr[map:get(Symbols, Symbol)] 
end function 
 
export function put(sequence Narr, sequence Symbol, object Value) 
	integer Index = map:get(Symbols, Symbol) 
	if Index = 0 then 
		Index = nextIndex() 
		map:put(Symbols, Symbol, Index) 
	end if 
	if length(Narr) < Index then 
		Narr &= repeat(0, Index - length(Narr)) 
	end if 
	Narr[Index] = Value 
	return Narr 
end function 

t_narr.e

include std/unittest.e 
include narr.e as narr 
 
sequence Narr1 = narr:new() 
 
Narr1 = narr:put(Narr1, "X", 100) 
Narr1 = narr:put(Narr1, "Y", -200) 
Narr1 = narr:put(Narr1, "Z", 300) 
 
test_equal("", 100, narr:get(Narr1, "X")) 
test_equal("", -200, narr:get(Narr1, "Y")) 
test_equal("", 300, narr:get(Narr1, "Z")) 
 
Narr1 = narr:put(Narr1, "X", 1000) 
Narr1 = narr:put(Narr1, "Y", -2000) 
Narr1 = narr:put(Narr1, "Z", 3000) 
 
test_equal("", 1000, narr:get(Narr1, "X")) 
test_equal("", -2000, narr:get(Narr1, "Y")) 
test_equal("", 3000, narr:get(Narr1, "Z")) 
 
sequence Narr2 = narr:new() 
 
Narr2 = narr:put(Narr2, "Velocity", 543.902) 
Narr2 = narr:put(Narr2, "X", 0.1) 
Narr2 = narr:put(Narr2, "Y", -0.2) 
Narr2 = narr:put(Narr2, "Z", 0.3) 
Narr2 = narr:put(Narr2, "Name", "Bullet") 
Narr2 = narr:put(Narr2, "XYZ-1", {narr:get(Narr1, "X"), 
                                  narr:get(Narr1, "Y"), 
                                  narr:get(Narr1, "Z")}) 
test_equal("", 0.1, narr:get(Narr2, "X")) 
test_equal("", -0.2, narr:get(Narr2, "Y")) 
test_equal("", 0.3, narr:get(Narr2, "Z")) 
test_equal("", "Bullet", narr:get(Narr2, "Name")) 
test_equal("", 543.902, narr:get(Narr2, "Velocity")) 
test_equal("", {1000, -2000, 3000}, narr:get(Narr2, "XYZ-1")) 

Please give advice on how to improve ways to use narrs. I mean string "include narr.e as narr". Why I needn't use "as", when including "map.e"? Second question: How to implement calling of narr:put without assignment? For example: Narr = put(Narr, "Name", "Joe"). When I using maps, I needn't assignment.

12. Re: named array

• Posted by TheresNoTime Sep 03, 2013
• 2140 views

I love Euphoria. It is very easy and convenient. All of these languages ​​have too little of procedural for my taste. However, I'm interested in other languages​​, because it broadens the mind. If I had not watched a few video lectures on Ruby and Erlang, I would not be able to solve my problem on Euphoria.

You are not quite right. It is possible to program procedurally in a functional language, it is possible to program functionally in a procedural language. For example, I was doing something similar to the memoization on Euphoria. Choice of language - is the choice of balance. If I can easily realize code, that I need often, I can not accept the fact that some of the rarely required capabilities are implemented difficult (wraps, crutches, external libraries).

Have you heard about the law of 80-10-10? If I am satisfied with 80, the foolish go to another language, because it has 10. Yes, it does have the 10, but it has its own 80, which are unusual to me. If I need the first 10, I think of a crutch. If I need a second 10, then I'll use C++ via the wrapper.

I hope, Euphoria withstand this load. My program is not very complicated and does not handle huge amounts of data. In addition, they occasionally (quite often) become unnecessary and should be eaten up by the garbage collector.

14. Re: named array

• Posted by mattlewis (admin) Sep 03, 2013
• 2101 views

Then I would agree that I don't understand the point. I updated the code you posted:

include std/unittest.e  
include std/map.e 
 
include narr.e as narr  
 
sequence Narr1 = narr:new()  
map map1 = map:new() 
  
Narr1 = narr:put(Narr1, "X", 100)  
Narr1 = narr:put(Narr1, "Y", -200)  
Narr1 = narr:put(Narr1, "Z", 300)  
 
map:put( map1, "X", 100 ) 
map:put( map1, "Y", -200 ) 
map:put( map1, "Z", 300 )  
 
 
test_equal("", 100, narr:get(Narr1, "X"))  
test_equal("", -200, narr:get(Narr1, "Y"))  
test_equal("", 300, narr:get(Narr1, "Z"))  
 
test_equal("", 100,  map:get(map1, "X"))  
test_equal("", -200, map:get(map1, "Y"))  
test_equal("", 300,  map:get(map1, "Z"))  
  
Narr1 = narr:put(Narr1, "X", 1000)  
Narr1 = narr:put(Narr1, "Y", -2000)  
Narr1 = narr:put(Narr1, "Z", 3000)  
  
map:put( map1, "X", 1000 ) 
map:put( map1, "Y", -2000 ) 
map:put( map1, "Z", 3000 ) 
 
test_equal("", 1000, narr:get(Narr1, "X"))  
test_equal("", -2000, narr:get(Narr1, "Y"))  
test_equal("", 3000, narr:get(Narr1, "Z"))  
 
test_equal("", 1000,  map:get(map1, "X"))  
test_equal("", -2000, map:get(map1, "Y"))  
test_equal("", 3000,  map:get(map1, "Z"))  
  
sequence Narr2 = narr:new()  
map map2 = map:new() 
 
Narr2 = narr:put(Narr2, "Velocity", 543.902)  
Narr2 = narr:put(Narr2, "X", 0.1)  
Narr2 = narr:put(Narr2, "Y", -0.2)  
Narr2 = narr:put(Narr2, "Z", 0.3)  
Narr2 = narr:put(Narr2, "Name", "Bullet")  
Narr2 = narr:put(Narr2, "XYZ-1", {narr:get(Narr1, "X"),  
                                  narr:get(Narr1, "Y"),  
                                  narr:get(Narr1, "Z")})  
 
map:put(map2, "Velocity", 543.902)  
map:put(map2, "X", 0.1)  
map:put(map2, "Y", -0.2) 
map:put(map2, "Z", 0.3)  
map:put(map2, "Name", "Bullet")  
map:put(map2, "XYZ-1", {map:get(map1, "X"),  
                                  map:get(map1, "Y"),  
                                  map:get(map1, "Z")})  
  
test_equal("", 0.1, narr:get(Narr2, "X"))  
test_equal("", -0.2, narr:get(Narr2, "Y"))  
test_equal("", 0.3, narr:get(Narr2, "Z"))  
test_equal("", "Bullet", narr:get(Narr2, "Name"))  
test_equal("", 543.902, narr:get(Narr2, "Velocity"))  
test_equal("", {1000, -2000, 3000}, narr:get(Narr2, "XYZ-1"))  
 
 
test_equal("", 0.1,  map:get(map2, "X"))  
test_equal("", -0.2, map:get(map2, "Y"))  
test_equal("", 0.3,  map:get(map2, "Z"))  
test_equal("", "Bullet", map:get(map2, "Name"))  
test_equal("", 543.902, map:get(map2, "Velocity"))  
test_equal("", {1000, -2000, 3000}, map:get(map2, "XYZ-1"))  
 

All I did was replace the narr stuff with map stuff. Note that you can also nest maps, and store and retrieve the data with a single call. Is there a reason you can't simply store the information inside of maps?

-- map of indexes may contains "first_name" = 1, "second_name" = 2, "task" = 3 (order may be other, but numbers from 1 to 3) 
Citizen = {"John", "Smith", "buy milk"} 
Superhero = {"Hedgehogman", 0, "save world"} -- yes, the second element is not used, but it is done for uniformity and speed. 

I would say that you're probably better off just coming up with a key, storing the person's structured data as a sequence in a map and using an enum to access the various parts:

enum 
	CITIZEN_FIRST, 
	CITIZEN_LAST, 
	CITIZEN_INCOME 
 
enum 
	SUPERHERO_FIRST, 
	SUPERHERO_LAST, 
	SUPERHERO_TASK 
 

Matt

16. Re: named array

• Posted by SDPringle Sep 03, 2013
• 2090 views

enum 
	CITIZEN_FIRST,  
	CITIZEN_LAST,  
	CITIZEN_INCOME  
  
enum  
	SUPERHERO_FIRST,  
	SUPERHERO_LAST,  
	SUPERHERO_TASK  
  

This kind of thing makes the accessing much faster than using find with a string. It is easy to write in EUPHORIA:

sequence stephen_hawking = { "Stephen", "Hawking", 120_000 } 

The problem is the code requires the coder to know how the structure members are ordered. The above line breaks 'data encapsulation'. Really you want to combine these with a function struct_assign:

sequence stephen_hawking = struct_assign({ CITIZEN_FIRST, "Stephen",  
                                            CITIZEN_LAST, "Hawking",  
                                          CITIZEN_INCOME, 120_000 }) 

The implementation of struct_assign is an exercise for the reader. :) Remember to replace 'sequence' with your own user defined type to save you from blunders.

18. Re: named array

• Posted by BRyan Sep 03, 2013
• 2078 views

Maybe you should rethink your approach.

It sounds to me that you really want to create and use a generic structure that describes the features of each avatar.

These structures can then be stored in a database or map.

20. Re: named array

• Posted by TheresNoTime Sep 03, 2013
• 2070 views

I have repeatedly tried to explain that this approach made ​​my life more difficult. That's why I came up with a "narr" because it makes my life easier.

Two maps.

So, I have to take care of that to backup data to be temporarily changed, and then must be restored. When I use a narr, I can just keep the previous state!

Person = narr:new({"citizenship = USA", "actions = law-abiding", "task = Consume!"}) 
ClarkKent = narr:put(Person, {"name = Clark Kent", "apparel = suit", "sweetheart = Lana Lane"}) 
Superman = narr:put(ClarkKent, {"name = Superman", "apparel = tights"}) 
if equal(narr:get(Person, "task"), "Save the free world!") then 
  Person = Superman 
else 
  Person = ClarkKent 
end if 

I don't warry about that. The fact that the keys are not duplicated in the narrs was not my intention. This is an additional effect. I wanted to get something like the symbols of Ruby, because they are simple and easy. You do not want to say that Ruby and Erlang (may be other) created by idiots?

I not only lazy but also stupid a bit. I do not like to use a nested structures, where possible to implement primitive one-dimensional array/list etc.

22. Re: named array

• Posted by useless_ Sep 03, 2013
• 2045 views

enum 
	CITIZEN_FIRST,  
	CITIZEN_LAST,  
	CITIZEN_INCOME  
  
enum  
	SUPERHERO_FIRST,  
	SUPERHERO_LAST,  
	SUPERHERO_TASK  
  

sequence stephen_hawking = { "Stephen", "Hawking", 120_000 } 

sequence stephen_hawking = struct_assign({ CITIZEN_FIRST, "Stephen",  
                                            CITIZEN_LAST, "Hawking",  
                                          CITIZEN_INCOME, 120_000 }) 

Looks like an xml data table.

useless

PS: if what the OP wants is a free-form xml table, i wrote such an interface in Eu in a version of strtok: getxml(). I removed it later because of criticism that it wasn't needed and wasn't the "Euphoria way".

24. getxml()

• Posted by jimcbrown (admin) Sep 04, 2013
• 1984 views

There are a few XML parsers in the archive. Perhaps one of these could be adapted for such a use. http://www.rapideuphoria.com/cgi-bin/asearch.exu?dos=on&win=on&lnx=on&gen=on&keywords=xml

It looks like getxml() is still around and available too: http://www.rapideuphoria.com/strtok-v2-1.zip

26. Re: named array

• Posted by TheresNoTime Sep 04, 2013
• 1936 views

function willAccident_Map(map State, atom Time) 
  atom Velocity = map:get(State, "velocity")            -- get velocity of system 
  atom Acceleration = map:get(State, "acceleration")    -- get acceleration of system 
  Velocity += Acceleration * Time                       -- no need to keep the old velocity! 
  map NewState = map:clone_and_put(State, "velocity", Velocity) -- because we can get new state 
  return isAccident(NewState)                              -- no need to save answer 
end function 

Yes, it is possible. But why? For what reason? Do you not see that either way - it's my way, but unnecessarily complicated. Your way of using maps plus a crutch to overcome their side effect. My method uses sequences because they initially do not have such effect. Yes, you will have one simple function, and I have three plus the map for keys "behind the scenes". However, if you look at the principle, not to it's implementation, my approach is simpler. It is better to have a new type of data than to remember that it is necessary to use a crutch for old type. Your variation of "willAccident" is shorter, but you just put some of my code into a separate function "clone_and_put". This is the same backup and restore (just disguised), but for the entire map! Pfff...

28. Re: named array

• Posted by TheresNoTime Sep 04, 2013
• 1989 views

Yes, of course, I can write

narr Person[1] = "James"

instead of

narr Person = put(Person, "name", "James")

if I absolutely sure, that key "name" = index 1 in that map. But it is dirty hack, that I'm not going to do. Otherwise, it is unclear why it was a fuss?

Theoretically, there is a much more efficient way. Write a preprocessor that looks for all the indexes and stores them in a list. For example, when it saw

abc = x[_A] + x[_B] + x[_C] -- underlining is used to indicate keys (that "symbols" in terms of Ruby) 

then it creates file symbols.e, that contains

public enum _A, _B, _C 
public function new() 
  return repeat(0, 3) -- because we have only 3 symbols 
end function 

I just came to mind. Perhaps I will do so. Not because it's faster, but because it will take away a lot of repetitive lines

sequence Name = get(my_narr, "name") 
sequence Work = get(my_narr, "work") 

The disadvantage is that it will lead to the need to monitor changes of consistency and make clones. But it will be much easier.

sequence NewState = State 
NewState[_VELOCITY] = NewVelocity 
return isAccident(NewState) -- State isn't changed, NewState is eaten by garbage collector 

Hmmm... No. I did not say so. In the middle of the conversation mentioned structure "map of maps". My narr is simpler than that.

If you say about one narr - yes. If you say about narrs - no. My narrs is more effective than set of maps, because keys stored in single table. I spied this principle in Ruby. I know that this is not in Python. And I'm not even sure that the atoms of the Erlang are analogous to Ruby's symbols.

Of course. I'm not going to make a production version. If the Ruby I spied the principle of symbols, the Erlang I spied principle "Let It Crush".

Oh no, again... Map of keys absolutely invisible. narr is regular sequence. About effectivness. As far as I guess, fetching some stuff form sequence is almost instantaneous operation. It is pointer internally, eh? So, narr is almost equal to map, because it do two actions only: get index from map by key, get value from sequence by index.

30. Re: named array

• Posted by TheresNoTime Sep 05, 2013
• 1852 views

I was talking about something else. I do not care what goes on behind the scenes. The problem is that if you use the maps, you will have to do clones manually. My approach - always make clones, even if they are not needed. This is inefficient, but it can be optimized. Here's how it might look from the outside

narr Local -- Auxiliary variable, to allude it every time when you call a function put() or get(). 
 
function playWithNarr(narr External) 
Local = External 
put("velocity:152.35 coordinates:458,490,3047 name:Ball") -- equivalent to tree puts: atom, sequence of integers and sequence "Ball"! 
sequence Data = get("acceleration color") -- equivalent to two gets! But I got carried away. This particular improvement doesn't make any sense. :) 
-- Ahh! But now would be a very useful thing! Universal function, that able to recognize, what I want: put or get. 
Local = x("velocity:152.35 coordinates:458,490,3047 name:Ball") 
Acceleration = x("acceleration") 

I'm starting to wonder ... May be, simply use the language, which already has something like this? For example, Ruby? Python has not something similar to Ruby's symbols. Python's dict is equivalent of Euphoria's map, but Python has very useful syntax sugar for it. So, it seems equivalent to Ruby's symbols.

In my particular case, this functionality is not only superfluous but also harmful.

This is my dream. Do you agree, that Euphoria's syntax is overloaded a bit? It would be great to create something, that would be the same for Euphoria, what was CoffeeScript for JavaScript. I propose to call it Kaif. This is an Arabic word meaning pleasant, relaxed pastime with coffee and tobacco. :)

32. Re: named array

• Posted by TheresNoTime Sep 05, 2013
• 1879 views

How? Replace standart "put" with "clone_and_put"?

We often do not understand each other because they are talking about several things at once. Security - this is one problem, and convenience - the second. In other languages ​​(Ruby and Python) I will have to decide what is more important. In the Euphoria I have no choice because there is no security, no convenience (in my understanding of these terms).

Did not see anything like what I want. Perhaps I misunderstood something.

A Russian programmer told the following story. He is working in the United States with colleagues of different nationalities. Everyone is doing their part of the program. Once his "Russian" part brought down testing. Began to understand. It turned out that the problem is in the "Chinese" part. The Chinese came and looked, and immediately began to correct. Therefore, Russian programmer saw whole process. He was in shock. A Chinese man has opened its source code. Each function has the list of options in a few screens long. The most amazing thing is that he quickly found the desired function, add a parameter in the middle of a very long list, and ... everything started to happen!

But I started to get nervous because the list of options beyond a single line! Maybe I should apply to such a noodle code quieter? Eventually, computer is steel, unlike my nerves. :)

34. Re: named array

• Posted by TheresNoTime Sep 06, 2013
• 1776 views

This information is extremely inspiring. Could you tell us how difficult it is to make sure that the following lines...

sequence x = {key1:value1 key2:value2} 
sequence y = {key1:value3 key3:value4} 
 
-- ...are automatically transformed into... 
 
sequence x = repeat(0, 3) 
x[1] = value1 
x[2] = value2 
sequence y = repeat(0, 3) 
y[1] = value3 
y[3] = value4 

I meant that those languages have such things right now. Obviously, any powerful language have self-improvement ability. Euphoria can be improved, but Ruby do not to improve, because it already has the symbols.

BTW, So far we have discussed these improvements, I wrote the program. Not all, but enough to not need such flexible instruments. It was necessary to me early on, because I did not know what parameters need to be stored, and which functions will modify the input data. But it could be done faster and easier.

36. Re: named array

• Posted by jimcbrown (admin) Sep 06, 2013
• 1730 views

I think I may have misunderstood this - now that I've taken a closer look, it appears that your library has one set of "global" keys that apply to every and all objects of your type, as opposed to using a big list of keys internally but only allowing keys associated with a specific immutable map to be used.

Since the list of keys are "global" and allowed to change (to be added to), an immutable map type won't work here.