Support for type classes

[wdanilo]

Enso doesn't have special syntax for writing type classes as of Oct 2024. The original design...

Implementation and tests for type classes, as described in the design doc. WARNING: the design doc needs to be confirmed before implementing this task!

...hasn't yet been implemented. Anyway this is the current blueprint to follow when writing type classes as of Oct 2024. There is also

• Better UX for "types with multiple roles" in the IDE #11366

[JaroslavTulach]

The blueprint to write type classes in Enso as for Oct 2024:

Define API and "Dictionary"

Here is a way to define Set type class:

from Standard.Base import Error
from Standard.Base.Errors.Common import Type_Error
from  Standard.Base.Errors import Illegal_State

type Set a
    Value o s:a

    is_empty self = self.o.is_empty self.s
    contains self e = self.o.contains self.s e
    length self = self.o.length self.s
    insert self e = Set.Value self.o <| self.o.insert self.s e
    union self (other:Set) = if self.o != other.o then Error.throw (Type_Error "Incompatible sets") else
        Set.Value self.o <| self.o.union self.s other.s

type Operator a
    is_empty (_ : Set) = Error.Throw (Illegal_State.Error "is_empty not implemented")
    contains (_ : Set) _ = Error.Throw (Illegal_State.Error "contains not implemented")
    length (_ : Set) _ = Error.Throw (Illegal_State.Error "length not implemented")
    insert (_ : Set) _ = Error.Throw (Illegal_State.Error "insert not implemented")
    union (_ : Set) _ = Error.Throw (Illegal_State.Error "union not implemented")

The type Set defines is_empty, contains, length, insert and union operations. Once one has such a set up, one can define an implementation.

Implementation with Vector Backing Store

Let's use Vector Any to store the elements as shown here:

from Standard.Base import Vector

import project.Set.Set


type Vector_Impl a
    empty = Set.Value Vector_Impl []

    is_empty (elements : Vector) = elements.length == 0
    contains (elements : Vector) e = elements.contains e
    length (elements : Vector) = elements.length
    insert (elements : Vector) e = if elements.contains e then elements else elements + [ e ]
    union (us : Vector) (them : Vector) = (us + them).distinct

the preferred way of creating type Set is to define a conversion to turn any Vector into a Set:

Set.from (that:Vector) = Vector_Impl.empty . insert that

Using Set

To use the set one can start with a conversion and they operate on the set as desired:

v = [1, 2, 3]
s = v:Set
four = s . insert 4
four . length . should_equal 4

[JaroslavTulach]

• see also Better UX for "types with multiple roles" in the IDE #11366