¿El espacio en blanco en los identificadores ha sido idiomático? [cerrado]

El estilo C # sugiere usar CamelCase en identificadores para delimitar palabras. La tradición de Lisp sugiere usar guiones en su lugar.

¿Ha existido alguna vez un lenguaje de programación en el que el uso de espacios en los identificadores no solo estaba permitido, sino que también era un idioma comúnmente utilizado al emplear identificadores de varias palabras?

Es posible tener identificadores con espacios en algunas implementaciones de Scheme , pero no es una práctica ampliamente vista. Aquí hay un ejemplo:

Petite Chez Scheme Version 8.4
Copyright (c) 1985-2011 Cadence Research Systems

> (define |hey there| 100)
> (define |x y z| 200)
> (list |hey there| |x y z|)
(100 200)

Los compiladores de FORTRAN ignoraron los espacios, así que:

   result = value * factor  
   r e s u l t = val ue * fac tor
   result=value*factor`

Eran idénticos en lo que respecta al compilador.

Algunos dialectos de SQL permiten espacios incrustados en los nombres de columna, pero deben estar rodeados por comillas inversas o algún otro delimitador antes de que puedan usarse.

Visual Basic (y VBScript) también permiten espacios en blanco en los identificadores si rodea el identificador con corchetes.

Dim [Hello World]
[Hello World] = 123

Sin embargo, hacerlo es bastante raro.

¿Cuenta SQL?

create table "Registered Members" (
    "Full Name" varchar(100),
    "Mailing Address" varchar(100),
    etc...
);

Así espacio en blanco es todo el espacio en blanco sobre ...:

La mayoría de los lenguajes de programación modernos no consideran la sintaxis de los espacios en blanco (espacios, tabulaciones y líneas nuevas), ignorándolos, como si no estuvieran allí. Consideramos que esto es una gran injusticia para estos miembros perfectamente amigables del conjunto de personajes. ¿Deben ser ignorados, simplemente porque son invisibles? El espacio en blanco es un lenguaje que busca corregir el equilibrio. Los caracteres que no sean espacios en blanco se ignoran; solo los espacios, las pestañas y las nuevas líneas se consideran sintaxis.

Desafortunadamente, Markdown no admite su sintaxis y no puedo mostrarle un código, pero Wikipedia tiene una muestra de código amigable para los humanos .

En Algol 68 podrías tener espacio en los identificadores (no recuerdo si fueron significativos o no). Pero las palabras clave fueron marcadas por stripping . Usar nombres con espacio en ellos era idiomático (al menos a mi alrededor).

VHDL permite identificadores con espacios significativos de ellos escapó: \foo bar\. Esto permite también utilizar palabras clave como identificador \and\, cualquier carácter \n<42>\sensibilidad y caso en los identificadores ( \Foo\y \foo\son diferentes, mientras que Fooy fooson equivalentes, y diferente de cualquiera \Foo\y\foo\!). Verilog también tiene identificadores espaciados con la mayoría de estas características (los identificadores normales distinguen entre mayúsculas y minúsculas y escapar de ellos innecesariamente no hace otro identificador), pero no permite espacios en ellos. La necesidad de identificadores escapados en VHDL y Verilog proviene del hecho de que a menudo se producen automáticamente a partir de otras fuentes (como esquemáticas) donde los identificadores habitualmente no tienen la misma restricción que en el lenguaje de programación; AFAIK, no se usan idiomáticamente en otras circunstancias.

No sé si consideras que el wikitexto de MediaWiki es un idioma, pero los nombres con espacios son definitivamente idiomáticos:

==Example==
This example lacks text.
{{Expand section}}

Donde "expandir sección" es el nombre de una plantilla (http://en.wikipedia.org/wiki/Template:Expand_section)

Supongo que cumple con los criterios, un lenguaje en el que los identificadores habitualmente contienen espacios. Nunca es (¿creo?) Ambiguo porque los identificadores siempre están rodeados de muchos signos de puntuación para separarlos del texto wiki sin formato.

Inform 7 es un sistema para desarrollar ficción interactiva utilizando una sintaxis similar al lenguaje natural, en la que los identificadores de varias palabras son comunes:

Mr Jones wears a top hat. The crate contains a croquet mallet. 

La restricción, por supuesto, es que un identificador no puede contener una palabra clave cuando esto sería ambiguo.

En una línea similar, los identificadores con guiones bajos en Agda pueden usarse mixfix, el ejemplo más simple de los cuales es probablemente el if_then_else_operador:

if_then_else_ : {A : Set} -> Bool -> A -> A -> A
if true  then x else y = x
if false then x else y = y

Scala permite identificadores arbitrarios utilizando backticks. El uso habitual para esto es invocar Thread.`yield`porque yieldes una palabra reservada en Scala. Esto podría (ab) usarse para tener espacios en los nombres, aunque eso estaría lejos de ser un código de Scala idiomático:

val `the answer` = 42
println(`the answer`)

Diablos, incluso puedes tener pestañas en los identificadores:

scala> val `the\tanswer` = 42
the     answer: Int = 42

Supongo que esto podría concebiblemente ser idiomática para la gente programación literaria. Tal vez.

F # permite espacios en blanco en los nombres de los identificadores, pero deben estar rodeados de dobles comillas. Consulte la respuesta a esta pregunta: https://stackoverflow.com/questions/6639688/using-keywords-as-identifiers-in-f .

Podría considerar que este es el caso en Cucumber / Gherkin , donde los nombres de funciones son efectivamente oraciones con los argumentos incrustados dentro de ellas.

Como extensión, esperaría que esto sea más común en pequeñas DSL , donde se supone que el lenguaje es amigable para los no desarrolladores. Por ejemplo, muchos motores de reglas proporcionan una habilidad para definir reglas con una descripción similar al inglés, donde los espacios se pueden usar en identificadores.

FWIW, Tcl permite espacios (y casi todos los demás caracteres) en los identificadores, aunque no es común aprovechar esta característica. La razón principal por la que no se usa con mucha frecuencia es que tiene que usar las citas adecuadas. Por ejemplo, lo siguiente establece una variable llamada "mi nombre" en "bob", luego la imprime

set "my name" "bob"
puts "hello, ${my name}"

OTOH, es muy útil cuando se construyen variables dinámicamente ya que, al crear tales variables, uno no tiene que preocuparse por caracteres ilegales

Hay pocos que conozco. Estoy trabajando en uno y el lenguaje de programación ágil . Inform sí, pero no es exactamente un lenguaje de programación de propósito general.

Si considera que un DSL de prueba automatizado es un lenguaje, el marco del robot permite espacios en los nombres de palabras clave, y es muy idiomático. En el siguiente ejemplo, "Saluda" es un nombre de palabra clave, "Ejemplo de caso de prueba" es un nombre de caso de prueba y "$ {first name}" es una variable:

*** Keywords ***
| Say hello | [Arguments] | ${first name}
| | log | Hello, ${first name}

*** Test Cases ***
| Example test case
| | Say hello | world

El lenguaje 4D permite espacios en blanco en los nombres de los métodos y las variables. Generalmente está mal visto dentro de la comunidad, pero todos los métodos y variables incorporados los usan cuando corresponde ( SET MENU ITEM PARAMETERpor ejemplo)

Smalltalk presenta métodos de palabras clave como los a:b:c:que implican espacios en blanco cuando se invocan. Por ejemplo: a: 100 b: 200 c: 300. Este es un idioma estándar en el idioma.

Powershell permite espacios en nombres de variables:

PS C:\> ${the var} = 100

PS C:\> ${the var}
100

Vi mención de similar para VB pero en JS esto se usa mucho en realidad. Se puede acceder a cualquier propiedad de un objeto en JavaScript y establecerla en forma de cadena entre corchetes o simplemente como cadenas en literales de objeto. Los nombres de propiedades que no siguen las reglas de nomenclatura variable de JS son inaccesibles a través de. notación pero son útiles. Por ejemplo, es posible que desee asignar URL a comportamiento o hacer referencia a un grupo de personas por nombre cuando esté seguro de que todas son únicas. A menudo es muy conveniente y fácil de leer:

var peoplesFavoriteThings = {
    "Bob Jones":"kittens",
    "Jane Doe":"chainsaws"
}

for(var name in peoplesFavoriteThings){
    console.log(name + ' likes ' + peoplesFavoriteThings[name] + '.\n');
}

Esto también facilita la reestructuración de JSON para facilitar su uso sin perder el factor de objeto instantáneo cuando se deja caer en JS.

Power Query utiliza una gran cantidad de código generado automáticamente. Supongo que más de la mitad de los identificadores generados usan espacios en blanco:

let
    Source = Sql.Database(".", "Test"),
    dbo_pvt = Source{[Schema="dbo",Item="pvt"]}[Data],
    #"Filtered Rows" = Table.SelectRows(dbo_pvt, each [VendorID] <= 4),
    #"Removed Columns" = Table.RemoveColumns(#"Filtered Rows",{"Emp1", "Emp2"}),
    #"Grouped Rows" = Table.Group(#"Removed Columns", {"Emp3", "Emp4"}, {{"Count", each List.Sum([Emp5]), type number}})
in
    #"Grouped Rows"

Como puede ver, como en muchos idiomas hay una sintaxis adicional para desambiguar cuál es el identificador.

Pero en lugares donde no es ambiguo, no se necesita sintaxis adicional:

let
    spaceRecord = [with space = 42, recursive record = @spaceRecord],
    drilldown = spaceRecord[recursive record][recursive record][recursive record][with space]
in
    drilldown   // 42

Si lo cuenta como un idioma real, lenguaje de script JMP ( http://www.jmp.com/support/downloads/pdf/jmp_scripting_guide.pdf ). Permite que los identificadores tengan espacios en blanco (para hacerlos más "legibles") y más o menos los alienta.

El lenguaje de programación o42a que estoy desarrollando actualmente admite nombres de varias palabras . El idioma no tiene palabras clave y los nombres generalmente se separan con algún símbolo. En el raro caso de que los dos nombres se sucedan, el guión bajo se usa para separarlos.

Authorware, cuyo lenguaje de secuencias de comandos se basó en Pascal no orientado a objetos, permitió espacios en nombres variables, aunque con el tiempo la gente descubrió los problemas con su uso y se alejó de él http://books.google.com/books?id= bHC88YignAkC & pg = PA428 & lpg = PA428 .

Editar: se demostró que esta respuesta no era correcta, vea los comentarios.

Si entiendo su pregunta correctamente, un compilador no puede permitir espacios en el nombre del identificador porque podría causar nombres duplicados (a menos que se use un delimitador). Por ejemplo:

int my = 0; bool mi cuenta = falso; int cuenta = 0; si (mi conde) ...

el término 'mi cuenta' es confuso, ya sea que podría referirse a la variable llamada 'mi cuenta' o tal vez el desarrollador olvidó escribir un operador de relación como> entre my y count.

COBOL permitió que los nombres de división y los nombres de sección se separen por espacio, pero esos no son identificadores y variables como en su pregunta.