# Using Classes¶

Once we defined a class and provided some instances, we can use the class for those instances. There are several ways to do this.

## Qualified names¶

You can use a fully qualified name to access a class method:

println$Eq[int]::==(1, 2); println$ Eq[int]::eq(1, 2);
println$Eq[double]::eq(1.1, 2.2);  You can leave out the type when it can be deduced by overload resolution: println$ Eq::==(1, 2);
println$Eq::eq(1, 2);  ## Missing Instances¶ If you try to use a method which has not been defined by an instance for the type you used, you will get an instantiation error. This is not a type error, it just means you forgot to provide an instance for that type: // println$ Eq::==("Hello", "World");
// WOOPS! we didn't defined it for strings


## Opening a Class¶

The easiest way to use a class is to open it:

open Eq;
println$eq(1,2); println$ 1 == 2;
println$1.1 == 2.2;  This is the most common method for script. In fact many classes in the standard library have already been opened for you. ## Opening a Class Specialisation¶ It is also possible to open a specialisation of a class: open Eq[int]; println$ eq(x,y);
println$x == y; // println$ 1.1 == 2.2;
// WOOPS, can't find == for double * double


This is not an instantiation error, and instance for double exists. The problem is that we didn’t open Eq for double, only for int.

## Passing a class to a function¶

You can also pass a class or specialisation to a function. Here is a monomorphic example:

fun eq3[with Eq[int]] (x:int, y:int, z:int) =>
x == y and y == z
;


This is exactly the same as opening the class or specialisation inside the function. It is useful because it isolates the access to the class by functional abstraction.

Here is a polymorphic example:

fun eq3[T with Eq[T]] (x:T, y:T, z:T) =>
x == y and y == z
;