Cobra Types Overview

  • Primitive Types
    • Common
      • bool
      • char
        • character literals are single quoted and preceeded by a c.
          • For example var underscore as char = c'_'
      • int (= int32)
      • uint (= uint32)
      • float (= float64)
      • decimal
      • number (defaults to decimal, Can change with compiler -number: option)
      • dynamic (see DynamicType)
    • Can be explicit wrt Sizes/Sign
      • int8, int16, int32, int64
      • uint8, uint16, uint32, uint64
      • float32, float64
    • PrimitiveTypeMembers
  • Complex Types
    • Class
      • Single inheritance
      • Heap-based
      • Popular classes (provided by platform)
        • Object, String, StringBuilder, Exception
        • List<of T>, Dictionary<of K, V>, Set<of T>
        • Stack<of T>, Queue<of T>
        • TextWriter, TextReader, StringWriter
    • Struct
      • No inheritance (other than Object)
      • Value-based
      • Popular structs (CLR)
        • DateTime, Color (System.Drawing)
    • Interface
      • Multiple inheritance
      • No code implementation
      • Popular interfaces (provided by platform libraries)
        • IEnumerable, IEnumerable<of T> (but use T* instead; see streams below)
        • IComparable, IComparable<of T>
    • Mixins
      • Reusable code implementation ( of interface or abstract class or just some capability)
      • Not instantiated directly
      • class declares use of a mixin explicitly and the implementation is melded into the class implicitly.
  • Nilable Type
    • Specifies that a variable can be either that type or nil (no-valued, Null)
    • A nilable type is not directly assignable to a non nilable variable of the same Type
      • requires explicit casting to lose or gain nilability ( to !, to ? )
    • Foo? - indicates nilable type Foo - can be type "Foo" or "nil"
    • applicable to all types
    • "dynamic" implies "dynamic?" meaning you can always pass "nil" where "dynamic" is expected
  • Streams
    • foo* - walkable collection of zero or more objects of type foo
    • See StreamType
  • Working with types at run-time
    • You can get the type of "x" with "x.getType" (library call) or "x.typeOf" (cobra language extension)
    • You can make instances with a type at run-time

      t = x.typeOf
      obj1 = t()
      obj2 = t(0, 0)
  • Generics
    • Classes, interfaces and structs can all be generic -- parameterized by type.
    • These are identical to .NET generics as found in C# and VB.
    • Examples: List<of int>, List<of String>, Dictionary<of String, int>
    • The general form is: Name<of T, U...> for a template where T and U are type placeholders.
      • example: class ATag<of T>
      • A generic type is instantiated by using the same name with a concrete type replacing the type placeholders
        e.g ATag<of String>()
    • You can declare your own and or instantiate generic template types defined locally or in platform libraries.
    • You can overload by number of type arguments. In other words, Foo<of T> and Foo<of T, U> are two different types.
    • Methods can be generic: def foo<of T>(a as T, b as T)

TODO: arrays, passthrough, vari, greatest common denominator

See also: TypeInference, LanguageTopics, LibraryTopics