λ Tony’s blog λ

I want you to imagine a scenario for me.

Did you know that carrying a Tiger’s Eye crystal provides protection and clearer thought? Yeah OK I agree, all that crystal healing stuff is just silly nonsense that essentially exists to provide a placebo effect. This doesn’t stop some people from genuinely believing in the healing properties of crystals of course — and they are certainly being exposed to a bias of confirmation. This is because a critical failure of rational faculties has occurred somehow — you and I see straight through it; it’s obviously nonsense! But they seek peer reinforcement for their mistake and have a hard time understanding what it is like to not believe in the healing properties of crystals.

If it is so blatantly false, then why do some apparently intellectually-equipped people swear by it?

Now suppose you were invited to be healed by a crystal healer and you decline because you have other relevant tasks to achieve. What would you say when asked why the declination? You wouldn’t want to insult the questioner — that they believe such a ridiculous proposition doesn’t compel you to simply insult their person, however, if you were to answer the question honestly, they would take offence. You’re caught in a pickle now, so what then? Dishonesty? Appeasing their fantasy?

Would you answer with a question, “I don’t believe crystal healing is effective, because there is no empirical data to suggest it is so. Can you show me otherwise?” to which they respond, “Sure! We use a process of high energy physics photography to derive our scientific conclusions.” So what now? They just provide more bunk — again, you and I see straight through it. You can make no progress. The only reasonable conversation you can have is one about how to deduce true facts in general.

But it gets worse, now imagine that the invitation to the crystal healing session requires that you drink frog poison upon entry, because the ancient Egyptians did it to appease the Gods with a small personal sacrifice. In this scenario, 150 people die each year from ingestion of frog poison, but the crystal healers put this down to anger from the Gods that must only be appeased further, otherwise it will be 300!

At this point, you now object to attendance on the grounds that it is detrimental to your health. Furthermore, you may even feel a moral obligation toward anybody else who has been coaxed into this form of abuse. You’re in a really big pickle now aren’t you?

This is exactly the pickle I am in when you try to peddle your pseudoscience onto me. I don’t want to insult you, but I don’t want to suffer the adverse effects of your crack-pottery. Furthermore, I don’t want other people, who have been tricked (as you have been), to suffer — I feel compelled to warn them against it. Again, not to offend you (though it might), but because I have a deep sense of empathy for all people, including you.

On the other hand, I could do what a lot of us non-crystal-healers do and be proactive in completely ignoring your existence wherever possible but that doesn’t take away from my sense of empathy.

Much of my work is in Scala or Haskell. Lately, it is mostly in Scala. Sometimes I have the unfortunate imposition to use Java by a false authority. This is where Functional Java is handy — in an attempt to make Java somewhat practical, even if only to a small degree.

JetBrains has granted Functional Java an open source licence to use their IntelliJ IDEA. I recently downloaded the 8.1 version and started working on some of the Scala components of Functional Java.

It is pleasing to have a usable IDE that is easy to install on my 64-bit Linux machine. It is more pleasing that the Scala plugin has all the required fundamental features and few bugs. I also use a 32-bit machine running Linux and it was just as much a breeze to install and use there. Of course, I do not use Compiz on these machines, since it screws up swing applications. I do, however, use xmonad window manager, which boosts productivity quite a lot.

The Scala plugin has the much desired “Go to declaration”, is able to report many compile-time errors — though not all and I expect I push Scala a bit harder than many others in terms of finding quirks in the language. It has many other features — some of which need a bit of work, but many of which are significantly ahead of other IDEs, particularly when it comes to stability.

Thanks JetBrains for making it viable to use advanced programming concepts in a capable programming language.

A co-variant binary functor (aka bifunctor) is any type constructor with a kind * -> * -> * that can satisfy identity and composition when mapping on either type variable. A couple of examples of bifunctors in the Scala library are

• Tuple2
• Either

Note that Function1 is not a bifunctor, evident by the fact that it is contra-variant in its first type variable. It is notable that Tuple2 represents conjunction while Either represents the disjunction of two theorems under the Curry-Howard Isomorphism (Function1 represents implication).

F[A, B] => (A => C) => (B => D) => F[C, D]

trait Bifunctor[F[+_, +_]] {
  def bimap[A, B, C, D](fa: F[A, B], f: A => C, g: B => D): F[C, D]
}
 
object Bifunctor {
  implicit def Tuple2Bifunctor = new Bifunctor[Tuple2] {
    def bimap[A, B, C, D](fa: (A, B), f: A => C, g: B => D) = 
      (f(fa._1), g(fa._2))
  }
 
  implicit def EitherBifunctor = new Bifunctor[Either] {
    def bimap[A, B, C, D](fa: Either[A, B], f: A => C, g: B => D) = 
      fa match {
        case Left(a) => Left(f(a))
        case Right(b) => Right(g(b))
      }
  }
}

obj.::(arg) 
arg :: obj

trait BifunctorW[F[+_, +_], A, B] {
  val value: F[A, B]
  val bifunctor: Bifunctor[F]
 
  def <-:->[C, D](f: A => C, g: B => D) = bifunctor.bimap(value, f, g)
 
  def <-:[C](f: A => C) = bifunctor.bimap(value, f, identity[B])
 
  def :->[D](g: B => D) = bifunctor.bimap(value, identity[A], g)
}
 
object BifunctorW {
  // a somewhat verbose but handy trick
  // for partially applying type variables.
  def bifunctor[F[+_, +_]] = new BifunctorApply[F] {
    def apply[A, B](v: F[A, B])(implicit b: Bifunctor[F]) = 
        new BifunctorW[F, A, B] {
      val value = v
      val bifunctor = b
    }
  }
 
  trait BifunctorApply[F[+_, +_]] {
    def apply[A, B](v: F[A, B])(implicit b: Bifunctor[F]): BifunctorW[F, A, B]
  }
 
  implicit def Tuple2Bifunctor[A, B](v: (A, B)) = 
    bifunctor[Tuple2](v)
 
  implicit def Either2Bifunctor[A, B](v: Either[A, B]) = 
    bifunctor[Either](v)
}

object Main {
  def main(args: Array[String]) {
    import BifunctorW._
 
    val x: Either[Int, String] = Left(7)
    val y = ("hello", 42)
 
    val f = (n: Int) => n + 1
    val g = (s: String) => s.reverse
    val h = (s: String) => s.toUpperCase
    val i = (n: Int) => n * 2
 
   // Pretty neat eh?
    val p = f <-: x :-> g
    val q = h <-: y :-> i
 
    // $ scala Main
    // Left(8)
    // (HELLO,84)
    println(p)
    println(q)
  }
}