Wednesday, July 28, 2010

Keywords by Language

Keywords (Reserved Words) Repository

The updated list will always be in the "Keywords" Page at the top of this blog (

Keywords: 102

abstract event new struct as explicit null switch base extern 
object this bool false operator throw break finally out true
byte fixed override try case float params typeof catch for 
private uint char foreach protected ulong checked goto public unchecked
class if readonly unsafe const implicit ref ushort continue in 
return using decimal int sbyte virtual default interface sealed volatile
delegate internal short void do is sizeof while double lock 
stackalloc else long static enum namespace string add alias ascending 
descending dynamic from get global group into join let orderby 
partial remove select set value var where yield __arglist __makeref 
__reftype __refvalue
Keywords: 137

AddHandler AddressOf Alias And AndAlso Ansi As Assembly Auto Boolean 
ByRef Byte ByVal Call Case Catch CBool CByte CChar CDate
CDec CDbl Char CInt Class CLng CObj Const CShort CSng 
CStr CType Date Decimal Declare Default Delegate Dim DirectCast Do
Double Each Else ElseIf End Enum Erase Error Event Exit 
False Finally For Friend Function Get GetType GoSub GoTo Handles
If Implements Imports In Inherits Integer Interface Is Let Lib 
Like Long Loop Me Mod Module MustInherit MustOverride MyBase MyClass
Namespace New Next Not Nothing NotInheritable NotOverridable Object On Option 
Optional Or OrElse Overloads Overridable Overrides ParamArray Preserve Private Property
Protected Public RaiseEvent ReadOnly ReDim REM RemoveHandler Resume Return Select 
Set Shadows Shared Short Single Static Step Stop String Structure
Sub SyncLock Then Throw To True Try TypeOf Unicode Until 
Variant When While With WithEvents WriteOnly Xor
Keywords: 84

asm auto bool break case catch char class const const_cast
continue default delete do double dynamic_cast else enum explicit export 
extern false float for friend gcnew goto if inline int
long mutable namespace new nullptr operator pin_ptr private protected public 
register reinterpret_cast restrict return safe_cast short signed sizeof static static_cast 
struct switch template this throw true try typedef typeid typename 
_typeof union unsigned using virtual void volatile wchar_t while each
interface value abstract delegate event finally generic in initonly literal 
override property sealed where
Keywords: 97

abstract and as assert base begin class default delegate do
done downcast downto elif else end exception extern false finally
for fun function global if in inherit inline interface internal
lazy let match member module mutable namespace new not null
of open or override private public rec return static struct
then to true try type upcast use val void when
while with yield asr land lor lsl lsr lxor mod 
sig atomic break checked component const constraint constructor continue eager 
event external fixed functor include method mixin object parallel process
protected pure sealed tailcall trait virtual volatile
Keywords: 66

abstract and as AST break callable cast char class constructor
continue def destructor do elif else ensure enum event except
failure final from for false get given goto if import
in interface internal is isa not null of or otherwise
override namespace partial pass public protected private raise ref retry
return self set super static struct success transient true try
typeof unless virtual when while yield 
Keywords: 92

and or xor exception array as break case class const 
continue declare default die do echo else elseif empty enddeclare 
endfor endforeach endif endswitch endwhile eval exit extends for foreach 
function global if include include_once isset list new print require 
require_once return static switch unset use var while final interface 
implements instanceof public private protected abstract clone try catch throw 
this namespace goto __LINE__ __FILE__ __FUNCTION__ __CLASS__ __METHOD__ __DIR__ __NAMESPACE__
import using object string int int64 double bool resource TRUE
FALSE NULL virtual unset parent __destruct __get __set __call __sleep
__wakeup __tostring
IronPython & Jython
Keywords: 31

and del from not while as elif global or with
assert else if pass yield break except import print class 
exec in raise continue finally is return def for lambda 
IronRuby & JRuby
Keywords: 38

alias and BEGIN begin break case class def defined do
else elsif END end ensure false for if in module
next nil not or redo rescue retry return self super
then true undef unless until when while yield
Delphi Prism
Keywords: 134

and as assembly begin break case class const constructor continue 
delegate div do downto else end ensure event except exit 
false finalizer finally for forward function future if implementation in 
inherited interface invariants is locking loop method mod module namespace 
new nil not nullable of old on operator or out 
parallel private procedure property protected public raise record repeat require 
result self set shl shr then to true try type 
unit until uses using var where while with xor yield
abstract add array async default each empty enum external final 
finalizer flags global has implements implies index inline iterator locked 
matching nested notify override params partial pinned read readonly reintroduce 
remove sealed sequence static step unsafe virtual where write asc 
desc distinct equals from group by into join on order
reverse select skip take
Keywords: 50

accept activity array as await begin by case const definition 
div do else elsif end exception exit false for if
implementation implements import in is loop mod module new nil 
object of on operator or procedure protocol record refines repeat 
return self termination then to true type until var while
Keywords: 59

_ abstract and array as base catch class def delegate 
do else enum event extern false finally for foreach fun 
if implements in interface internal lock macro match module mutable namespace 
new null out override params private protected public ref sealed 
static struct syntax this throw true try type typeof unless 
using variant virtual void when where while assert ignore
Keywords: 57

abstract as assert boolean break byte case catch char class
const continue def default do double else enum extends false
final finally float for goto if implements import in instanceof
int interface long native new null package private protected public
return short static strictfp super switch synchronized this threadsafe throw
throws transient true try void volatile while
Keywords: 50

abstract continue for new switch assert default goto package synchronized
boolean do if private this break double implements protected throw
byte else import public throws case enum instanceof return transient 
catch extends int short try char final interface static void
class finally long strictfp volatile const float native super while
Keywords: 139

abstract fake internal new nonvirtual private protected public shared override 
partial virtual vari inout out adds all and any as 
assert body branch break callable catch class const continue cue 
def do dynamiceach else end ensure enum event every except 
extend finally for from get has if ignore implements implies 
in inherits inlined interface invariant is listen lock mixin must 
namespace not objc of old on or pass passthrough post 
print pro raise ref require return same set sig stop 
struct success test throw to trace try using var where 
while yield true false nil use import base this Array 
char Color decimal dynamic DateTime Dictionary Exception float float32 float64 
int int8 int16 int32 int64 ICloneable IComparable IDictionary IEnumerable IList 
List number Object Queue Set Stack StreamReader StreamWriter String StringBuilder 
StringReader StringWriter TextReader TextWriter uint uint8 uint16 uint32 uint64
Keywords: 46

abstract as assert break case catch class const continue default
do else enum false final finally for foreach if internal
is isnot it mixin native new null once override private
protected public readonly return static super switch this throw true
try using virtual volatile void while
Keywords: 75

break case catch class const continue debugger default delete do
else export extends false finally for function if import in
instanceof new null protected return super switch this throw true
try typeof var while with abstract boolean byte char decimal
double enum final float get implements int interface internal long
package private protected public sbyte set short static uint ulong
ushort void assert ensure event goto invariant namespace native require 
synchronized throws transient use volatile
Keywords: 40

abstract case catch class def do else extends false final
finally for forSome if implicit import lazy match new null
object override package private protected requires return sealed super this 
throw trait try true type val var while with yield
Keywords: 70

abstract after and as assert at attribute before bind bound 
break catch class continue def delete else exclusive extends false 
finally first for from function if import indexof in init 
insert instanceof into inverse last lazy mixin mod new not 
null on or override package postinit private protected public-init public 
public-read replace return reverse sizeof static step super then this 
throw trigger true try tween typeof var where while with
Keywords: 53

application new as null break override case package catch private 
class property continue protected default public do readonly else request 
eval return except session execution set extends static finally super 
final switch find this for try foreach typeas function typeis 
get typeof hide unless implements uses index var interface void 
internal while native

1 comment:

  1. interesting comparation work! obviously i miss some of my favs langs which not support oop (at least directly) like haskell or clojure (or another lisp). Mmmm i think clojure have really has a few reserved words, only the literals : true, false, nil