vemod.net

Post-rock

Sat, 24 Jul 2010 10:35:18 +0200

Post-rock rocks. Here are some good bands:

Caspian (Spotify)
Explosions in the Sky (Spotify)
Godspeed You! Black Emperor (Spotify)
Mono (Spotify)
Red Sparowes (Spotify)
Russian Circles (Spotify)

A Predicate Combinator

Mon, 28 Jun 2010 00:08:46 +0200

I’ve experimented a lot with PLT Scheme lately. I found myself testing values against several predicate functions a couple of times and writing this kind of code:

(define (integer-or-string? x) (or (integer? x) (string? x)))

Not too pretty. Inspired by PLT Scheme’s contract combinator or/c I wrote this:

(define (or/p . ps) (λ (x) (ormap values (map (λ (f) (f x)) ps))))

And now I can write this:

(define integer-or-string? (or/p integer? string?))

And then I lived happily ever after.

Update: cce/scheme has this function as disjoin.

Haskell

For comparison, the function would be written like this in Haskell:

or_p ps x = or $ map ($x) ps

(Yes, I like dollars—why?)

Scala

And something more to compare with:

def orP[T](ps: List[T => Boolean])(x: T) =
  ps.map(_(x)).foldLeft(false)(_||_)

Tags: Haskell, Scala, and PLT Scheme

The Web Site Hall of Shame

Wed, 23 Jun 2010 20:20:28 +0200

GOTO world-wide-fail.tumblr.com

Tags: Web

Scala: Runnable and Callable

Mon, 21 Jun 2010 18:10:49 +0200

Scala functions don’t implement the Runnable and Callable interfaces even though there’s a simply mapping. Luckily, Scala provides us with a mechanism to extend functions on our own: implicits conversions. Here are two usable definitions:

implicit def runnable(f: () => Unit): Runnable =
  new Runnable() { def run() = f() }

import java.util.concurrent.Callable

implicit def callable[T](f: () => T): Callable[T] =
  new Callable[T]() { def call() = f() }

Enjoy.

Tags: Scala

Purely Functional Heap Sort in Scala

Tue, 15 Jun 2010 14:28:03 +0200

Inspired by the blog post Purely functional Heap Sort in OCaml, F# and Haskell on The Flying Frog Blog I decided to implement the same datastructure and operations in Scala to get one little step closer to Scala mastery. This code is not idiomatic Scala, but I think it is decent anyway. If you have any comments, feel free to contact me as usual.

Challenge: Rewrite the code to be more object-oriented. (Disclaimer: I don’t think it’s possible to write toList as a method and have the tail recursion optimization kick in, but I’d love to be proven wrong.)

Don’t forget to take a look at the OCaml, F# and Haskell versions and compare. Note the amount of types that Scala can’t infer.

Update: The code has been updated with some improvements suggested by Robbert.

sealed abstract class Heap[+A] { def rank: Int }
case object EmptyHeap extends Heap[Nothing] { def rank = 0}
case class NonEmptyHeap[A](rank: Int, element: A, left: Heap[A], right: Heap[A]) extends Heap[A]

object Heap {
  def apply[A](x: A): Heap[A] =
    this(x, EmptyHeap, EmptyHeap)

  def apply[A](x: A, a: Heap[A], b: Heap[A]): Heap[A] =
    if (a.rank > b.rank)
      NonEmptyHeap(b.rank + 1, x, a, b)
    else
      NonEmptyHeap(a.rank + 1, x, b, a)

  def merge[A <% Ordered[A]](a: Heap[A], b: Heap[A]): Heap[A] =
    (a, b) match {
      case (x, EmptyHeap) => x
      case (EmptyHeap, x) => x
      case (x: NonEmptyHeap[A], y: NonEmptyHeap[A]) =>
        if (x.element >= y.element)
          Heap(x.element, x.left, merge(x.right, y))
        else
          Heap(y.element, y.left, merge(x, y.right))
    }

  def toList[A <% Ordered[A]](heap: Heap[A]) =
    toListWithMemory(List(), heap)

  @annotation.tailrec
  def toListWithMemory[A <% Ordered[A]](memo: List[A], heap: Heap[A]): List[A] =
    heap match {
      case EmptyHeap => memo
      case x: NonEmptyHeap[A] =>
        toListWithMemory(x.element :: memo, merge(x.left, x.right))
    }

  def heapSort[A <% Ordered[A]](xs: Seq[A]): Seq[A] =
    toList(xs.foldLeft(EmptyHeap: Heap[A])((memo, x) => merge(Heap(x), memo)))
}

object HeapSortTest {
  def main(args: Array[String]) = {
    Heap.heapSort(Range(1, 1000000))
    System.out.println("Done!")
  }
}

Tags: Scala

How to Set Cache-Control for Rails Assets with Apache

Mon, 14 Jun 2010 21:54:24 +0200

RewriteCond "%{QUERY_STRING}" "[0-9]+$" 
RewriteRule "^.*$" "$0" [L,E=CACHE:True] # Match all.
Header onsuccess set "Cache-Control" "public, max-age=31536000" env=CACHE

Dependencies: mod_rewrite and mod_headers

Please contact me if you know an even nicer way.

Tags: Rails

Datorbutiker i Malmö

Mon, 24 May 2010 11:07:24 +0200

Här är en nästan komplett lista över datorbutiker i Malmö. Var vänlig och meddela mig om någon butik saknas.

Se även: Datorbutiker i Lund och Datorbutiker i Malmö på Google Maps

Datorbutiker

Apple-återförsäljare

Hemelektronikkedjor

PHP: render_template

Tue, 18 May 2010 00:36:24 +0200

I try to avoid PHP but a university course mandated its use some time ago and I decided to do the best of the situation. One of the things I did was to implement this simple function for template rendering:

<?
function render_template($filename, $variables) {
    extract($variables);
    ob_start();
    require("templates/" . $filename . ".php");
    $contents = ob_get_contents(); 
    ob_end_clean();
    return $contents;
}
?>

It can be used like this:

<?
function layout($title, $body) {
    return render_template("layout.html", array("title" => $title, "body" => $body));
}
?>

This allows for very simple and nice composition of templates. Additionally, passing around all the template data explicitly like this makes it easier to stay sane.

Tags: PHP

PLT Scheme

Tue, 18 May 2010 00:12:20 +0200

PLT Scheme is a programming language based on Scheme

Implementing Your Own Control Structures in Scala

Mon, 17 May 2010 02:17:50 +0200

I just discovered that Scala has the necessary power to handle implemention of custom control structures without any ugliness. The secret ingredient is that Scala has call-by-name parameters. Here’s an example (note the =>):

def unless[A](condition: Boolean, ifFalse: => A, ifTrue: => A) =
  if (condition) ifTrue else ifFalse

Demonstration: Scala won’t evaluate ifFalse or ifTrue unless necessary, like here:

unless(true, throw new Error, "Hello!") 
=> "Hello!"

Sweet!

Tags: Scala