Cobra Differences From C#


# Cobra
d = {'a': 1, 'b': 2}
assert d['a'] == 1 and d['b'] == 2
for key, value in d
    print '[key] = [value]'  # string interpolation
// C#
var dictionary = new Dictionary<string, int> { {"a", 1}, {"b", 2} };
Assert.IsTrue(dictionary["a"] == 1 && dictionary["b"] == 2);
foreach (var key in dictionary.Keys)
   var value = dictionary[key];
   Debug.WriteLine(string.Format("{0} == {1}", key, value));


Quick Reference

  • Dynamic Typing and Type inference (doesnt require Type or keyword to declare locals)
    • optional type declarations
  • Block structured by indentation only (like Python) no squiggly braces (brackets)
    • nil tracking - variables can be declared as nil assignable (or not)
  • Built in language support for
    • unit test code
    • assertions
    • Design by contract - invariants, preconditions and postconditions
  • Syntax support for builtin
    • Lists - [] - List of Dynamic
    • Dictionaries - {:} Dictionary of <Dynamic, Dynamic>
    • Sets - {,}
  • Line Oriented
    • # to comment line (instead of //)
    • /# ... #/ for multiline comments
    • Line continuation is implied in method argument lists:,[NEWLINE]arg2)
    • Use a trailing _ for explicit line continuation
    • Tab or 4 Spaces to indent line (Fixed 4 space indent), Cannot mix Tabs and spaces for an indent level
    • No statement terminator (goodbye to ';')
  • Fractional numbers default to decimal type (rather than int)- can be overridden (to float/double) with a compiler commandline option
  • Method names and properties start with lowercase. (i.e lowerCamelCase)
    • Access to methods/properties in used libraries are also done via (implicitly mapped) lowerCamelCase methodnames
    • In resulting binaries such as .exe and .dll, the .NET standard CamelCase is used so that Cobra libraries vend out naturally to C# and VB.NET
  • Class names must be (upper)  CamelCased or at least start with an upper case letter)
  • instance variable optionally prefixed with _ (implicitly makes them protected) or __ (implicitly makes them private).
    If so prefixed, these can be accessed directly in methods (without a leading '.')
  • methods (and properties) on current object invoked with leading this. or more usually (shortcut) just ..
  • constructor/initializer method is called init, has no return value

  • String type accessed as String
  • Numeric types specified as int, uint, float/float64, float32 and decimal
  • Sized int and uint types all have the same naming form
    • int8, int16, int/int32, int64 instead of SByte, Int16, Int32/int, Int64
    • uint8, uint16, uint/uint32, uint64 instead of Byte, UInt16, ...
    • float32, float/float64 instead of float, double
  • Type of numeric literals can be dictated using suffixes ( e.g. unsigned 47_u, 47_u8, signed 47_i8, 47_i64)
  • Variable specification - typing, access modifiers, argument attributes specified by keyword as rather than C-like/Java-like syntax
    • e.g. x as int32, instVar as string public (vs int32 x; public String instVar; )
  • typecasting by keyword to as in 'x to Type' rather than '(Type)x'
    • cast to and away from nilable Type.
  • is shared to declare a static type
  • <> instead of != for 'not equals' comparisons
  • Condition negation uses keyword not ( as in not a >10 )
  • boolean conditions use keywords and and or ( as in if a>3 and b<10 or b>55 )
  • boolean and and or have equal precedence in Cobra whereas in C# they are differentiated. When converting code to Cobra, additional parentheses may be needed.
  • nil for no object (null) value
  • Supports +=, -=, etc. Does not support ++ or -- unary operators ( use += 1 and -= 1 instead).

  • boolean conditions can be tested on any type. True is any of
    • non false (bool Type)
    • numeric not 0
    • non zero char
    • not nil
  • blank strings and empty collections are true (non nil) - must check .length for strings and .count for collections
  • Strings delimited by single or double quotes, normal range of \c expansion ( e.g \n, \t)
  • Substitute expressions (values) directly in strings by enclosing with [].
    • such expressions can have optional String.format specification
  • 'Raw' Strings (r"a raw string") no escape sequence expansion ( vs c# @"a raw string")
  • 'NoSubstitution' strings ( ns" no substitution [done] here")
  • DocStrings on Programs, Classes, Interfaces (etc), instance variables, methods and properties
  • Different syntax for characters c'x'
  • since '[] used for declaring literal Lists, array literals are specified using @[] - comma separated values
  • ref keyword for getting a reference (e.g., safe pointer) to a method, rather than calling it, so the reference can be stored or passed around. (for delegates)
  • sig keyword for declaring a delegate type
  • def keyword to declare a method/function
    • e.g def doCalc( start as int) as int instead of int doCalc( int start)
  • use keyword instead of 'using' to get access to a non default namespace
  • branch... on, on, [else] statement rather than c# case statement
  • Slicing syntax for sequences (Lists and Strings) [start:stop:step] as well as normal library subsequence methods (substring, range, ...)
  • numeric for loop uses slice syntax. e.g. for i in 1:10:1 vs for( int i =1; i<=10; i++)
  • the Cobra ternary operator has a different syntax: if(<condition>, <texpr>, <fexpr>). Example at
  • more as they surface

See also