Tipos básicos usados en clean. Existen 4 tipos básicos: Int



Descargar 104,58 Kb.
Fecha de conversión25.01.2017
Tamaño104,58 Kb.
UNIFICACIÓN
El compilador usa una técnica llamada “unificación” que comprueba que en cualquier aplicación, los tipos coinciden con los tipos correspondientes de los argumentos formales

Esto explica el término “unificar (unify)”, el termino unify es usado en el compilador al detectar un error de tipos.

CLEAN al usar los operadores, suma (+), resta (-), multiplicación (*) y la división (/ ), los operandos deben ser del mismo tipo.

Para los números reales se expresan con decimales, ejemplos: 2.0, 3.0, 4.0… etc.

Para los números enteros se expresan simplemente sin decimales, ejemplos: 2, 3, 4… etc.
Ejemplos

La división de un real con un entero, esto producirá un error de tipos, ya no se permite operandos de distintos tipos.




Otro ejemplo es la división de enteros, por lo que el resultado de esta división será de tipo entero, el resultado será CERO, es decir, en realidad la división de 2/3 da como resultado 0.66666667, pero CLEAN lo truncara al CERO ya que estamos trabajando con los números enteros.


En este último ejemplo, se muestra una operación con números de tipos reales, por lo que el resultado de esta operación con operandos reales, será de tipo real, como se muestra en la imagen.



Tipos básicos usados en CLEAN.

Existen 4 tipos básicos:



Int: El tipo de los números enteros (también puede ser negativo);

Real: El tipo de números de los reales (aproximación de los números reales);

Bool: El tipo del Boolean, se aprecia como True y False (verdadero y falso);

Char: El tipo de letras, dígitos y los símbolos que pueden aparecer en el teclado de la computadora.
También existen:
List, las listas que son sucesiones de elementos

Tuples, Una tupla es una lista inmutable. Una tupla no puede modificarse de ningún modo después de su creación

Arrays, Los arrays son cadenas o listas de algo. Normalmente siempre serán del mismo tipo. También se denomina estructura de acceso aleatorio, o acceso directo, porque todos sus componentes pueden seleccionarse arbitrariamente y son igualmente accesibles. Para designar a un componente aislado, el nombre de la estructura se amplía con el llamado índice de selección del componente. El índice debe ser un valor del tipo definido como tipo índice del

array.


Otras funciones incluidas en los números enteros son

abs el valor absoluto de un número. Ejemplo: Start = abs (-5)  resulta 5

gcd el máximo común divisor de dos números. Ejemplo: Start = gcd 2 4  resulta 2

^ elevar un número a una potencia. Ejemplo: Start = 2^3  resulta 8


Algunas funciones estándar en los números reales son
sqrt la función raíz cuadrada

sin la función seno

ln el logaritmo natural

exp la función exponencial




Funciones predefinidas en Booleanos
> major que. Ejemplo: Start = 1>2  resulta “False”

< menor que. Ejemplo: Start = 1<2  resulta “True”

>= major o igual que. Ejemplo: Start = 1>=2  resulta “False”

<= menor o igual que. Ejemplo: Start = 1<=2  resulta “True”

<> no es igual a. Ejemplo: Start = 1>2  resulta “True”

== igual a. Ejemplo: Start = 1==2  resulta “False”

Funciones Booleanas se pueden combinar con los operadores “and” y “or”
&& Operador “and”. Ejemplo: Start = 1>2 && 1==1  resulta “False”

|| Operador “Or”. Ejemplo: Start = 1>2 || 1==1  resulta “True”

Tiempo de vida de las variables

Global constant functions (CAF’s):
En CLEAN se pueden definir “constantes locales” (por ejemplo s = sqrt (b *b 4.0 *a *c) declaradas dentro de una función).

Las “Constantes Locales”,  expresión que se evalúan sólo una vez, incluso si se utilizan en varios lugares.


Cabe también definir tales constantes en el nivel global, por ejemplo una lista muy grande de enteros

Está definido como:

biglist :: [Int]

biglist =: [1..100000]


Tenga en cuenta que uno tiene que utilizar el símbolo =: para separar el lado izquierdo(biglist), del lado derecho([1..100000] ), de la definición de constante global.
Las funciones de constante en el nivel global están también conocido como “constant applicative forms” (CAF ‘s).

