Results for: "minmax"

Set#inspect

Returns a string containing a human-readable representation of the set. (“#<Set: {element1, element2, …}>”)

Tempfile#unlink

Unlinks (deletes) the file from the filesystem. One should always unlink the file after using it, as is explained in the “Explicit close” good practice section in the Tempfile overview:

file = Tempfile.new('foo')
begin
   ...do something with file...
ensure
   file.close
   file.unlink   # deletes the temp file
end

Unlink-before-close

On POSIX systems it’s possible to unlink a file before closing it. This practice is explained in detail in the Tempfile overview (section “Unlink after creation”); please refer there for more information.

However, unlink-before-close may not be supported on non-POSIX operating systems. Microsoft Windows is the most notable case: unlinking a non-closed file will result in an error, which this method will silently ignore. If you want to practice unlink-before-close whenever possible, then you should write code like this:

file = Tempfile.new('foo')
file.unlink   # On Windows this silently fails.
begin
   ... do something with file ...
ensure
   file.close!   # Closes the file handle. If the file wasn't unlinked
                 # because #unlink failed, then this method will attempt
                 # to do so again.
end

ThreadsWait#finished?

Returns true if any thread has terminated and is ready to be collected.

ThreadsWait#join

Waits for specified threads to terminate, and returns when one of the threads terminated.

ThWait#finished?

Returns true if any thread has terminated and is ready to be collected.

ThWait#join

Waits for specified threads to terminate, and returns when one of the threads terminated.

TrueClass#inspect

The string representation of true is “true”.

FalseClass#inspect

‘nuf said…

Thread#join

The calling thread will suspend execution and run this thr.

Does not return until thr exits or until the given limit seconds have passed.

If the time limit expires, nil will be returned, otherwise thr is returned.

Any threads not joined will be killed when the main program exits.

If thr had previously raised an exception and the ::abort_on_exception or $DEBUG flags are not set, (so the exception has not yet been processed), it will be processed at this time.

a = Thread.new { print "a"; sleep(10); print "b"; print "c" }
x = Thread.new { print "x"; Thread.pass; print "y"; print "z" }
x.join # Let thread x finish, thread a will be killed on exit.
#=> "axyz"

The following example illustrates the limit parameter.

y = Thread.new { 4.times { sleep 0.1; puts 'tick... ' }}
puts "Waiting" until y.join(0.15)

This will produce:

tick...
Waiting
tick...
Waiting
tick...
tick...

Thread#inspect

Dump the name, id, and status of thr to a string.

Proc#inspect

Returns the unique identifier for this proc, along with an indication of where the proc was defined.

Method#inspect

Returns the name of the underlying method.

"cat".method(:count).inspect   #=> "#<Method: String#count>"

Method#unbind

Dissociates meth from its current receiver. The resulting UnboundMethod can subsequently be bound to a new object of the same class (see UnboundMethod).

UnboundMethod#inspect

Returns the name of the underlying method.

"cat".method(:count).inspect   #=> "#<Method: String#count>"

UnboundMethod#bind

Bind umeth to obj. If Klass was the class from which umeth was obtained, obj.kind_of?(Klass) must be true.

class A
  def test
    puts "In test, class = #{self.class}"
  end
end
class B < A
end
class C < B
end

um = B.instance_method(:test)
bm = um.bind(C.new)
bm.call
bm = um.bind(B.new)
bm.call
bm = um.bind(A.new)
bm.call

produces:

In test, class = C
In test, class = B
prog.rb:16:in `bind': bind argument must be an instance of B (TypeError)
 from prog.rb:16

TracePoint#inspect

Return a string containing a human-readable TracePoint status.

TracePoint#lineno

Line number of the event

Kernel#BigDecimal

Kernel#printf

Equivalent to:

io.write(sprintf(string, obj, ...))

or

$stdout.write(sprintf(string, obj, ...))

Kernel#print

Prints each object in turn to $stdout. If the output field separator ($,) is not nil, its contents will appear between each field. If the output record separator ($\) is not nil, it will be appended to the output. If no arguments are given, prints $_. Objects that aren’t strings will be converted by calling their to_s method.

print "cat", [1,2,3], 99, "\n"
$, = ", "
$\ = "\n"
print "cat", [1,2,3], 99