Programación imperativa (2)

• La igualdad de referencia se comprueba con la función eq?: (eq? x y) devuelve #t cuando x e y apuntan al mismo dato
• La igualdad de contenido se comprueba con la función equal?: (equal? x y) devuelve #t cuando x e y contienen el mismo valor

Si dos variables son eq? también son equal?.

(define a (cons 1 2))
(define b (cons 1 2))
(define c a)
(equal? a b)
(equal? a c)
(eq? a b)
(eq? a c)

• Inserción en una lista ordenada:

  (define (make-olist)
     (list '*list*))
  
  (define (insert! n olist)
     (cond 
        ((null? (cdr olist)) (set-cdr! olist (cons n '())))
        ((< n (cadr olist)) (set-cdr! olist (cons n (cdr olist))))
        ((= n (cadr olist)) #f) ; el valor devuelto no importa
        (else (insert! n (cdr olist)))))
  

• Otro ejemplo: tabla hash

  (define (make-table)
     (list '*table*))
  
  (define (get key table)
     (let ((record (assq key (cdr table))))
        (if (not record)
           #f
           (cdr record))))
  
  (define (put key value table)
     (let ((record (assq key (cdr table))))
        (if (not record) 
           (set-cdr! table
              (cons (cons key value) (cdr table)))
           (set-cdr! record value))))
  

• Objetos
• Colecciones mutables
• List Buffer

import scala.collection.mutable.ListBuffer
val buf = new ListBuffer[Int]
buf += 1 
buf += 2
3 +: buf

• Un ListBuffer es un tipo de referencia:

  val buf = new ListBuffer[Int]
  val buf2 = buf
  buf2 += 4
  

• Añadiendo list buffers:

  val buf = new ListBuffer[Int]
  buf += 1
  val buf2 = new ListBuffer[Int]
  buf2 ++= List(2,3,4)
  buf ++= buf2
  

• Eliminando elementos:

  val buf = new ListBuffer[String]
  buf ++= List("Paris","Madrid","Londres")
  buf -= "Paris"
  

• Función indexOf:

  val buf = new ListBuffer[String]
  buf ++= List("Paris","Madrid","Londres")
  buf.indexOf("Madrid")
  

• Función update:

  val buf = new ListBuffer[String]
  buf ++= List("Paris","Madrid","Londres")
  buf.update(1,"Barcelona")
  

• Secuencia
• Selección
• Iteración

Veremos principalmente Scala, aunque añadiremos algún ejemplo de Scheme

• Scheme

  (define x 3)
  (define y 5)
  (define (cambia-vars a b)
     (set! x a)
     (set! y (+ a b x))
     (+ x y))
  

• Scala

  var x=3
  var y=5
  def cambiaVars(a: Int, b: Int) = {
     x=a
     y=a+b+x
     x+y }
  

• La sentencia if de Scala devuelve el resultado de la última expresión evaluada

  val filename = if (!args.isEmpty) args(0) else "default.txt"
  println(filename)
  

• Con efectos laterales

  def pruebaMatch(str: String) = {
     str match { 
        case "salt" => println("pepper") 
        case "chips" => println("salsa") 
        case "eggs" => println("bacon") 
        case _ => println("huh?")
     }
  }
  

• Devolviendo un valor

  def pruebaMatch2(str: String): String = {
     str match { 
        case "salt" => "pepper"
        case "chips" => "salsa"
        case "eggs" => "bacon"
        case _ => "huh?"
     }
  }
  

Lenguajes y Paradigmas de Programación
Curso 2010-2011
Departamento de Ciencia de la Computación e Inteligencia Artificial
Universidad de Alicante

Sitio web realizado con org-mode y el estilo CSS del proyecto Worg