julia-lang - language - julia lenguaje de programacion
¿Qué es un "símbolo" en Julia? (1)
Los símbolos en Julia son los mismos que en Lisp, Scheme o Ruby. Sin embargo, las respuestas a esas preguntas relacionadas no son realmente satisfactorias , en mi opinión. Si lees esas respuestas, parece que la razón por la que un símbolo es diferente de una cadena es que las cadenas son mutables, mientras que los símbolos son inmutables, y los símbolos también son "internados", sea lo que sea lo que eso signifique. Las cuerdas son mutables en Ruby y Lisp, pero no están en Julia, y esa diferencia es en realidad una pista falsa. El hecho de que los símbolos estén internados, es decir, modificados por la implementación del lenguaje para comparaciones rápidas de igualdad, es también un detalle de implementación irrelevante. Podría tener una implementación que no incluya símbolos y el idioma sería exactamente el mismo.
Entonces, ¿qué es un símbolo, realmente? La respuesta radica en algo que Julia y Lisp tienen en común: la capacidad de representar el código del idioma como una estructura de datos en el lenguaje mismo. Algunas personas lo llaman "homoiconicity" ( Wikipedia ), pero otros no parecen pensar que solo sea suficiente para que un idioma sea homoicónico. Pero la terminología en realidad no importa. El punto es que cuando un idioma puede representar su propio código, necesita una forma de representar cosas como asignaciones, llamadas a funciones, cosas que pueden escribirse como valores literales, etc. También necesita una forma de representar sus propias variables. Es decir, necesita una forma de representar, como datos, el foo en el lado izquierdo de esto:
foo == "foo"
Ahora estamos llegando al meollo del asunto: la diferencia entre un símbolo y una cuerda es la diferencia entre foo en el lado izquierdo de esa comparación y "foo" en el lado derecho. A la izquierda, foo es un identificador y evalúa el valor vinculado a la variable foo en el alcance actual. A la derecha, "foo" es un literal de cadena y evalúa el valor de cadena "foo". Un símbolo en Lisp y Julia es cómo se representa una variable como datos. Una cadena simplemente se representa a sí misma. Puede ver la diferencia al aplicarles eval :
julia> eval(:foo)
ERROR: foo not defined
julia> foo = "hello"
"hello"
julia> eval(:foo)
"hello"
julia> eval("foo")
"foo"
Lo que el símbolo :foo evalúa depende de qué -si acaso- la variable a la que está obligado foo , mientras que "foo" siempre evalúa como "foo". Si desea construir expresiones en Julia que usen variables, entonces está usando símbolos (lo sepa o no). Por ejemplo:
julia> ex = :(foo = "bar")
:(foo = "bar")
julia> dump(ex)
Expr
head: Symbol =
args: Array{Any}((2,))
1: Symbol foo
2: String "bar"
typ: Any
Lo que arrojó esa cosa muestra, entre otras cosas, que hay un objeto de símbolo :foo dentro del objeto de expresión que obtienes al citar el código foo = "bar" . Aquí hay otro ejemplo, construyendo una expresión con el símbolo :foo almacenado en la variable sym :
julia> sym = :foo
:foo
julia> eval(sym)
"hello"
julia> ex = :($sym = "bar"; 1 + 2)
:(begin
foo = "bar"
1 + 2
end)
julia> eval(ex)
3
julia> foo
"bar"
Si intentas hacer esto cuando sym está vinculado a la cadena "foo" , no funcionará:
julia> sym = "foo"
"foo"
julia> ex = :($sym = "bar"; 1 + 2)
:(begin
"foo" = "bar"
1 + 2
end)
julia> eval(ex)
ERROR: syntax: invalid assignment location ""foo""
Es bastante claro ver por qué esto no funciona: si trataste de asignar "foo" = "bar" a mano, tampoco funcionaría.
Esta es la esencia de un símbolo: un símbolo se usa para representar una variable en la metaprogramación. Una vez que tiene símbolos como tipo de datos, por supuesto, resulta tentador usarlos para otras cosas, como las teclas hash. Pero eso es un uso incidental y oportunista de un tipo de datos que tiene otro propósito principal.
Tenga en cuenta que dejé de hablar sobre Ruby hace un tiempo. Eso es porque Ruby no es homoicónica: Ruby no representa sus expresiones como objetos Ruby. Entonces, el tipo de símbolo de Ruby es una especie de órgano vestigial: una adaptación sobrante, heredada de Lisp, pero que ya no se usa para su propósito original. Los símbolos de Ruby se han utilizado para otros fines, como las teclas hash, para extraer métodos de las tablas de métodos, pero los símbolos en Ruby no se utilizan para representar variables.
En cuanto a por qué los símbolos se usan en DataFrames en lugar de cadenas, es porque es un patrón común en DataFrames para enlazar valores de columna a variables dentro de las expresiones proporcionadas por el usuario. Por lo tanto, es natural que los nombres de columna sean símbolos, ya que los símbolos son exactamente lo que usted usa para representar las variables como datos. Actualmente, debe escribir df[:foo] para acceder a la columna foo , pero en el futuro, puede acceder a ella como df.foo en df.foo lugar. Cuando eso sea posible, solo se accederá a las columnas cuyos nombres son identificadores válidos con esta conveniente sintaxis.
Ver también:
Específicamente: estoy tratando de usar el paquete DataFrames de Julia, específicamente la función readtable () con la opción de nombres, pero eso requiere un vector de símbolos.
- ¿Qué es un símbolo?
- ¿Por qué elegirían eso sobre un vector de cuerdas?
Hasta ahora, he encontrado solo un puñado de referencias al símbolo de la palabra en el idioma Julia. Parece que los símbolos están representados por ": var", pero está lejos de ser claro para mí lo que son.
Aparte: Puedo correr
df = readtable( "table.txt", names = [symbol("var1"), symbol("var2")] )
Mis dos preguntas con viñetas siguen en pie.