Type deduction for fields, lambda parameters, results, local variables and constants
Every value in Argentum has statically assigned type. For fields, constants, variables and lambda prototypes compiler deduces their types automatically by their initial values:
class MyClass {
x = 2 + 3; // int64 (inferred from int expression)
s = "Hello"; // shared pointer to sys_String (inferred from string literal)
z = true; // bool
v = Array; // owning pointer to Array (inferred from the instance creation)
w = &MyClass; // weak pointer to MyClass (&ClassName expression creates unbound weaks)
}
fn myFunction() {
a = MyClass; // non-optional owning pointer to MyClass (points to a new instance)
b = *a; // shared pointer to immutable MyClass
// (inferred from a freeze operator applied to MyClass instance)
}Explicit type declarations:
Only function/method parameters/results need to be declared explicitly. Primarily because they may be defined in one module but used in another one. Thus their explicit types play documenting and enforcement roles.
Example of type declarations:
fn myFunction(
i int, // int64
b bool, // bool
s String, // temporary pointer to sys_String
c &MyClass, // non-owning weak pointer to MyClass
a *Array(User), // pointer to an immutable Array of User objects
l (str, int) @SharedArray(String) // a lambda that takes a string and an integer
// and returns a newly created shared-immutable array of strings
) @Cursor { // function returns an owning pointer to a newly created string cursor
...
}List of all Argentum types:
- Primitive types:
short,int,float,double,bool - Pointers to mutable objects:
@Composition,&Association,Temp. - Shared pointers to immutable objects (aka const, frozen objects):
*Aggregation,&*WeakConstand conform pointers to any objects (mutable or immutable):-Conform,&-WeakConform. - Callables:
- Lambda
(ParameterTypes)ResultType - Function
fn(ParameterTypes)ResultType - Delegate
&(ParameterTypes)ResultType
- Lambda
- Optional type:
?BaseType