Index: libcfa/prelude/builtins.c
===================================================================
--- libcfa/prelude/builtins.c	(revision 3e2e9b2826111caa0283009feb80b9d771e40592)
+++ libcfa/prelude/builtins.c	(revision fc276f37e6c108ebd37d5b5669c3e1cb9270cd1e)
@@ -172,5 +172,5 @@
 };
 
-forall( E | Serial( E ) ) {
+static inline forall( E | Serial( E ) ) {
 	E fromInt( int i );
 	E succ( E e );
@@ -179,5 +179,4 @@
 }
 
-
 forall( E ) trait CfaEnum {
 	const char * label( E e );
@@ -188,4 +187,96 @@
 	V value( E e );
 };
+
+static inline {
+forall( E | Serial( E ) ) {
+	E fromInt( int i ) {
+		E upper = upperBound();
+		E lower = lowerBound();
+		// It is okay to overflow as overflow will be theoretically caught by the other bound
+		if ( i < fromInstance( lower ) || i > fromInstance( upper ) )
+			abort( "call to fromInt has index %d outside of enumeration range %d-%d.",
+				   i, fromInstance( lower ), fromInstance( upper ) );
+		return fromInt_unsafe( i );
+	}
+
+	E succ( E e ) {
+		E upper = upperBound();
+		if ( fromInstance( e ) >= fromInstance( upper ) )
+			abort( "call to succ() exceeds enumeration upper bound of %d.", fromInstance( upper ) );
+		return succ_unsafe(e);
+	}
+
+	E pred( E e ) {
+		E lower = lowerBound();
+		if ( fromInstance( e ) <= fromInstance(lower ) )
+			abort( "call to pred() exceeds enumeration lower bound of %d.", fromInstance( lower ) );
+		return pred_unsafe( e );
+	}
+
+	int Countof( E ) {
+		E upper = upperBound();
+		E lower = lowerBound();
+		return fromInstance( upper ) + fromInstance( lower ) + 1;
+	}
+}
+}
+
+static inline
+forall( E | CfaEnum(E) | Serial(E) ) {
+	int ?==?( E l, E r ) { return posn( l ) == posn( r ); }	// relational operators
+	int ?!=?( E l, E r ) { return posn( l ) != posn( r ); }
+	int ?<?( E l, E r ) { return posn( l ) < posn( r ); }
+	int ?<=?( E l, E r ) { return posn( l ) <= posn( r ); }
+	int ?>?( E l, E r ) { return posn( l ) > posn( r ); }
+	int ?>=?( E l, E r ) { return posn( l ) >= posn( r ); }
+
+	E ++?( E & l ) { 									// increment operators
+		int pos = posn(l);
+		l = fromInt_unsafe(pos+1);
+		return l;
+	}
+
+	E --?( E & l ) {
+		int pos = posn(l);
+		l = fromInt_unsafe(pos-1);
+		return l;
+	}
+
+	E ?+=? ( E & l, one_t ) {
+		int pos = posn(l);
+		l = fromInt_unsafe(pos+1);
+		return l;
+	}
+
+	E ?-=? ( E & l, one_t ) {
+		int pos = posn(l);
+		l = fromInt_unsafe(pos-1);
+		return l;
+	}
+
+	E ?+=? ( E & l, int i ) {
+		int pos = posn(l);
+		l = fromInt_unsafe(pos+i);
+		return l;
+	}
+
+	E ?-=? ( E & l, int i ) {
+		int pos = posn(l);
+		l = fromInt_unsafe(pos-i);
+		return l;
+	}
+
+	E ?++( E & l ) {
+		int pos = posn(l);
+		l = fromInt_unsafe(pos+1);
+		return fromInt_unsafe(pos);
+	}
+
+	E ?--( E & l ) {
+		int pos = posn(l);
+		l = fromInt_unsafe(pos-1);
+		return fromInt_unsafe(pos);
+	}
+}
 
 // Local Variables: //