eval allows arbitrary strings to be treated as code, so here’s what I came up with:

def bm_help(l)
  mags = [100, 1000, 10000, 100000, 1000000]
  mags.each do |order|
    puts "\nBENCHMARKING ARRAYS OF SIZE " + order.to_s
    testFwd = (1..order).to_a
    testRev = testFwd.reverse
    testRnd = testFwd.shuffle

    l.each do |name|
      puts ("\n" + name)
      Benchmark.bm(8) do |x|
        x.report("random: ") do
          eval ("testRnd." + name)
        end
        x.report("reverse: ") do
          eval ("testRev." + name)
        end
        x.report("inorder: ") do
          eval ("testFwd." + name)
        end
      end
    end
  end
end

bm_help ["quicksort", "shellsort", "mergesort", "heapsort", "insertionsort", "bininsertionsort"]

I realize that this doesn’t give much in the way of explanation, but if anyone has questions, just comment and I’ll post clarifications.

With that said, we will make use of a contrived example for the sake of simplicity . I don’t seem to have code highlighting, so apologies in advance for that; however, this post is a Literate Haskell file, so you can copy this into a plaintext file and all will be well.

To start off, we enable the existential quantification extension:

> {-# LANGUAGE ExistentialQuantification #-}

Existentially quantified datatypes essentially allow you to hide the type values of a datatype’s parameters from the outside world. As a simple example, consider the following:

> data Thingum a = forall b. Show b => Thing b a

Ignoring the “forall b. Show b =>” segment for a moment, notice that a type variable b is used in the type constructor Thing but doesn’t appear in the datatype’s type signature. Indeed, if we examine the kind of Thingum, we’ll notice something odd: Thing has the kind (* -> *)! If we write Thingum as “data Thingum a b = Thing b a”, (b being an instance of Show doesn’t really matter for kinds), then the kind comes out as (* -> * -> *). What each * on the left hand of an arrow denotes is a “slot” for a type that needs to be filled in in order for us to get any real result out of calculations involving this type. Thus, with our existentially quantified datatype, the data of type b inside of Bm is essentially inaccessible outside of Bm. This is where “forall b. Show b =>” comes in. By declaring that the type variable b must be an instance of show, we can, in a limited way, interact with b. Here’s what I mean demonstrated through an example:

We’ll declare a new type Foo:

> data Foo = forall a. Test a

So far so good. In fact, this is rather exciting! We can put any type of “a” we want into this datatype! Congratulations, we just bypassed Haskell’s type system! Well, not really. Can you think of why? Here’s a hint: think about what happens when we want to free our type from its Test container.

Let’s define a function to do just that:

> bar :: Foo -> a

> bar (Test x) = x

Uhhh… well what is the x? And why isn’t this compiling? Is x a String? Is it an Int? Is it a function? Now that we have this value, what can we do with it? Well, with just this code, we can’t really do anything with it because we can’t know what functions can accommodate x as a parameter. This is why we need the value to be of a type that has is an instance of a typeclass, such as “forall b. Show b” in our first example. (Note that the forall in this context simply gives the compiler a hint that we explicitly want b to be existentially quantified in our datatype). Now, Haskell has a fact about b that it can work with. We know that when all is said and done, we can convert b into a String and do something useful with it. We can toss any showable thing we want into the b slot, and when we decide we want to read about it, we are able to because the compiler can verify that show works at compile time:

> showHidden (Thing showMe _) = show showMe

Bam! We’ve freed our b from its chains, and have done so in a typesafe way. However, the only way out for a value of type b in this example is through the show function. So,  unless you only intend to be using b as a string, it would be prudent to ensure that the typeclass instance that you use can fully support the features you need.

I’ll leave it to your imagination to come up with more interesting uses for this, but this just about covers the basics. Feel free to comment with any interesting uses of existentially qualified types. I’d love to see what people do with these odd extensions to Haskell98.

It appeals to me artistically, architecturally, and philosophically. The standard Western mindset maintains an intense focus upon consumerism and materialism, stressing that fulfillment comes through accumulating wealth and expending that wealth on goods and entertainment. I find this entire mindset terribly disturbing, if only because of the fact that the urge to obtain the latest and greatest powerfully grips me from time to time, urging me to forsake contentment in favor of placing my nose to the grindstone just to obtain something I will rarely use and previously didn’t even know I needed. However, consumerism isn’t content to stop just at inducing our pack-rat tendencies; the widespread growth of internet communications encourages what I’ll term informational consumerism. Email, Twitter, Facebook, Blogs, reddit, and Wikipedia place near-limitless amounts of information at our fingertips. These facilities in moderation have the power to be incredibly useful, but for many have grown into subconsciously compulsive obsessions.

A bored person coupled with an internet connection provide a new realm for consumerism that brings out the same pathological tendencies that Western society has dealt with for the last seventy years when dealing with material goods. I’ve learned from experience the veracity of this.

Much as a shopping channel addict can’t help but whip out a phone and credit card at the words “BUY NOW!”, for several years I have struggled with getting things done in the face of the internet. Without thinking, I would find myself absently typing in facebook.com, closing the tab after ascertaining that nothing new had occurred, only to immediately open a new tab and go to Facebook once more. As I discovered Digg, reddit, and more, I found that more and more of my time was spent refreshing pages obsessively.

I know that this is not just me. As a resident assistant at a college dorm, as I walk down the halls I see room after room of guys sitting in front of the computer, absently clicking away as a means of avoiding homework. Unlike most addictions, the internet is nearly impossible to get away from. It is from this perspective that I espouse minimalism as a very necessary tool for surviving the modern world; A quiz testing one’s knowledge about Disney characters, another Lolcat, or another chainmail from Uncle Rudolph is in fact rather detrimental to living well.

These distractions take our focus away from the real work and play in our lives. As I have stripped down mailing list subscriptions, ruthlessly blocked addictive websites on my computer, deleted old bookmarks, uninstalled rarely used applications and more, I have felt a burden lift from my shoulders. The tension of having to cram in work and play in between multiple-hour sessions of reddit browsing is at an end. The apathy about checking my email is gone, because I don’t have to wade through piles of junk just to find important emails.

I could say more, but instead I’ll heartily recommend Minimal Mac and mnmlist.com for inspiration and ideas. Even if you don’t face these problems in a computer-oriented environment, I strongly recommend taking an area in life that feels sluggish and unproductive and stripping out everything but the essentials and giving the Minimalist approach a try. It can do wonders.