Introduction to Alore Type System

Introduction

Alore is a programming language that supports both dynamic and static typing, and a mixture of both in the same program. This document is an introduction to the Alore type system. It explains how and why to use static types when programming in Alore.

Learning the Alore static type system in any detail is strictly optional for Alore programmers. If you want to get started quickly, you can begin with the dynamically-typed Alore subset and get back to the type system later, when you have more experience with the language.

Note: The implementation of the Alore type system is still incomplete, but it is already usable for fairly complex tasks. For example, the implementation of the type checker heavily uses static typing.

Contents

• Overview of static and dynamic typing
  • A static typing example
  • Why both static and dynamic typing?
  • Features of Alore type system
  • More examples
• Simple types
  • Variables with types
  • The nil value
  • Function type signatures
  • Dynamically-typed functions and the void type
  • Statically-typed classes
  • Symbolic constants
• Basics of type inference
• Using generic types
  • Using Array types
  • Constructing Array instances
  • Type inference for arrays
  • Multiple assignment with arrays
  • Using Map objects
  • Pair objects
  • Generic type compatibility
  • Nested generics
  • Constructing arbitrary generic instances
• Inheritance and subtyping
  • The Object type
  • Overriding methods
  • Overriding member variables and accessors
• Interfaces
  • Multiple interface inheritance
  • Inheritance and interface implementation
  • Standard library interfaces
  • For loop and Iterable
  • Interface binding
  • Accessors and interfaces
• Tuple types
  • Tuple basics
  • Variable definition and type inference
  • Variable definition with explicit types
  • Tuple types and multiple assignment
  • General tuple types
  • Constructing tuples with explicit types
  • The Tuple type
• Casts
  • Successful cast
  • Failed casts
  • The precedence of as
  • Invalid casts and converting values
  • Casts to generic types and dynamic casts
• The dynamic type and mixed typing
  • The type dynamic
  • Implicit dynamic types
  • Type compatibility
  • Running programs with mixed typing
  • Runtime type errors and mixed typing
  • Generic types and dynamic typing
  • Dynamic casts
  • Inheritance and mixed typing
• Function types
  • Simple function types
  • Default arguments values and varargs
  • Types Function and Type
• Defining generic types and functions
  • Defining a generic type
  • Generic functions
• Intersection types
  • Intersection type basics
  • Overlapping signatures
  • Interface methods and intersection types
• Generic inheritance and generic interfaces
  • Implementing a generic interface
  • Inheriting from a generic class
  • Generic inheritance and mixed typing