Finite automata in erlang... well, in perl

I've been hacking some erlang after the third class with Johan Montelius. Last lecture was about failure handling, exeptions, linking and monitoring processes.

I've been tempted to translate some classical problems of concurrent or parallel computing to erlang. First chapters in some books are about what they call LTSA. They are mostly state machines, that can be composed, concatenated, intersected, and some other operation.


At first, I started doing an erlang little program that has three states, and receives messages to travel from one state to other.

Here's the basic code for the hello->converse->goodbye LTSA

	-module (test3).
	-export ([start/0 , f0/0]).
	start () ->
	Pid = spawn_link(test3,f0,[]),
	loop (Pid).
	loop (Pid) ->
	Pid ! (string:strip(io:get_line ("msg: "),right, $\n)),
	loop (Pid).
	f0() ->
	io:format ("~w~n", [self()]),
	io:format ("0~n"),
	receive
	"hello" -> f1();
	_ -> f0 ()
	end.
	f1 ()->
	io:format ("1~n"),
	receive
	"converse" -> f2 ();
	_ -> f1 ()
	end.
	f2 ()->
	io:format ("2~n"),
	receive
	"goodbye" -> bye;
	_ -> f2 ()
	end.

view raw test3.erl hosted with ❤ by GitHub

Theres's a couple of things to note here:

• Erlang syntax is a bit tricky. so many different line endings (, ; . nothing).
• It's an ad-hoc code, but it follows a clear pattern.
  

Then, I thought about going meta. Why can't we build a program builder, that with a simplifyed input of our desired behaviour, writes erlang code?

I've used perl to hack a simple script that builds the code structure (or the whole program depending on your needs). I won't have to tell you it's quite unstable, and you can make it produce failing codes. Of course, it's quite shaky, but well... Just for the fun of it.

Try it, play with it, break it, or fix it. I don't think it can be useful for anything in this state, but maybe implementing composing functions...

For the moment the program just gets information on states, transitions, and destination states.
Then it builds a function for every state, and builds a receive statement, with each possible transition, and and ending _ -> fun to discard unrecognized messages. Keep in mind it won't keep order, so non disjoint cases aren't guaranteed to work. When entering a function, it's name (and actual parameters) are printed on the screen.

	#!/usr/bin/perl
	#Raimon Grau Cuscó <raimonster AT gmail DOT com>
	use strict;
	use warnings;
	use Data::Dumper;
	=head2 selectSignature
	returns the arguments to io:format to print the actual parameters
	of the function
	=over 4
	=item Arguments
	$fun is the function signature. For example:
	a() , a(X) or a({X,[1 ,2 , B] , atom} , hello)
	=back
	=cut
	sub selectSignature {
	my ($fun) =@_;
	return qq|"$fun~n"| if ($fun =~ m/\(\s*\)/); # no arguments
	#strip fun name and parameters
	(my $signature = $fun) =~s/.*\(/\(/;
	$signature =~ s/\).*/\)/;
	my $complSig = $signature;
	$signature =~ s/\[[^]]*\]//g;
	$signature =~ s/\{[^]]*\}//g;
	return qq|"$fun ~w ~n",[$complSig]| if ($signature !~ /,/); # 1 parameter (no commas)
	return "$fun ". ('~w ' x split(/,/ , $signature)) . ", [ $complSig ]"; #many params
	}
	#gets the states and transitions:
	# state | message | nextState
	my $funs;
	my $first = undef;
	while (<DATA>) {
	chomp;
	my @parts = split /\s*\|\s*/;
	$funs->{$parts[0]}->{$parts[1]} = $parts[2] ;
	$first ||= $parts[0];
	}
	print <<"EOF";
	-module(test).
	-export([start/0, f0/0]).
	start () ->
	Pid = spawn_link(test,f0,[]),
	loop (Pid).
	loop (Pid) ->
	Pid ! list_to_atom(string:strip(io:get_line ("msg: "),right, \$\\n)),
	loop (Pid).
	f0()-> $first .
	EOF
	for my $f (keys %$funs) {
	my $sign = selectSignature($f);
	my $code = <<EOC;
	$f ->
	\tio:format($sign),
	\treceive
	EOC
	for (keys %{$funs->{$f}}) {
	$code .= "\t\t$_ -> " . $funs->{$f}->{$_} . ";\n";
	}
	# chomp $code;
	# chop $code;
	$code .= "\t\t_ -> $f";
	$code .= "\n";
	$code.= "\tend.\n";
	print $code;
	}
	__DATA__
	a() | m | b()
	a() | accum | a(0)
	a(X) | add | a(X+1)
	a(X) | sub | a(X-1)
	a(X) | quit | a()
	a() | caca | c()
	b() | ma | c()
	c() | quit | notexists:notexists()

view raw generlator.pl hosted with ❤ by GitHub

Yeah, the perl syntax highlight problem... try here to see a hightlighted version.

Check out my other erlang posts