Skip to end of metadata
Go to start of metadata

Boo is a statically typed language.

Static typing is about the ability to type check a program for type correctness.

Static typing is about being able to deliver better runtime performance.

Static typing is not about putting the burden of declaring types on the programmer as most mainstream languages do.

The mechanism that frees the programmer from having to babysit the compiler is called type inference.

Type inference means you don't have to worry about declaring types everywhere just to make the compiler happy. Type inference means you can be productive without giving up the safety net of the type system nor sacrificing performance.

Boo's type inference kicks in for newly declared variables and fields, properties, arrays, for statement variables, overriden methods, method return types and generators.

Variables

Assignments can be used to introduce new variables in the current scope. The type for the new variable will be inferred from the expression on the right.

Only the first assignment to a variable is taken into account by the type inference mechanism.
The following program is illegal:

Fields

Declare the new field _name and initialize it with an empty string. The type of the field will be string.

Properties

When a property does not declare a type it is inferred from its getter.

In this case the type of the Answer property will be inferred as int.

Arrays

The type of an array is inferred as the least generic type that could safely hold all of its enclosing elements.

For statement variables

This works even when with unpacking:

Overriden methods

When overriding a method, it is not necessary to declare its return type since it can be safely inferred from its super method.

Method return types

The return type of a method will the most generic type among the types of the expressions used in return statements.

When a method does not declare a return type and includes no return statements it will be typed System.Void.

Generators

(warning) A Word of Caution About Interfaces

When implementing interfaces it's important to explicitliy declare the signature of a method, property or event. The compiler will look only for exact matches.

In the example below the class will be considered abstract since it does not provide an implementation with the correct signature:

(info) Ok. So where do I have to declare types then?

Let's say when.

  • when the compiler as it exists today can't do it for you. Ex: parameter types, recursive and mutually recursive method/property/field definitions, return for abstract and interface methods, for untyped containers, properties with a only set defined
  • when you don't want to express what the compiler thinks you do:
  • when you want to access a member not exposed by the type assigned to an expression:
  • when you want to use Duck Typing:
  • No labels

3 Comments

  1. What is the difference between:
    f as IDisposable = foo()
    and
    f = foo() as IDisposable

  2. """The type of an array is inferred as the most generic type that could safely hold all of its enclosing elements.

    a = (1, 2) # a is of type (int)

    b = (1L, 2) # b is of type (long)"""

    Isn't the "most generic type" always going to be "object", and so this would be more accurate to say "the least generic type that could safely hold all of the enclosed elements"?

    Where (1,2) as (int) is specific, (1L, 2) as (long) is a bit more generic, and (1,2,"hi") as (object) is the most generic... 

  3. Thanks for the correction, Simon.