Ejemplos abstracción de tipos

;;#lang racket

;;Viva Winterfell, siempre Univalluna :)
;; Ahora a nuestro Ewok revivido por
;las maravillas del Edo Tensei o por magia brujas rojas, le solicitan lo siguiente:

;; Se requiere una función que tome
;una lista de bananas y cuente cuantas me he comido, sencillo no!:

(define listaMortal (list 'banana 'manzana 'perro 'gato 'gato 'manzana 'chanda 'manzana 'manzana 'banana))

(define listaEpicamenteMortal (list 1 'manzana 'perro 'gato 1'manzana 'chanda 'manzana 'manzana 'banana 1 1 2 3 2 'jaja 'gg 'izi 'bot))

; list-of-symbol -> num
(define (cuantasBananas lista)
  (cond
    [(empty? lista) 0]
    [(cons? lista)
     ;;Esto es lo mismo que preguntar (list? lista)
     (cond
       [(symbol=? (car lista) 'banana) ;;car = first
         (+ 1 (cuantasBananas (cdr lista))) ;;cdr = rest
        ]
       [else (cuantasBananas (cdr lista))]
       )
     ]
    )
  )


;; Y vuelve el perro arrepentido!, ahora se requiere una función que tome una lista de manzanas y
;; cuente cuantas me he comido, sencillo no!:

(define (cuantasManzanas lista)
  (cond
    [(empty? lista) 0]
    [(cons? lista)
     ;;Esto es lo mismo que preguntar (list? lista)
     (cond
       [(symbol=? (car lista) 'manzana) ;;car = first
         (+ 1 (cuantasManzanas (cdr lista))) ;;cdr = rest
        ]
       [else (+ 0 (cuantasManzanas (cdr lista)))]
       )
     ]
    )
  )

;;Pos, que podemos hacer ahora y si me preguntan cuantos perros me he comido!!!
;;o si me preguntan por humanos o lombrices o otras cosas horribles, que hago



(define (cuantasCosas lista pregunta)
  (cond
    [(empty? lista) 0]
    [(cons? lista)
     ;;Esto es lo mismo que preguntar (list? lista)
     (cond
       [(symbol=? (car lista) pregunta) ;;car = first
        (+ 1 (cuantasCosas (cdr lista) pregunta))  ;;cdr = rest
        ]
       [else (+ 0 (cuantasCosas  (cdr lista) pregunta)) ]
       )
     ]
    )
  )

(define (fun a) (* a a a))

;;; (number -> number) list-of-number -> list-of-number
;;; (X -> X) list-of-X -> list-of-X
(map fun '(1 2 3 4) )


;;Distancias
;; list-of-posn -> list-of-number
(define (distancia-al-origen l)
  (local
    [(define (calcular-distancia pos)
       (local
         [(define x (posn-x pos))
          (define y (posn-y pos))
          ]
         (sqrt (+ (* x x) (* y y)))
         )
       )
     ]
    ;(posn -> num) list-of-posn -> list-of-number
    ;( X -> Y)  list-of-X -> list-of-Y
    (map calcular-distancia l)
    )
  )

(define lista-distancias (list (make-posn 1 2) (make-posn 2 3)
                                           (make-posn 4 3)
                                           (make-posn 1 9)
                                           )
  )

;list-of-num -> num
(define (sum l)
  ;((num num -> num) num list-of-num) -> num
  (foldr + 0 l)
)
(define (product l) (foldr * 1 l))

;;;
(define (sumatoriapor2 lista)
  (local
    [(define (sumapor2 a b)
       ;(* 2 (+ a b))
       (+ (* 2 a) b)
       )
     ]
    (foldr sumapor2 0 lista)
    )
  )


;;and-map or-map

(define (predicado a)
  (< a 2)
  )

(define listicaH '(1 2 3 4 5))

(ormap predicado listicaH)
(andmap predicado listicaH)


;; Uso lambda

(define (sumaMortal a b)
  ((lambda (x y) (+ x y)) a b))

(define (filtroAsesino l fruta1 fruta2)
  (cond
    [(empty? l) empty]
    [(cons? l)
     (local
       [(define (predicado a)
          (or
           (symbol=? a fruta1)
           (symbol=? a fruta2)
           ))
        (define llamado (filtroAsesino (rest l)
                                       fruta1
                                       fruta2
                                       )
          )
        ]

       (cond
         [(empty? l) empty]
         [(predicado (first l))
          llamado
          ]
         [else (cons (first l) llamado)]
         )
       )
     ]
    )
  )
  ;(sumaMortal 1 2)
(define gato 'gato)
(define apple 'apple)
(filtroAsesino (list 'apple 'apple 'pera 'guayaba
                        'chonta
                        'banano
                        'gato) 'apple 'gato)

;; funcion con lambda


(define (filtroAsesinoConLambda l fruta1 fruta2)
  (cond
    [(empty? l) empty]
    [(cons? l)
     (local
       [
        (define llamado (filtroAsesino (rest l)
                                       fruta1
                                       fruta2
                                       )
          )
        ]

       (cond
         [(empty? l) empty]
         [(
           (lambda (a)
             (or
              (symbol=? a fruta1)
              (symbol=? a fruta2)
              ) )
           (first l))
          llamado
          ]
         [else (cons (first l) llamado)]
         )
       )
     ]
    )
  )

(filtroAsesinoConLambda (list 'apple 'apple 'pera 'guayaba
                        'chonta
                        'banano
                        'gato) 'apple 'gato)


(define (make-adder n)
(lambda (m) (+ m n)))

(define (curry a)
  (lambda (b)
    (lambda (c)
           (lambda (d)
             (lambda (e)
               (+ a b c d e)
               )
             )
           )
    )
  )