Cobra Differences From C#

See also  Cobra Forums Differences with C#

• 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: foo.bar(arg1,[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 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 and double types (rather than Int, UInt, Float, Double)
• 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,...
• Type of numeric literals can be dictated using suffixes

• 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, or and implies do not follow the conventions of boolean logic. In Cobra they have equal precedence. When converting code to Cobra, or writing new code additional parentheses are needed to get the same results as in C#.
• 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 pointer to method (reference) rather than calling it (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++)

• more as they surface

See also:

•  http://cobra-language.com/how-to/