Jon Harrop said:
Functional programming languages are divided into purely functional
(Miranda, Clean, Haskell etc.) and impure (Lisp, Scheme, Erlang, OCaml,
Standard ML, F#, Scala, Nemerle etc.).
let parse_command (state, para, doc as accu) line =
I wrote a purely functional parser in Java once for fun.
That is, all assignments are final, thus, there are no
storage modifications. No side effects used anywhere
(except in the test code and in the debug code, which
does the side-effect of printing.) Code is given below.
The building scheme of the »functional« methods
of the scanner and parser below is always like:
let x0 = ...
x1 = ...
x2 = ...
in ...
which, in Java, is written as
{ final x0 = ...;
final x1 = ...;
final x2 = ...;
return ...; }
(When replying to my post, please do not quote my complete
post, but only those parts you directly refer to.
Especially, please do not quote the complete source code.)
public class List
{
// implementation of a dotted pair
private final int car; private final List cdr;
List( final int car, final List cdr ){ this.car = car; this.cdr = cdr; }
// That was the actual class »List«
// The rest are static methods.
// support for lists
private static final boolean DEBUG = false;
static List cons( final int car, final List cdr )
{ return new List( car, cdr ); }
static int fst( final List l ){ return l == null ? INVALID : l.car; }
static List rest( final List l ){ return l == null ? null : l.cdr; }
static int snd( final List l ){ return fst( rest( l )); }
static int caddr( final List l ){ return fst( rest( rest( l ))); }
static List cddr( final List l ){ return rest( rest( l )); }
static List cdddr( final List l ){ return rest( cddr( l )); }
static String prints( final List l )
{ return l == null ? "" : "" + name( fst( l ))+ ", " + prints( rest( l )); }
static List print( final List l )
{ if( DEBUG )System.out.println( "( "+ prints( l ) + " )" ); return l; }
static List print( final String s, final List l )
{ if( DEBUG )System.out.println( s + "( "+ prints( l ) + " )" ); return l; }
// main with some test cases
public static void main( String[] args )
{ System.out.println( "" + evaluate( "(3+4)*2" ) + " [14]." );
System.out.println( "" + evaluate( "2*10" ) + " [20]." );
System.out.println( "" + evaluate( "(9+9)*9+9" ) + " [171]." );
System.out.println( "" + evaluate( "3*(4+5)" ) + " [27]." );
System.out.println( "" + evaluate( "3*(4*5)" ) + " [60]." );
System.out.println( "" + evaluate( "3*(4+5)*2" ) + " [54]." );
System.out.println( "" + evaluate( "3*(4*5)+2" ) + " [62]." );
System.out.println( "" + evaluate( "1+1+1+1+1+1" ) + " [6]." );
System.out.println( "" + evaluate( "2*2*2*2*2*2" ) + " [64]." );
System.out.println( "" + evaluate( "1+1+(2*2*2)+1+1" ) + " [12]." );
System.out.println( "" + evaluate( "1+1+(1+1+1)+1+1" ) + " [7]." );
System.out.println( "" + evaluate( "2*2*(2+2+2)*2*2" ) + " [96]." );
System.out.println( "" + evaluate( "2*2*(2*2*2)*2*2" ) + " [128]." );
System.out.println( "" +
evaluate( "2*2*((1+1)*2*2)*2*2" ) + " [128]." );
System.out.println( "" +
evaluate( "2*2*(2*(1+1)*2)*2*2" ) + " [128]." );
System.out.println( "" +
evaluate( "2*2*(2*2*(1+1))*2*2" ) + " [128]." );
System.out.println( "" +
evaluate( "2*2*(2*(1+1)*(1+1))*2*2" ) + " [128]." );
System.out.println( "" +
evaluate( "2*2*((1+1)*(1+1)*2)*2*2" ) + " [128]." );
System.out.println( "" +
evaluate( "2*2*((1+1)*(1+1)*(1+1))*2*2" ) + " [128]." );
System.out.println( "" +
evaluate( "0+2*2*((1+1)*(1+1+0)*(1+1))*2*2+0" ) + " [128]." );
System.out.println( "" +
evaluate( "10+2*2*((1+1)*(1+1+0)*(1+1))*2*2+10" ) + " [148]." );
System.out.println( "" +
evaluate( "10+2*2*((1+1)*(1+1+0)*(1+1))*2*2+100" ) +
" [238]." ); }
// the evaluator
static int evaluate( final String string )
{ return fst( expression( tokenize( string ))); }
// syntactical analyzer
static List expression( final List arg )
{ final List tokens = term( arg );
final int term = fst( tokens );
final int operator = snd( tokens );
final List tail = cddr( tokens );
final List tailval = operator == PLUS ? expression( tail ) : null;
return tail == null ? cons( term, null ) :
operator == PLUS ? cons( term + fst( tailval ), rest( tailval )) :
operator == R_PAREN ? cons( term, tail ) : null; }
static List term( final List arg )
{ final List pair = factor( arg );
final int result = fst( pair );
final List tokens = rest( pair );
final List tail = rest( tokens );
final List tailval = factor( tail );
return tail == null ? cons( result, null ) :
fst( tokens ) == MUL ?
term( cons( result * fst( tailval ), rest( tailval ))) :
cons( result, tokens ); }
static List factor( final List arg )
{ final int result = fst( arg );
final List tokens = rest( arg );
return result >= NUMBER ? cons( result, tokens ) :
result == L_PAREN ? expression( tokens ) : null; }
// support for the lexical analyzer
static int numlen( final String s )
{ final boolean done = s.equals( "" );
final boolean valid = !done;
final String r = valid ? s.substring( 1, s.length() ): "";
final char c = valid ? s.charAt( 0 ): 0;
final boolean isdigit = Character.isDigit( c );
return done ? 0 : isdigit ? 1 + numlen( r ) : 0; }
static int max( final int i, final int j )
{ return i > j ? i : j; }
// The lexical analyzer
static final int NUMBER = 0;
static final int INVALID = -1;
static final int PLUS = -2;
static final int MUL = -3;
static final int L_PAREN = -4;
static final int R_PAREN = -5;
static String name( final int l )
{ return l >= NUMBER ? "" + l : l == INVALID ? "INVALID" :
l == PLUS ? "PLUS" : l == MUL ? "MUL" : l == L_PAREN ? "L_PAREN" :
l == R_PAREN ? "R_PAREN" : "(UNKNOWN)"; }
static List tokenize( final String s )
{ final boolean done = s.equals( "" );
final boolean valid = !done;
final String r =
valid ? s.substring( max( 1, numlen( s )), s.length() ): "";
final char c = valid ? s.charAt( 0 ): 0;
final boolean isdigit = Character.isDigit( c );
final int d = isdigit ?
Integer.valueOf( s.substring( 0, numlen( s ))).intValue() : 0;
return done ? null : cons
( ( isdigit ? d : c == '+' ? PLUS : c == '*' ? MUL :
c == '(' ? L_PAREN : c == ')' ? R_PAREN : INVALID ),
tokenize( r )); }}
/*
171 [171].
27 [27].
60 [60].
54 [54].
62 [62].
6 [6].
64 [64].
12 [12].
7 [7].
96 [96].
128 [128].
128 [128].
128 [128].
128 [128].
128 [128].
128 [128].
128 [128].
128 [128].
148 [148].
238 [238].
*/
When replying to my post, please do not quote my complete
post, but only those parts you directly refer to.
Especially, please do not quote the complete source code.
