stacyprowell.com » Programming

Gosu

stacy — Mon, 05 Dec 2011 01:06:58 +0000

Deriving its name from the Korean term for a “highly skilled person,” Gosu is a computer language targeting the Java Virtual Machine. It tries to be more expressive than Java (which isn’t really all that hard) while being conceptually simpler than Scala. Of course, sometimes simplicity comes with other baggage. “Type parameters are covariant. This is not sound, and that does not matter” (http://lazygosu.org/generics.html). I’ve spent some time arguing about covariance, contravariance, and invariance, and I think it matters.

Ooh! See this.

The real issue with Gosu, however, is documentation. A quick search for Gosu turns up http://gosu-lang.org/. From this you can find a quick start guide and comprehensive documentation. Great! I read the quick introduction and then download the distribution. It’s nice! It comes with a lightweight IDE and an interactive “REPL” mode. That’s what I like to see. Next, I dig into the comprehensive documentation… but examples from the documentation don’t work!

For instance, the documentation of DateTime (here) says:

Gosu implicitly coerces the Gosu DateTime object from String in most formats. For example:
var date : DateTime = "2007-01-02"

Nifty! I try that and I get:

program_.__Program__0

Errors: 

The type "java.lang.String" cannot be converted to "java.util.Date" [line:1 col:23] in
line 1: var date : DateTime = "2007-01-02"
Expected Type: Date
Line Number: 1  Column: 23

That doesn’t seem like automatic coercion to me. Never one to give up without a fight, I post the following message to the Gosu forum:

The following code:

var date : DateTime = “2007-01-02″

taken directly from the Gosu DateTime page fails to compile with the
following errors:

Errors:

The type “java.lang.String” cannot be converted to
“java.util.Date” [line:1 col:23] in
line 1: var date : DateTime = “2007-01-02″
Expected Type: Date
Line Number: 1 Column: 23

This is also true if one tries “Jan 2, 2007″ as DateTime.
So… What am I doing wrong?

$ gosu -version
0.8.6.1-C

$ javac -version
javac 1.6.0_26

$ java -version
java version “1.6.0_26″

Java(TM) SE Runtime Environment (build 1.6.0_26-b03)
Java HotSpot(TM) 64-Bit Server VM (build 20.1-b02, mixed mode)

$ uname -rm
3.0.0-13-generic x86_64

Thanks in advance.

I expect something along the lines of “wrong version of Java,” or “you’re an idiot because.” Instead, I receive this:

In the open source version of Gosu we don’t support the implicit string to
date coercion. You’ll have to use the .toDate() method on String instead:
var date = “2007-01-02″.toDate()

Cheers,
Carson

Okay, great. Apparently there is an open source version of Gosu and a closed source version. I google in vain for information on these, but none appears. Searching the documentation for “open source” turns up nothing. Everything I read says Gosu is released under the Apache license, and nothing seems to indicate otherwise. So… Clearly the comprehensive documentation is either wrong or incomplete. I’m not happy with either.

I did reply asking where the differences are documented. I’ll post here whatever I hear back. I’ve probably missed some obvious, glaring, probably blinking notice about the differences.

So no Gosu for us, at least for now.

Scala Sudoku

stacy — Tue, 28 Dec 2010 06:48:07 +0000

A while back I needed to get back up to speed on Python, so I wrote a Sudoku solver using a simple algorithm. This required me to think just a bit about the language and how to implement this… plus it was fun.

Now I’m tinkering with Scala, and it occurred to me to write a Sudoku solver tonight. So just over an hour later I have one, and I’m posting it here. I make no claims about this being the right way to do things, or even a good way to do things. In particular, it uses a dumb algorithm to solve Sudoku, and probably isn’t done The Scala Way. In fact, I’m actually posting this so you can tell me where I’ve gone wrong, should have done things differently, etc.

Plus, if you want a Scala Sudoku solver, well, here’s one. Enjoy!

Use this in one of three ways.

Compile it and run it from the prompt. Enter the board one line per row.
Load it into a running Scala REPL and use Board.init to interactively enter the board, one line per row. Use the search method to find a solution.
Put the board in a file and use Board.read from the Scala REPL to load the board. Use the search method to find a solution.

/**
 * Simple Sudoku solver.
 * 2010 by Stacy Prowell.
 * http://stacyprowell.com/
 */
package sjp.sudoku
 
/**
 * An exception indicating that the board has no solution.
 * @param msg  A message.
 * @author sprowell
 */
class BadBoardException(msg:String) extends Exception(msg)
 
/**
 * Helper class for search data.
 * @param fails  Number of failures detected so far during the search.
 * @author sprowell
 */
protected class SearchData(var fails:Int = 0)
 
/**
 * A ''board'' holds two items.
 * - The currently known cell values
 * - The set of possible values for each unknown cell
 * 
 * @author sprowell
 */
class Board {
 
  /** Size of board. */
  val N = 9
 
  /** Representation of an unknown cell. */
  val U = ' '
 
  /** Known values in the grid. */
  val known = Array.ofDim[Char](N,N)
  for (i <- 0 until N; j <- 0 until N) known(i)(j) = U
 
  /** Allowed possibilities for each cell. */
  val possible = Array.ofDim[Set[Char]](N,N)
  for (i <- 0 until N; j <- 0 until N) possible(i)(j) = '1' to '9' toSet
 
  /**
   * Generate a string representing the current state of a cell.
   * There are two possiblities.
   * - `(5,4)=9` if the cell value is known
   * - `(5,4) allows {3,9}` if the cell value is now known
   * @param row  The zero-based row.
   * @param col  The zero-based column.
   * @return  The cell representation.
   */
  def cellToString(row:Int, col:Int) = {
    require(row >= 0 && row < N)
    require(col >= 0 && col < N)
    (row,col) +
      (known(row)(col) match {
        case U => " allows {" + possible(row)(col).mkString(",") + "}"
        case c => "=" + c
      })
  }
 
  /**
   * Set a cell to the given value.  This also updates the set of possible
   * values for each cell.
   * @param row  The zero-based row.
   * @param col  The zero-based column.
   * @param ch  The character, 0-9.
   * @return  The updated board.
   */
  def set(row:Int, col:Int, ch:Char):Board = {
    /**
     * Tiny local function to exclude a value from the possibilities for
     * a cell.
     * @param rr  The zero-based row.
     * @param cc  The zero-based column.
     * @return  True if the cell is solved, false if it is not.
     * @throws  BadBoardException  There is no longer any viable solution.
     */
    def exclude(rr:Int, cc:Int, ex:Char) = {
      if (possible(rr)(cc) contains ex) {
        possible(rr)(cc) -= ex
        possible(rr)(cc).size match {
          case 0 => throw new BadBoardException(cellToString(rr,cc) +
            " has no possibilities")
          case 1 => true
          case _ => false
        }
      }
      false
    }
 
    // Check the arguments.
    require(row >= 0 && row < N)
    require(col >= 0 && col < N)
    require('1' <= ch && ch <= '9')
 
    // The proposed value must be allowed for the cell.
    if (known(row)(col) != U && known(row)(col) != ch)
      throw new BadBoardException(cellToString(row,col) + " cannot be " + ch)
    if (!possible(row)(col).contains(ch))
      throw new BadBoardException(cellToString(row,col) + " cannot be " + ch)
 
    // Record any cells that get solved along the way.
    var also = List[(Int,Int)]()
 
    // Cannot have same value in row or column.
    for (i <- 0 until N) {
      if (i != col && exclude(row,i,ch)) also = (row,i)::also
      if (i != row && exclude(i,col,ch)) also = (i,col)::also
    } // Exclude in row and column.
 
    // Cannot have same value in block.
    val (brow,bcol) = (row/3*3,col/3*3)
    for (i <- 0 to 2; j <- 0 to 2) {
      val (rr,cc) = (brow+i,bcol+j)
      if (rr != row && cc != col && exclude(rr,cc,ch)) also = (rr,cc)::also
    } // Exclude in block.
 
    // Fix up the cell.  Set known and the set of possibilities.
    known(row)(col) = ch ; possible(row)(col) = Set(ch)
 
    // Done.  Now check to see if we discovered any other values.
    // If so, then set those now, recursively.
    also foreach {
      case (rr,cc) => set(rr,cc,possible(rr)(cc).head)
    } // Set each discovered solved cell.
    this
  }
 
  /**
   * Create a duplicate of this board.
   * @return  An independent clone of this board.
   */
  override def clone = {
    val cl = new Board()
    for (i <- 0 until N; j <- 0 until N) {
      cl.known(i)(j) = known(i)(j)
      cl.possible(i)(j) = possible(i)(j) 
    } // Duplicate known and possible.
    cl
  }
 
  /**
   * Initialize a row.  This is only intended to be used from the
   * companion object's init.  The provided string can be any length;
   * only the first N or fewer characters are used.
   * @param row  The zero-based row.
   * @param vals  A string of the values in that row.
   * @return  The updated board.
   */
  private def init(row:Int, vals:String) = {
    require(row >= 0 && row < N)
    require(vals.length <= N)
    var col = 0
    vals.foreach{ch => if (ch != U) set(row,col,ch) ; col += 1}
    this
  }
 
  // Import used below.
  import java.io.{Writer,FileWriter}
 
  /**
   * Write the board to the given writer.
   * @param writer  The writer to get the output.
   */
  def write(writer:Writer) {
    writer.write(known.map(row => row.mkString("")).mkString("\n"))
    writer.flush()
  }
 
  /**
   * Write the board to the given file.
   * @param file  The file name.
   */
  def write(file:String) {
    write(new FileWriter(file))
  }
 
  /**
   * Pretty-print the board.
   * @return  String representing the current known state of the board.
   */
  override def toString() = {
    def rts(row:Int) =
      known(row).slice(0, 3).mkString("") + " | " +
      known(row).slice(3, 6).mkString("") + " | " +
      known(row).slice(6, 9).mkString("") + "\n"
 
    var str = ""
    for (rblock <- 0 until N by 3) {
      if (rblock != 0) str += "----+-----+----\n"
      for (roff <- 0 to 2) {
        str += rts(rblock+roff)
      }
    } // Format all blocks.
    str
  }
 
  /**
   * Search for a solution.
   * @return  Solution, if one is found.
   */
  def search():Option[Board] = search(new SearchData(0))
 
  /**
   * Search for a solution.
   * @param sd  Search data block.
   * @return  Solution, if one is found.
   */
  private def search(sd:SearchData):Option[Board] = {
    // Get the cells that are currently unknown, and get the possibilities
    // for each.
    def unknowns = {
      for (i <- 0 until N; j <- 0 until N if known(i)(j) == U)
        yield (i,j,possible(i)(j))
    }
 
    // If all cells are known... We are done!
    if (unknowns.length == 0) {
      printf("Solution found:  fails=%d\n", sd.fails)
      return Option(this)
    }
 
    // Randomly choose an unknown
    val (row, col, choices) = unknowns(scala.util.Random.nextInt(unknowns.length))
 
    // Try each choice for the unknown cell.
    choices foreach {
      ch =>
      // Copy the board and set the value.  Then recursively seek a
      // solution.  If we find one, we are done.
      val newboard = clone
      try {
        newboard.set(row, col, ch)
        val soln = newboard.search(sd)
        if (soln.isDefined) return soln
      } catch {
        case e:BadBoardException => sd.fails += 1
      }
    } // Trying each choice.
    None
  }
}
 
/**
 * Companion object to the board class.  Provides methods to make and
 * initialize a board.
 *
 * @author sprowell
 */
object Board {
 
  /**
   * Convenience method to make a new board.
   * @return  A new board.
   */
  def apply() = new Board()
 
  import scala.io.Source
 
  /**
   * Read a file into a new board.  The file should consist of nine lines,
   * with each line a sequence of digits and unknown markers (typically a
   * space).  This designates the initial board.
   * @param file  The file path.
   * @return  The new board.
   */
  def read(file:String):Board = read(Source.fromFile(file))
 
  /**
   * Read a file into a new board.  The file should consist of nine lines,
   * with each line a sequence of digits and unknown markers (typically a
   * space).  This designates the initial board.
   * @param source  The source providing the data.
   * @return  The new board.
   */
  def read(source:Source):Board = {
    val board = new Board()
    var row = 0
    for (line <- source.getLines) {
      if (line.length > 0) board.init(row, line)
      row += 1
    } // Read all rows.
    board
  }
 
  /**
   * Interactively initialize a board by requesting nine lines of text
   * from the user.  Each line should consist of digits and unknown markers
   * (typically a space).  This is the initial board.
   * @return  The new board.
   */
  def init:Board = {
    val board = new Board
    for (row <- 0 until board.N) {
      val line = Console.readLine("Row %d: ", row)
      board.init(row, line)
    } // Read all rows.
    board
  }
}
 
/**
 * Application entry point when run from the prompt.  Initialize a board
 * using user input, solve it, and print the solution.
 *
 * @author sprowell
 */
object Sudoku {
  /**
   * Entry point when run from the prompt.
   * @param args  Command line arguments (ignored).
   */
  def main(args:Array[String]) {
    Board.init.search() match {
      case None => println("No solution.")
      case Some(b) => println(b)
    }
  }
}

Watched Properties in Scala

stacy — Tue, 27 Apr 2010 20:08:39 +0000

Scala is pretty damn neat. I’ve only just started learning the language (an earlier attempt had to be sidelined because “real” work interfered), but I’m back to it now.

Properties

Here’s a funny little class I’ve been playing with in some development work.

class Property[T](var value:T) {
  def get:T = value
  def set(newval:T) = {
    value = newval
    this
  }
  def :=(newval:T) = set(newval)
  override def toString = "Property(" + value + ")"
}
implicit def Property2value[T](prop:Property[T]) = prop.get

I think that’s just too neat. The property can be set with the (admittedly PL/1-ish) := operator, and the value can be extracted with a cast or assignment.

If I could override the assignment then I could make this very, very C++-ish-ish. Note that I could have written something like the following.

def `=`(newval:T) = set(newval)

But then I’d have to use this as follows.

scala> val p = new Property(12)
scala> p `=` 13

That’s just not the same thing. Scala does not allow overriding assignment; no copy constructor for you.

If you are willing to declare p to be a var, then you can do the following. But this is really not what you want since it creates a new property, and does not modify the value of the existing property.

scala> def ValueToProperty[T](value:T) = new Property(value)
 
scala> var p = new Property(12)
p: Property[Int] = Property(12)
 
scala> p = 171
p: Property[Int] = Property(171)

Watched Property

So what’s the point of having this mutable property class? Well, now that I have the above I can add code to watch the property.

trait Watcher[T,U] {
  def notify(value:T, data:U)
}
trait Watchable[T,U] {
  var watchers:Map[Watcher[T,U],U] = Map()
  def register(watch:Watcher[T,U], data:U) = {
    watchers += (watch -> data)
  }
  def notify(value:T) = {
    watchers foreach {
      case (watcher, data) => watcher.notify(value, data)
    }
  }
}
class WatchedProperty[T,U](value:T) extends Property(value) with Watchable[T,U] {
  override def set(newval:T) = {
    super.set(newval)
    notify(newval)
    this
  }
}

Now I have a watcher and a watchable. I mix in the watchable trait with the property, and presto! I have a watched property. It’s somewhat of a big deal for some work I’m doing now; this would have made my life much easier.

class See[T,U]() extends Watcher[T,U] {
  def notify(value:T, data:U) = {
    println("Value is now " + value + " and data is " + data + ".")
  }
}

Finally, we do some “work.”

scala> val see = new See[Int,String]
see: See[Int,String] = See@fab91
 
scala> val watch = new WatchedProperty[Int,String](1)
watch: WatchedProperty[Int,String] = Property(1)
 
scala> watch register (see,"watch")
 
scala> watch := 12
Value is now 12 and data is watch.
res22: Property[Int] = Property(12)
 
scala> watch := 31
Value is now 31 and data is watch.
res23: Property[Int] = Property(31)

Of course, I can also avoid new by declaring the companion object for WatchedProperty and adding a factory method. Life in Scala is pretty good (so far).

object WatchedProperty {
  def apply[T,U](value:T) = new WatchedProperty[T,U](value)
}

Cleaner Watched Property

There is a problem with the implementation of watched property, and it is the type annotation U. Why should the property have to know the type for the data? The data only exists for the benefit of the watcher. Worse, the watched property isn’t a drop-in replacement for property; it has two parameters instead of just one. Finally, everyone who wants to register must use the same data type U (or a subclass). Here are some alternatives.

The watcher can maintain a map from watched property to the associated data. The watched property can then send itself with the property change notification. This is bad. The watcher has to maintain the map. If it is watching a lot of properties then it may have to maintain a big map, and there is lookup overhead. We avoid that by having the property return the data with the notification.
We could treat the data as an Any. Then it is the responsibility of the watcher to correctly cast the value during notification. This is a nuisance because the compiler cannot catch type problems for us, but Java programmers should be used to that by now.

Let’s try the second approach.

trait Watcher[T] {
  def notify(value:T, data:Any)
}
trait Watchable[T] {
  var watchers:Map[Watcher[T],Any] = Map()
  def register(watch:Watcher[T], data:Any) = {
    watchers += (watch -> data)
  }
  def notify(value:T) = {
    watchers foreach {
      case (watcher, data) => watcher.notify(value, data)
    }
  }
}
class WatchedProperty[T](value:T) extends Property(value) with Watchable[T] {
  override def set(newval:T) = {
    super.set(newval:T)
    notify(newval)
    this
  }
}

That’s better, actually. Watched property is again a referentially-transparent replacement for property, and watchers can use any data type they want. What could be better than this?

Better Watched Property

Actually that whole “Any” value is the problem now. This implementation cleans up the design a bit with better information hiding and referential transparency, but it also musses up type safety a bit. The watcher knows the type of the data; why can’t it get back properly-typed data during notification?

Maybe we’ve been asking the wrong question. The issue is, I think, the Java-esque nature of the solution. Why does notify really have to be passed the data? Why not do something very different? In fact, why not get rid of the watcher trait altogether? Why do we need it? We really just want to invoke a function (or method) when the property is changed. Let’s just directly register the callback, and forget the middleman.

trait Watchable[T] {
  var watchers:List[(T) => Unit] = List()
  def register(notify:(T) => Unit) {
    watchers += notify
  }
  def notify(value:T) = {
    watchers foreach (notify => notify(value))
  }
}
class WatchedProperty[T](value:T) extends Property(value) with Watchable[T] {
  override def set(newval:T) = {
    super.set(newval)
    notify(newval)
    this
  }
}

Watcher is gone. The data item is gone. The funny type problem is gone. The code is simpler, and even more flexible, since anything can be a watcher, including lambdas.

scala> val prop = new WatchedProperty(21)
prop: WatchedProperty[Int] = Property(21)
 
scala> def see(x:Int) = println("Value changed to: " + x + ".")
see: (Int)Unit
 
scala> prop.register(see)
 
scala> prop.register((x:Int) => println("Lambda sees value: " + x + "."))
 
scala> prop := 413
Value changed to: 413.
Lambda sees value: 413.
res10: Property[Int] = Property(413)

Data Again

Well, what about data? The value for data can be captured in a closure. Here’s an example, where the data is a name for the property being monitored.

class ChangeWatcher {
  def watch[T](prop:WatchedProperty[T], name:String) {
    prop register {
      (value:T) => println(name + ": " + value)
    }
  }
}

Did you get all that? The above is a fully-generic watcher. You pass it a property and a name for the property. Whenever the property is changed, it notifies you. This works for any kind of property.

scala> val prop = new WatchedProperty(21)
prop: WatchedProperty[Int] = Property(21)
 
scala> val status = new WatchedProperty("okay")
status: WatchedProperty[java.lang.String] = Property(okay)
 
scala> val temp = new WatchedProperty(21.8)
temp: WatchedProperty[Double] = Property(21.8)
 
scala> val cw = new ChangeWatcher
cw: ChangeWatcher = ChangeWatcher@3da8bc
 
scala> cw.watch(prop, "prop")
 
scala> cw.watch(status, "status")
 
scala> cw.watch(temp, "temperature")
 
scala> status := "Danger!"
status: Danger!
res18: Property[java.lang.String] = Property(Danger!)
 
scala> temp := 73.2
temperature: 73.2
res19: Property[Double] = Property(73.2)

The important thing to note is that you don’t have to have data. Or you can have lots of data. Or whatever you want. The responsibility for data is all back to the watcher, and off the shoulders of the watchable. This seems (to me) to be the correct division of responsibility.

To sum up: Functional Programming + Objects = Good.

Good Idea / Bad Idea

stacy — Fri, 21 Aug 2009 17:52:04 +0000

Programming

I spend my time (recently) writing a mishmash of Python, C++, and Java. It’s interesting to switch back and forth.

What’s a good idea and what’s a bad (or dangerous) idea in computer language design? We’ve got a lot of candidates, and a lot of opinions.

I’ll list a few here, along with a few places where they show up. I’m not saying C macros are the same as, or even similar to, Lisp macros. Just trying to clarify the spectrum.

I’ve heard someone, at some point, say each one of the items below is a good idea / bad idea. Dangerous in the hands of a novice? Yes, but then so is any computer with a network connection.

Preprocessors (C, C++)
Macros (C, Lisp)
Multiple Inheritance (C++, Smalltalk)
Operator Overloading (C++, Python)
Closures (Lisp, Haskell)
Generics (Java, Ada)
Template Metaprogramming (C++)
Casts (C, C++)
Strong or Weak Typing (Scala, Lisp, Python, ML)
Fixed-Point Math (C# and COBOL)
Fixed Integer Types vs. “Numbers” (C, Lisp, Python)
Garbage Collection (Java, Lisp, ML)
Manual Allocation / Deallocation (C, C++)
Everything is an Object / Some Things are Primitives (Smalltalk, Java)
Auto-(Un)Boxing (Java, C#)
Indentation is Significant (Python)
First-Order Functions (ML, Lisp)
Lambdas (ML, Lisp, Python)
Type Erasure (Java)

Did I leave out your favorite / most reviled language feature? Complain below. I included type erasure at the end of the list. Does anyone think this was a good idea for Java???