El sistema de tipos de Ogu (1)

Es momento de analizar más detalles del lenguaje de programación Ogu, vamos a partir por su sistema de tipos, este artículo es una introducción al tema.

Ogu es un lenguaje con declaración de tipos estáticos, aunque implementa inferencia de tipos. Veamos algunos ejemplos:

i : Int = 0
j := i // j es de tipo Int
s : String = "un string"
t := s

Ogu tiene “sacarina sintáctica” para soportar tuplas

naipe : (Int,String) = (10, "espadas")  // naipe es una tupla
as := (1,"espadas")
Naipe = (Int,String) // Introduce el tipo Naipe como alias de la tupla (Int,String)

Tambien hay sacarina para listas y hashes:

vocales : \[String\] = \["a", "e", "i", "o", "u"\]
ListaDeStrings = \[String\]
mapa : \[String : Int\] = \["Chile":56, "Usa":1\]

Las clases pueden ser genéricas:

Stack{T}  : () = {
var \_data : \[T\] = \[\]
push : (x:T) = \_data = x :: \_data
pop : ()-\>(r:T) = {
r = head \_data\
\_data = tail \_data\
}
}

Las tuplas, listas y mapas se implementan en basa tipos genéricos. En realidad al declarar una variable de tipo [T] es lo mismo que declararla como Sequence{T}, y al declararla como [K:V] es lo mismo que Map{K,V}.  Tanto Sequence y Map son clases definidas en el runtime básico de Ogu.

Para crear un stack de enteros hacemos lo siguiente

stackOfInt := Stack{Int}()
// otra manera
StackOfInt = Stack{Int} // type alias
stackOfInt := StackOfInt()

Ogu soporta herencia de clases

// un troglodita es un cavernicola que vive en una cueva
Troglodita : (nombre,grito,cueva : String) > Cavernicola(nombre,grito) = {
_cueva := cueva
}

Interfaces

Consideremos un paquete que trabaja con figuras geométricas

Circulo : (radio:Int) = {
area : () -> Int  = pi * radio ^ 2
perimetro: () -> Int = 2 * pi * radio
}
Cuadrado : (lado:Int) = {
area : () -> Int = lado * lado
}

Supongamos que queremos crear una funcion que imprima el area de una figura geometrica:

imprimeArea : (c:Cuadrado) = println("el area es "+c.area())
imprimeArea : (c:Circulo) = println("el area es "+c.area())

el problema es que Ogu no nos permite sobrecargar funciones :sad:

Hay tres maneras de solucionar esto, la primera es usando selectores de tipo:

imprimeArea : (c:Cuadrado\|Circulo) = println("el area es "+c.area())

lo que hemos hecho es que el tipo de la función imprimeArea puede ser un Cuadrado o un Circulo (Cuadrado | Circulo ).

Ahora si definimos esta función:

imprimePerimetro : (c : Cuadrado\|Circulo) = println("el perimetro es "+c.perimetro())

tendremos un error de compilación,  Cuadrado no define la función perímetro.

La otra forma de solucionar este problema es declarando una interfaz:

Figura := {
area : ()->Int
perimetro : () -> Int
}

Una interfaz es como una clase, pero no tiene constructor y el cuerpo de las funciones es opcional.

De este modo puedo redefinir las clases Circulo y Cuadrado de esta manera:

Circulo : (radio:Int) ~ Figura = {
area = pi * radio ^ 2
perimetro = 2 * pi * radio
}
Cuadrado : (lado:Int) ~ Figura ={
area = lado * lado
perimetro = lado * 4
}

e implementar nuestras funciones así

imprimeArea : (f:Figura) = println("el area es "+f.area())
imprimePerimetro : (f:Figura) = println("el perimetro es"+f.perimetro())

La tercera forma de implementar polimorfismo es mediante herencia y esa queda propuesta al lector.

Consideremos la interfaz Dibujo

Dibujo :=  {
dibujar : () = println ("dibuja un "+nombre)
nombre : String
}

Podemos ahora extender Circulo y Cuadrado para que sean también dibujos:

Circulo : (radio:Int) \~ Figura & Dibujo = {
area = pi \* radio \^ 2
perimetro = 2 \* pi \* radio
nombre = "circulo"
}
Cuadrado : (lado:Int) \~ Figura & Dibujo ={
area = lado\*lado
perimetro = lado\*4
nombre = "circulo"
}

Este artículo es solo una introducción, y es un complemento a la primera parte de la presentación de Ogu. Espero sus comentarios.