Las constantes globales pueden ser evaluadas como las constantes locales, son evaluadas sólo una vez.

La diferencia con constantes locales es que una constante global puede ser usada en cualquier parte del programa.

La constante (evaluada) será recordada durante el tiempo entero de vida de la aplicación. La ventaja es que si la misma constante es usada en varios lugares, y no tiene que calcularse repetidas veces. La desventaja puede ser que una constante evaluada podría consumir mucho más espacio que una no evaluada. Por ejemplo la expresión no evaluada [1..100000] consume mucho menos espacio que una lista evaluada con 100000 elementos en ella. Si más bien le gustaría evaluar la constante global cada vez que se usa, para ahorrar espacio usted lo puede definir como:



biglist :: [Int]

biglist = [1..100000]

El uso de =: en vez de = hace la diferencia.



Funciones predefinidas en las listas
Se puede definir rangos en las listas.

Ejemplo: [1..10] que es la lista del 1 hasta el 10


El operador ++ concatena dos listas. Por ejemplo:

Start = [1,2] ++ [3,4,5]  resulta, [1,2,3,4,5]


También se pueden usar en las listas la función booleana. Por ejemplo:

Start = [1<2, 2<3, 1==0]  resulta, [True.True,False]


La función take n, si el número es n, la función devuelve los primeros n elementos de la lista. Por ejemplo:

Start = take 3 [2..10]  resulta [2,3,4]


Otras funciones:
Start = sum [1..10] suma todos los elementos de la lista

