Expressiveness using implicit conversions

[Garrett Rowe]

I was considering this post about the expressiveness of the Ruby Date/Time functions, and was wondering if the same type of syntax could be duplicated in Scala. After about 20 minutes hacking around, here's what I came up with. I'm not sure I'm completely in love with the abstraction, but the method calls look the same.

import java.util.Date
 
class MillisecondTime(i : Int) {
 
   val daysInWeek = 7L
   val hoursInDay = 24L
   val minutesInHour = 60L
   val secondsInMinute = 60L
   val millisInSecond = 1000L
   
   lazy val weeks = {
      daysInWeek * days
   }
   
   lazy val days = {
      hoursInDay * hours
   }
   
   lazy val hours = {
      minutesInHour * minutes
   }
   
   lazy val minutes = {
      secondsInMinute * seconds
   }
   
   lazy val seconds = {
      millisInSecond * i
   }
}
 
class ScalaTime(millis: Long) {
 
   import ScalaTime.now
 
   def ago = before(now)
 
   def from(d: Date) = new Date(d.getTime + millis)
   
   def before(d: Date) = new Date(d.getTime - millis)
   
}
 
object ScalaTime {
 
   def now = new Date
   
}
 
object TimeConversions {
 
   implicit def int2MilliTime(i: Int) = new MillisecondTime(i)
   implicit def long2ScalaTime(l: Long) = new ScalaTime(l)
   
}
 
object TimeMain {
 
   import TimeConversions._
   import ScalaTime.now
   
   def main(args: Array[String]) {
   
      println("2 weeks from now: " + (2.weeks from now))
      println("10 days from now: " + (10.days from now))
      println("5 minutes ago: " + (5.minutes ago))
   
   }
}

Output:
2 weeks from now: Sat Jul 26 14:58:44 MST 2008
10 days from now: Tue Jul 22 14:58:44 MST 2008
5 minutes ago: Sat Jul 12 14:53:44 MST 2008
[ July 12, 2008: Message edited by: Garrett Rowe ]

[Marc Peabody]

I fiddled with your code before going to bed. This was a ton of fun!

Maybe what I did will spark some more ideas:

package hello
 
import java.util.Date
import java.util.Calendar
class MillisecondTime(i : Int) {
  val daysInWeek = 7L
  val hoursInDay = 24L
  val minutesInHour = 60L
  val secondsInMinute = 60L
  val millisInSecond = 1000L
  lazy val weeks = { daysInWeek * days }
  lazy val days = { hoursInDay * hours }
  lazy val hours = { minutesInHour * minutes }
  lazy val minutes = { secondsInMinute * seconds }
  lazy val seconds = { millisInSecond * i }
  def pm = {
    val c =  Calendar.getInstance()
    c.set(Calendar.MILLISECOND, 0)
    c.set(Calendar.SECOND, 0)
    c.set(Calendar.MINUTE, 0)
    c.set(Calendar.HOUR, i)
    c.set(Calendar.AM_PM, Calendar.PM)
    c.getTime()
  }
  def am = {
    val c =  Calendar.getInstance()
    c.set(Calendar.MILLISECOND, 0)
    c.set(Calendar.SECOND, 0)
    c.set(Calendar.MINUTE, 0)
    c.set(Calendar.HOUR, i)
    c.set(Calendar.AM_PM, Calendar.AM)
    c.getTime()
  }
  def :>(min: Int) = {
    val c =  Calendar.getInstance()
    c.set(Calendar.MILLISECOND, 0)
    c.set(Calendar.SECOND, 0)
    c.set(Calendar.MINUTE, min)
    c.set(Calendar.HOUR, i)
    c.getTime()    
  }
}
class ScalaTime(millis: Long) {
  import ScalaTime.now
  def ago = before(now)
  def from(d: Date) = new Date(d.getTime + millis)
  def before(d: Date) = new Date(d.getTime - millis)
}
object ScalaTime {
  import TimeConversions._ 
  def now = new Date
  def noon = 12.am
  def midnight = 12.pm
}
class FlexiDate(date: Date){
  import TimeConversions._ 
  def tomorrow =  {
    new Date(date.getTime()+(1.days))
  }
  def yesterday = {
    new Date(date.getTime()-(1.days))
  }
}
object TimeConversions {
  implicit def int2MilliTime(i: Int) = new MillisecondTime(i)
  implicit def long2ScalaTime(l: Long) = new ScalaTime(l)
  implicit def date2FlexiDate(d: Date) = new FlexiDate(d)
}
object TimeMain {
  import TimeConversions._ 
  import ScalaTime._
  def main(args: Array[String]) {
    println("2 am: " + (2.am))
    println("3 pm yesterday: " + (3.pm yesterday))
    println("noon tomorrow: " + (noon tomorrow))
    println("12:05 - " + (12 :> 05 ))
  }
}    

2 am: Sun Jul 13 02:00:00 EDT 2008
3 pm yesterday: Sat Jul 12 15:00:00 EDT 2008
noon tomorrow: Mon Jul 14 12:00:00 EDT 2008
12:05 - Sun Jul 13 12:05:00 EDT 2008

I was surprised that the Calendar treats noon as 12 am and midnight as 12 pm.

[Garrett Rowe]

I'll see your extensions and raise you some more sugary sweet syntax.

