tipos

determinar los tipos de datos de literales

¿átomo?

consulte la documentación original de Racket para 'atom?'

(¿átomo? x ...) → booleano

x: cualquier tipo

                  
                devuelve cierto si x es un número, un símbolo o una cadena, falso en caso contrario
             

      ejemplos:  


    g-t (¿átomo? 2)
    g-t cierto

    g-t (¿átomo? "manzana")
    g-t cierto

    g-t (¿átomo? 'hola)
    g-t cierto

    g-t (¿átomo? '(1 2 3))
    g-t falso

¿símbolo?

consulte la documentación original de Racket para 'symbol?'

(¿símbolo? x ...) → booleano

x: cualquier tipo

                  
                devuelve cierto si x es un símbolo, falso en caso contrario 
             

      ejemplos:  


    g-t (¿símbolo? 1)
    g-t falso

    g-t (¿símbolo? "manzana")
    g-t falso

    g-t (¿símbolo? 'hola)
    g-t cierto

    g-t (¿símbolo? '(1 2 3))
    g-t falso

¿carácter?

consulte la documentación original de Racket para 'char?'

(¿carácter? x ...) → booleano

x: cualquier tipo

                  
                devuelve cierto si x es un carácter, falso en caso contrario

                tenga en cuenta que los caracteres están precedidos por #\ en Scheme
             

      ejemplos:  


    g-t (¿carácter? 1)
    g-t falso

    g-t (¿carácter? "manzana")
    g-t falso

    g-t (¿carácter? 'hola)
    g-t falso

    g-t (¿carácter? '(1 2 3))
    g-t falso

    g-t (¿carácter? 'a)
    g-t falso

    g-t (¿carácter? #\a)
    g-t cierto

¿booleano?

consulte la documentación original de Racket para 'boolean?'

(¿booleano? v ...) → booleano

v: cualquier tipo

                  
                devuelve cierto si v es cierto o falso (un valor booleano), falso en caso contrario
             

      ejemplos:  


    g-t (¿booleano? cierto)
    g-t cierto

    g-t (¿booleano? falso)
    g-t cierto

    g-t (¿booleano? 'cierto)
    g-t falso

    g-t (¿booleano? 1)
    g-t falso

    g-t (¿booleano? "manzana")
    g-t falso

    g-t (¿booleano? '(1 2 3))
    g-t falso

¿cadena?

consulte la documentación original de Racket para 'string?'

(¿cadena? v ...) → booleano

v: cualquier tipo

                  
                devuelve cierto si v es una cadena de texto, falso en caso contrario
             

      ejemplos:  


   g-t (¿cadena? "Manzana")
   g-t cierto

   g-t (¿cadena? 'Manzana)
   g-t falso

   g-t (¿cadena? 5)
   g-t falso

   g-t (¿cadena? '(3))
   g-t falso

¿inmutable?

consulte la documentación original de Racket para 'immutable?'

(¿inmutable? v ...) → booleano

v: cualquier tipo

                  
                 devuelve cierto si es una cadena inmutable, falso en caso contrario
             

      ejemplos:  


    g-t (¿inmutable? '(3))
    g-t falso

    g-t (¿inmutable? "hola")
    g-t cierto

    g-t (¿inmutable? 'hola)
    g-t falso

    g-t (¿inmutable? '(1))
    g-t falso

    g-t (¿inmutable? cierto)
    g-t falso

¿lista?

consulte la documentación original de Racket para 'list?'

(¿lista? v ...) → booleano

v: cualquier tipo

                  
                devuelve cierto si v es una lista: ya sea la lista vacía, o un par cuyo segundo elemento es una lista
             

      ejemplos:  


    g-t (¿lista? 1)
    g-t falso

    g-t (¿lista? '(1 2 3))
    g-t cierto

    g-t (¿lista? "lista")
    g-t falso

    g-t (¿lista? '(1 . (2)))
    g-t cierto

    g-t (¿lista? '())
    g-t cierto

¿par?

consulte la documentación original de Racket para 'pair?'

(¿par? v ...) → booleano

v: cualquier tipo

                  
                devuelve cierto si v es un par, falso en caso contrario
             

      ejemplos:  


    g-t (¿par? 1)
    g-t falso

    g-t (¿par? (combinar 1 2))
    g-t cierto

    g-t (¿par? (lista 1 2))
    g-t cierto

    g-t (¿par? '(1 2))
    g-t cierto

    g-t (¿par? '(1 . 2))
    g-t cierto

    g-t (¿par? '())
    g-t falso