ruby wish-list

Ari Brown wrote:
> Hey!
>
> Not **quite** on topic of garbage collection.... But how hard would
> it be to create maybe a style of method creation that doesn't use
> the . to represent Object.behavior ?
Define your code in the global namespace, like
def a
end
is a function a 'in the global namespace' -- no dots.
Maybe hard code in the parent class?
The way Rails does it is by say you do the command
my_special_class_function_one
if it doesn't exist it catches the error thrown for non-existence, looks
up how and then defines the method and returns it (redefines things
in-line).

>
> In retrospect, it seems like definitely a core language feature that
> may or may not be impossible to get at... But I figured I'd ask :-)
>
>
> Also, Is there an easy/hard way to define new %{} style methods? Like
> for a Rope object, maybe %m{} or something.

Not sure.
GL!

>
> Just a newbie's musings.
>
> Thanks,
> Ari
> --------------------------------------------|
> If you're not living on the edge,
> then you're just wasting space.

--
Posted via http://www.ruby-forum.com/.

On 10/15/07, Ari Brown <ari@aribrown.com> wrote:
>
> Also, Is there an easy/hard way to define new %{} style methods? Like
> for a Rope object, maybe %m{} or something.

This has come up before - I can't find the thread, but I believe the
answer was that it would hinder the ability to add new ones to the
core (since that could potentially break code that had already defined
it).

martin

GC wish list:
Isn't it possible to create your own reference checking style object?
Would this be possible, for example.


Class Object

attr_reader :internal_object # only used if you call
new_with_timely_death_wrapper for your new call--see below
def new_with_timely_death_wrapper class_to_use, *args
@internal_object = class_to_use.new *args # since this object is
'only internal' deleting it later will be OK
end

def assign_to_me this_wrapped_object
dec
@internal_object = this_wrapped_object.internal_object
inc
end

def do_method name, *args
eval("@internal_object.#{name} *args") # ok there's probably a better
way maybe object.internal_object.do_whatever args
end

def dec
@internal_object.count -= 1
recycle_current_object if count == 0
end

def inc
@internal_object.count += 1
end

def recycle_current_object
# traverse internal members of @internal_object--force_recycle them,
unless they're wrappers, then just dec them.
@internal_object.recycle
end

def inc
@internal_object.count += 1
end

def go_out_of_scope
dec
self.force_recycle # we are toast -- this is scary and might not be
right
end

end

Then the example:

a = Array.new_with_timely_death_wrapper(0,0)
b = Array.new_with_timely_death_wrapper(0,0) # only time you should use
assign is on start
b.assign_to_me a #recycle's b's object, assigns internal_object to a's
internal_object.a, sets count to 2
a.go_out_of_scope # a set to 1
b.go_out_of_scope # a set to 0 -- recycled.

?
--
Posted via http://www.ruby-forum.com/.

Roger Pack wrote:
> GC wish list:

Another wish for Ruby would be the power to define ones own unary or
binary operators.

Like I wish I could define "is_within?' for arrays, like
if element_x is_within? array_y
# do stuff
end

That would be sweet. If such a thing were possible, then one could
really create code that looks like complete sentences
My $.02 for the day.

-Roger
--
Posted via http://www.ruby-forum.com/.

Oh, wishing star! Here are my wishes:

1. Use "new" as the name of the constructor instead of "initialize".
You can keep "initialize" around for legacy support; just "alias
initialize new" for the future.

This makes it easy to connect the dots: "SomeClass.new" actually calls
the "new" instance method of a newly instantiated object of class
SomeClass.


2. Fix the Ruby parser to treat // (literal regexp) just like the
%r{...} (also literal regexp) construct so that you aren't forced to use
parentheses in method calls:

$ ruby -v
ruby 1.8.6 (2007-03-13 patchlevel 0) [i686-linux]

$ ruby -w -e '"foo".sub /o$/, "x"'
-e:1: warning: ambiguous first argument; put parentheses or even
spaces

$ ruby -w -e '"foo".sub %r/o$/, "x"'
[observe lack of warning]

This problem becomes especially apparent when you use gsub! or sub!:

"foo".gsub! /o$/, "x" # IMHO, sweet!