Start = reverse [1..10]  resulta [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Start = reverse (sort [1,6,2,9,2,7]) (ordena mi lista y luego invierte la lista resultante)  resulta [9,7,6,2,2,1]

En algunas ocasiones es necesario distinguir una serie de casos en una definición de la función. Ejemplo:

absoluto x

| x<0 = ~x

| otherwise = x

Start = absoluto -5

En una lista es posible definir dos función es de utilidad, importando la librería StdList, estas dos funciones ya definidas en la librería son:
hd [x:y] = x

tl [x:y] = y


hd ”head” el cual me exporta la cabeza de la lista, es decir, el primer elemento

tl “tail” el cual exporta el cuerpo de una lista. Ejemplos


Start = hd [1,2,3,4,5]  resulta [1]

Start = tl [1,2,3,4,5]  resulta [2,3,4,5]


Definiciones locales

Dentro de las funciones locales se puede definir una palabra reservada “where”, el cual son definidas a nivel local lo que significa que solo tienen un significado dentro de la función.

Ejemplo.
roots a b c = [ (~b+s)/d , (~b-s)/d ]

where


s = sqrt (b*b-4.0*a*c

d = 2.0*a

Es importante dejar espacio al definir una constante local (s y d).


Módulos y tipos de datos abstractos
En nuestra investigación sobre el concepto de tipo abstractos de datos en nuestro lenguaje de programación CLEAN, nos enfocaremos en 2 puntos de vistas estos hacen referencia a la parte estructural como también el lado de programación:
Aspecto visto desde un punto de vista de programación:
Por defecto una función en Clean solo se puede declarar dentro del módulo, si se desea usar una función en otro módulo basta con solo declararla. Ahora si se quiere exportar un tipo solo se tiene que repetir la declaración de tipo en el módulo.
Definición de módulo día:

::Día==Lun |Mar| Mier| Jue| Vie| Sab| Dom


Por razones de ingeniería de software es mejor solo declarar el nombre del módulo, esto quiere decir no declarar su tipo, en Clean solo se especifica el lado izquierdo, el lado derecho permanece oculto dentro del múdulo.

Definición de módulo día:

::Día
La definición de un módulo puede ser de distintos tipos (datos algebraicos, registros, sinónimos, etc.).

Al módulo sin su definición de tipo se le llama dato de tipo abstracto (DTA). Su ventaja radica en que su definición es invisible para el “mundo exterior”, estos solo pueden ser usados y manipulados a través de funciones que son exportadas por el módulo. Los DAT solo se pueden almacenar en estructuras de datos.

El ejemplo más conocido de un tipo abstracto de dato es el es stack, se puede definir como:
Definición módulo stack:

::Stack a

Empty :: (Stack a)

isEmpty :: (Stack a) -> Bool

Top :: (Stack a) -> a

Push a(Stack a) -> Stack a

Pop :: (Stack a) -> Stack a
Se define un stack vacío, luego se crea un elemento de tipo a, luego e obtiene un Stack a en Push, para eliminar elemento se hace a través de Pop, se puede eliminar el elemento a y se comprueba si la pila esta vacía con isEmpty
Aspecto desde el punto de vista estructural:
Tipos abstractos de datos (Abstract data types).

-En Clean existen 2 tipos de módulos llamados:

-Modulo de Implementación (.Icl)

-Modulo de definición (.Dcl)

Los tipos de datos abstractos consisten en “ocultar la definición real de una función”.

El “modulo de implementación”, el cual es el equivalente a mi archivo fuente, y el “modulo de definición” consiste en que si se quiere usar o exportar una función en otro modulo de implementación se tiene que definir en su correspondiente modulo de definición, lo que este escrito en el modulo de definición será oculto al usuario, el usuario solo podrá ver la función definida en el modulo de definición.

A esta información ocultada se llamara Abstract data types.
Ejemplo.
Mi modulo de implementación “moduloEjemplo.icl”
Implementation module moduloEjemplo

Import StdEnv


incrementa :: Int -> Int

incrementa n = n + 1


Start = incrementa 2

En el modulo de definicion se crea una función llamada “incrementa” la cual primero se definió su tipo, luego el código de mi función, la línea “Start = incrementa 2” es la que ejecuta la función incrementa.

Es importante definir la palabra reservada completa “Implementation module”, cuando se quiere exportar una función, si solo se define con “module”, provocara un error al querer usar la función en otro modulo.

Mi modulo de definición “moduloEjemplo.dcl”


definition module moduloEjemplo

incrementa :: Int -> Int


Aquí se exporta la función del modulo de implementación “moduloEjemplo.icl”, para luego ser usada en otro modulo, como en el siguiente ejemplo.
Mi modulo “ModuloCallDefinicion.icl” donde uso la función del modulo “moduloEjemplo.dcl”
module ModuloCallDefinicion

import StdEnv


from moduloEjemplo import incrementa

Start = incrementa 4



Definición recursión
En las definiciones de las funciones, las funciones se pueden utilizar otros. Pero también la función puede ser utilizada en su propia definición! Una función que se utiliza en su propia definición se llama una función recursiva. Por Ejemplo
fac n

| n==0 = 1

| n>0 = n * fac (n-1)
El nombre de la función que se define (FAC) se llama recursivamente en la parte derecha del símbolo =.


Enlace Estático de tipos a variables
Clean posee un enlace estático de tipos a variables este puede ser tanto como implícito como explicito.

Para el caso implícito; todas las operaciones en Clean poseen un tipo, es decir, los operandos de una operación tienen que ser del mismo tipo, y su resultado será del mismo tipo. En estos casos no es necesario definir una “declaración de tipos”: las declaraciones de tipo son, como por ejemplo: sqrt :: Real -> Real. Las cuales son definidas encima de una función.

En el caso explicito, las “declaración de tipos”, son importantes al exportar una función, para ser usadas en otro modulo, ya que sin ellas no podríamos exportar alguna función al modulo de definición.

Ejemplos:


Declaración de tipos implícita:
increment n = n + 1
Start = increment 5
 Su resultado será 6
Esta declaración de tipos es de tipo entero ya que, tanto como “n” que tiene como valor 5, y 1 de la parte derecha es de tipo entero, se concluye que el resultado es de tipo entero.
Declaracion de tipos explicita:
increment :: Int -> Int

increment n = n + 1

Start = increment 8
 Su resultado será 9

Se puede apreciar en la declaración de tipos que en “n” de la izquierda es de tipo entero y el resultado será de tipo entero.



Ámbito Estático

En CLEAN el ámbito de las variables son de tipo Estático.

Una definición de Ámbito Estático:

Puede ser llamado antes de la ejecución. Usado en la mayoría de los lenguajes imperativos. Es normal permitir el anidamiento en una jerarquía de ámbitos, que defina una descendencia estática.



Paso por valor

Clean usa el paso por valor, una definición de esta:



El paso de parámetros por valor consiste en enviar una COPIA del valor de la variable al módulo invocado.

De esta manera se asegura que el valor de la variable sólo puede ser modificado por el módulo que la declaró.


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal