Erlang: The problem with being "new"

So you spend 5/10 years learning X, but start to think it might not be the best solution for every problem, You have heard Y is good for solving your new problem, so you give it a shot, skim over some blogs, maybe even spend an afternoon learning it. After while you get fustrated, things that you can do easily in X are suddenly hard and fustrating in Y, you cant recognise the wierd interface. Conclusion: it must be a terrible language / application / etc.

One of the most popular opinions I find on Erlang is that it looks like an amazing platform, but not a very nice language. Since I had a similiar opinion when coming to Erlang (from primarily PHP and Java), I thought I would post comparable snippets to show why I now enjoy programming in Erlang.

Problem:

Code a simple chat message handler, define a simple function that takes parsed input, and calls the function relating to that command. if the message isnt one of the valid format, throw an exception. The 3 valid inputs in both languages are :

Erlang :                           PHP : 
handle({enter,"user"})             handle(array(ENTER,"user"))
handle({leave,"user"})             handle(array(LEAVE,"user"))
handle({message,"user","message"}) handle(array(MESSAGE,"user","message"))

PHP Solution :

define("ENTER",   1);
define("LEAVE",   2);
define("MESSAGE", 3);

function handle($cmd)
{
  if(is_array($cmd) && ($count = count($cmd)) > 1)
  {
      if($cmd[0] == ENTER && $count == 2) 
        return enter($cmd[1]);
      else if($cmd[0] == LEAVE && $count == 2) 
        return leave($cmd[1]);
      else if($cmd[0] == MESSAGE && $count == 3) 
        return message($cmd[1],$cmd[2]);
  }
  throw new Exception('Invalid Message');
}

Erlang Solution :

handle({enter,User})       -> enter(User);
handle({leave,User})       -> leave(User);
handle({message,User,Msg}) -> message(User,Msg);
handle(_)                  -> throw("Invalid Message").

The example illustrates a small benefit of pattern matching which is at the heart of Erlang. Some things new users might see as 'warts' are often powerful features, and a few hours introduction into a language is never going to match the cumulative experience gained in years of writing applications.

Comments

function handle($cmd) {
  try {
    switch ( $cmd[0] ) {
      case 1:  return enter ( $cmd[1] );
      case 2:  return leave ( $cmd[1] );
      case 3:  return message ( $cmd[1], $cmd[2] );
    }
  } catch(e) { }
  throw new Exception ( 'Invalid Message' );
}

ENTER   = 1
LEAVE   = 2
MESSAGE = 3

def handle_enter(user):
    print 'enter', user

def handle_leave(user):
    print 'leave', user

def handle_message(user, msg):
    print 'message', user, msg

handlers = {
    ENTER:    handle_enter,
    LEAVE:    handle_leave,
    MESSAGE:  handle_message,
}

def handle(cmd, *args):
    f = handlers.get(cmd)
    if not f:
        raise Exception("Invalid Message")
    return f(*args)

** exception error: no function clause matching 
module:handle(your,"madeupparams")

define('ENTER',   1);
define('LEAVE',   2);
define('MESSAGE', 3);

function handle(array $cmd) {
  switch (array(array_shift($cmd), count($cmd))) {
    case array(ENTER, 1):   $handler = 'enter';   break;
    case array(LEAVE, 1):   $handler = 'leave';   break;
    case array(MESSAGE, 2): $handler = 'message'; break;
    default: throw new Exception('Invalid Message');
  }
  return call_user_func_array($handler, $cmd);
}

Post a Comment