Time#succ ?

[Hal Fulton]

Should this be added? It would enable the creation
of Time ranges like t1..t2 and so on.

I'd assume that seconds would be the default resolution
(although the actual resolution is platform-dependent).

Hal

 

[Yukihiro Matsumoto]

Hi,

In message "Time#succ ?"

|Should this be added? It would enable the creation
|of Time ranges like t1..t2 and so on.
|
|I'd assume that seconds would be the default resolution
|(although the actual resolution is platform-dependent).

I like the idea. How should I treat sub-second value?

n = Time.now
p n.to_f # 1069633904.88943
p n.succ.to_f # 1069633905.88943 or 1069633905.0 or 1069633906.0?

matz.

 

[Hal Fulton]

Hi,

In message "Time#succ ?"

|Should this be added? It would enable the creation
|of Time ranges like t1..t2 and so on.
|
|I'd assume that seconds would be the default resolution
|(although the actual resolution is platform-dependent).

I like the idea. How should I treat sub-second value?

n = Time.now
p n.to_f # 1069633904.88943
p n.succ.to_f # 1069633905.88943 or 1069633905.0 or 1069633906.0?

I would expect the first case.

Then n.succ.to_f would behave the same as (n+1).to_f,
isn't that correct?

Hal

 

[Paul Brannan]

Should this be added? It would enable the creation
of Time ranges like t1..t2 and so on.

Does this not already work?

[pbrannan@zaphod ruby]$ irb
irb(main):001:0> t = Time.now
=> Wed Nov 26 16:27:46 EST 2003
irb(main):002:0> (t .. t+1)
=> Wed Nov 26 16:27:46 EST 2003..Wed Nov 26 16:27:47 EST 2003

(the problem only comes if you want to iterate over the range, which
seems to me to be an ill-defined operation).

Paul

 

[Hal Fulton]

Should this be added? It would enable the creation
of Time ranges like t1..t2 and so on.

Does this not already work?

[pbrannan@zaphod ruby]$ irb
irb(main):001:0> t = Time.now
=> Wed Nov 26 16:27:46 EST 2003
irb(main):002:0> (t .. t+1)
=> Wed Nov 26 16:27:46 EST 2003..Wed Nov 26 16:27:47 EST 2003

(the problem only comes if you want to iterate over the range, which
seems to me to be an ill-defined operation).

Hmmm. For some reason I thought that to have a Range, the
endpoint objects had to know #succ.

Apparently Time ranges do work fine. I don't know why I
never thought of them before.

As for iterating: I agree it's ill-defined, but I think it's
reasonable to let t.succ be the same as t+1 (since the latter
is already meaningful).

But since I can construct a Time range and call include? on it,
I suppose that's all we really need.

Hal

 

[Ara.T.Howard]

Date: Thu, 27 Nov 2003 06:29:10 +0900
From: Paul Brannan <[email protected]>
Newsgroups: comp.lang.ruby
Subject: Re: Time#succ ?

Should this be added? It would enable the creation
of Time ranges like t1..t2 and so on.

Does this not already work?

[pbrannan@zaphod ruby]$ irb
irb(main):001:0> t = Time.now
=> Wed Nov 26 16:27:46 EST 2003
irb(main):002:0> (t .. t+1)
=> Wed Nov 26 16:27:46 EST 2003..Wed Nov 26 16:27:47 EST 2003

(the problem only comes if you want to iterate over the range, which
seems to me to be an ill-defined operation).

anyone familiar with the 'jot' unix program? i think ranges should work like
that - eg. one should be able to define the increment

day = 60 * 60 * 24

a = Time.now
b = Time.now + (7 * day)

week = (a...b)

week.each(step = day) do |weekday|
...
end

as it is needs to overide the #succ method of an object for that to occur.


i realize this is problematic since currently ranges only rely on having a
#succ method, but perhaps this could be extend such that Range#each takes an
optional argument, step. if this is given it will be passed to the objects
#step method, something similar to:


~ > cat timestep.rb

class Range
alias __each each
def each step = nil, &block
nxt, e = self.begin, self.end

if nxt.respond_to? :step
loop do
yield nxt
nxt = nxt.step step
break if (exclude_end? ? nxt >= e : nxt > e)
end
else
__each &block
end
end
end

class Time;
def step n; self + n; end
end

a = Time.now
b = Time.now + (7 * 24 * 60 * 60)

week = (a...b)

week.each(24 * 60 * 60) do |day|
p day
end

~ > ruby timestep.rb

Wed Nov 26 15:29:18 MST 2003
Thu Nov 27 15:29:18 MST 2003
Fri Nov 28 15:29:18 MST 2003
Sat Nov 29 15:29:18 MST 2003
Sun Nov 30 15:29:18 MST 2003
Mon Dec 01 15:29:18 MST 2003
Tue Dec 02 15:29:18 MST 2003
Wed Dec 03 15:29:18 MST 2003


-a
--

ATTN: please update your address books with address below!

===============================================================================
| EMAIL :: Ara [dot] T [dot] Howard [at] noaa [dot] gov
| PHONE :: 303.497.6469
| ADDRESS :: E/GC2 325 Broadway, Boulder, CO 80305-3328
| STP :: http://www.ngdc.noaa.gov/stp/
| NGDC :: http://www.ngdc.noaa.gov/
| NESDIS :: http://www.nesdis.noaa.gov/
| NOAA :: http://www.noaa.gov/
| US DOC :: http://www.commerce.gov/
|
| The difference between art and science is that science is what we
| understand well enough to explain to a computer.
| Art is everything else.
| -- Donald Knuth, "Discover"
|
| /bin/sh -c 'for l in ruby perl;do $l -e "print \"\x3a\x2d\x29\x0a\"";done'
===============================================================================

 

[Sabby and Tabby]

anyone familiar with the 'jot' unix program? i think ranges should work like
that - eg. one should be able to define the increment

day = 60 * 60 * 24

a = Time.now
b = Time.now + (7 * day)

week = (a...b)

week.each(step = day) do |weekday|
...
end

Maybe Range#step:

day = 60*60*24
a = Time.now
b = a + 7 * day

(a..b).step(day) {|t| puts t}

Unfortunately:

./gem:20:in `step': cannot iterate from Time (TypeError)

A work-around:

a = Time.now.to_i
b = a + 7 * day

(a..b).step(day) {|t| puts Time.at(t)}

 

[Niklas Frykholm]

anyone familiar with the 'jot' unix program? i think ranges should work like
I think a rather nice way of doing this is "by example":

def loop_over(v1,v2,vn)
x = v1
step = v2 - v1
while x <= vn
yield x
x += step
end
end

loop_over(1,2,10) {|x| puts x} # -> 1,2,3,4,5,6,7,8,9,10

day = 60 * 60 * 24
t = Time.now

loop_over(t, t + day, t + 7*day) do |weekday|

// Niklas