"foo".gsub! %r/o$/, "x" # IMHO, so-so!

"foo".gsub!(/o$/, "x") # IMHO, ugly!

Thanks for your consideration.
--
Posted via http://www.ruby-forum.com/.

On Oct 19, 2007, at 5:09 PM, Roger Pack wrote:

> Roger Pack wrote:
>>
> Like I wish I could define "is_within?' for arrays, like
> if element_x is_within? array_y
> # do stuff
> end
>

That can't be done now?!?

arr = ['a', 'b']

if arr.include? 'a'
puts "array arr includes the letter 'a'"
end

should be easy to do it the other way as well.

cross-post from core:
After examining how the 1.8.6 gc works, I had a few thoughts:

Background:

It seems that on a 'cpu intensive' program (one that generates a lot of
discardable objects--quite common), there is a competition between two
aspects of the gc to call garbage_collect first. They are:

1) If you run out of available heap slots ruby calls garbage_collect,
and
if
"FREE_MIN" slots now exist (by default 4096) then it returns and leaves
the heap the same size. It also resets the current 'malloc'ed bytes'
counter to 0, since it called garbage_collect.

2) If you reach GC_MALLOC_LIMIT of malloc'ed bytes, then it calls
garbage_collect, resets it to 0.

Anyway so what happens in today's implementations is that number 1 is
called often (I believe) preventing number 2 from ever even springing,
as it
resets the current count of malloc'ed bytes. It's like garbage_collect
is
trying to serve 2 masters, and ends up serving just the one. I see this
as curious as it basically disallows GC_MALLOC_LIMIT from being reached,
which is not what you would expect.


Thoughts?

On another point, I have a question on this line of code, run at the end
of garbage collection:
if (malloc_increase > malloc_limit) {
malloc_limit += (malloc_increase - malloc_limit) * (double)live /
(live + freed); // this line
if (malloc_limit < GC_MALLOC_LIMIT) malloc_limit = GC_MALLOC_LIMIT;
}

I haven't checked this, but it seems to me that It seems to me that
(malloc_increase - malloc_limit) will always be a very small number (?)
which may not be what was expected. I could be wrong.



So my question is "what should the GC do, and when?
Any thoughts?
In my opinion, if it runs out of heap slots available, it should call
garbage_collect AND increase the heap size (so that next time it won't
run out, and will have enough to hopefully reach GC_MALLOC_LIMIT).

I think when it does reach GC_MALLOC_LIMIT malloc'ed bytes, it should
set it

new_malloc_limit = GC_MALLOC_LIMIT *
(1 - percent_of_recent_allocated_memory_that_was_freed)

to allow the malloc_limit to change dynamically, maybe with a fixed max
size.

So my question is what should best happen?
Ruby rox.
--
Posted via http://www.ruby-forum.com/.

> Another wish for Ruby would be the power to define ones own unary or
> binary operators.
>
> Like I wish I could define "is_within?' for arrays, like
> if element_x is_within? array_y
> # do stuff
> end

I guess it is possible:

if element_x.is_within? array_y
# do stuff
end


Ruby is flexible enough again!

Another wish list item would be being able to use "a {var_name}" instead
of "a #{var_name}" I hate that extra pound, as it reminds me of perl

Take care.
-Roger
--
Posted via http://www.ruby-forum.com/.

Suraj Kurapati wrote:

> "foo".gsub! /o$/, "x" # IMHO, sweet!
>
> "foo".gsub! %r/o$/, "x" # IMHO, so-so!
>
> "foo".gsub!(/o$/, "x") # IMHO, ugly!
>
> Thanks for your consideration.

I wonder if that fact that regex's always with have two /'s might
help...


Now my own wish. I wish ruby didn't need ,'s for method parameters.
Why are they always necessary?
foo a b c # as long as a, b, and c aren't functions, and aren't
operators, this could parse!
Take care.
-Roger
--
Posted via http://www.ruby-forum.com/.

> Take care.
> -Roger

I wish that ranges could be descending, like
(2000..1950)
and that Range.to_a wouldn't become obselete, as it seems quite useful
in rails!
--
Posted via http://www.ruby-forum.com/.