import java.util.{Date, Calendar}
 
class TimeInterval(val milliseconds: Long) {
 
  import DateTime.now
 
  def ago = before(now)
  def from(d: Date) = new Date(d.getTime + milliseconds)
  def before(d: Date) = new Date(d.getTime - milliseconds)
  def +(ti: TimeInterval) = new TimeInterval(milliseconds + ti.milliseconds)
  def -(ti: TimeInterval) = new TimeInterval(milliseconds - ti.milliseconds)
   
}
 
object TimeInterval {
   
  val daysInWeek = 7L
  val hoursInDay = 24L
  val minutesInHour = 60L
  val secondsInMinute = 60L
  val millisInSecond = 1000L
  
}
  
class TimeIntervalFactory(i: Int) {
  import TimeInterval._
 
  def weeks = new TimeInterval(daysInWeek * hoursInDay * minutesInHour * secondsInMinute * millisInSecond * i)
  def week = weeks
  def days = new TimeInterval(hoursInDay * minutesInHour * secondsInMinute * millisInSecond * i)
  def day = days
  def hours = new TimeInterval(minutesInHour * secondsInMinute * millisInSecond * i)
  def hour = hours
  def minutes = new TimeInterval(secondsInMinute * millisInSecond * i)
  def minute = minutes
  def seconds = new TimeInterval(millisInSecond * i)
  def second = seconds
  def milliseconds = new TimeInterval(i)
  def millisecond = milliseconds
  
} 
 
sealed trait Time {//Sealed so it can only be constructed through the factory methods
   val underlying: Date
}
 
class TimeFactory(i: Int) {
   
  def pm = {
    val c =  Calendar.getInstance()
    c.set(Calendar.MILLISECOND, 0)
    c.set(Calendar.SECOND, 0)
    c.set(Calendar.MINUTE, 0)
    c.set(Calendar.HOUR, i)
    c.set(Calendar.AM_PM, Calendar.PM)
    new Time{ val underlying = c.getTime() }
  }
  
  def am = {
    val c =  Calendar.getInstance()
    c.set(Calendar.MILLISECOND, 0)
    c.set(Calendar.SECOND, 0)
    c.set(Calendar.MINUTE, 0)
    c.set(Calendar.HOUR, i)
    c.set(Calendar.AM_PM, Calendar.AM)
    new Time{ val underlying = c.getTime() }
  }
  
  def :>(min: Int) = {
    val c =  Calendar.getInstance()
    c.set(Calendar.MILLISECOND, 0)
    c.set(Calendar.SECOND, 0)
    c.set(Calendar.MINUTE, min)
    c.set(Calendar.HOUR, i)
    new Time{ val underlying = c.getTime() }
  }  
}  
 
class DateTime(d: Date) {
  def at(time: Time) = {
      val ct = Calendar.getInstance()
      ct.setTime(time.underlying)
      val c =  Calendar.getInstance()
      c.setTime(d)
      c.set(Calendar.MILLISECOND, ct.get(Calendar.MILLISECOND))
      c.set(Calendar.SECOND, ct.get(Calendar.SECOND))
      c.set(Calendar.MINUTE, ct.get(Calendar.MINUTE))
      c.set(Calendar.HOUR, ct.get(Calendar.HOUR))
      c.getTime()
   }
      
}
 
object TimeConversions {
  implicit def int2TimeIntervalFactory(i: Int) = new TimeIntervalFactory(i)
  implicit def int2TimeFactory(i: Int) = new TimeFactory(i)
  implicit def date2DateTime(d: Date) = new DateTime(d)
}
 
object DateTime {
  import TimeConversions._
 
  def now = new Date
  def tomorrow = 1.day from now
  def yesterday = 1.day before now
  def noon = 12.am
  def midnight = 12.pm
}
 
object DTMain extends Application {
   import TimeConversions._
   import DateTime._
 
   println("1 day ago: " + (1.day ago))
   println("Yesterday at 3:00: " + (yesterday at 3 :> 00))
   println("30 days from now at midnight: " + (30.days from now at midnight))
   println("Tomorrow at 3 AM: " + (tomorrow at 3.am))
   println("30 days from 8 hours from now: " + (30.days from (8.hours from now)))
   println("30 days + 8 hours from now: " + (30.days + 8.hours from now))
}

1 day ago: Sat Jul 12 02:16:38 MST 2008
Yesterday at 3:00: Sat Jul 12 03:00:00 MST 2008
30 days from now at midnight: Tue Aug 12 00:00:00 MST 2008
Tomorrow at 3 AM: Mon Jul 14 03:00:00 MST 2008
30 days from 8 hours from now: Tue Aug 12 10:16:38 MST 2008
30 days + 8 hours from now: Tue Aug 12 10:16:38 MST 2008
[ July 13, 2008: Message edited by: Garrett Rowe ]

[Mike Simmons]

Pretty slick, Garrett, and Marc. Thanks for showing that. And Garrett - greetings from a former Arizonan.

[Marc]: I was surprised that the Calendar treats noon as 12 am and midnight as 12 pm.

What makes you say that? The documentation for Calendar says otherwise:

"Although historically not precise, midnight also belongs to "am", and noon belongs to "pm", so on the same day, 12:00 am (midnight) < 12:01 am, and 12:00 pm (noon) < 12:01 pm"