O espaço em branco nos identificadores já foi idiomático? [fechadas]

O estilo C # sugere o uso do CamelCase em identificadores para delimitar palavras. A tradição Lisp sugere usar traços.

Já existiu uma linguagem de programação em que o uso de espaços em identificadores não era apenas permitido, mas um idioma comumente usado ao empregar identificadores de várias palavras?

É possível ter identificadores com espaços em algumas implementações do Scheme , mas não é uma prática amplamente vista. Aqui está um exemplo:

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)

Os compiladores FORTRAN ignoraram os espaços, portanto:

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

Foram idênticos no que diz respeito ao compilador.

Alguns dialetos SQL permitem espaços incorporados nos nomes das colunas, mas precisam estar entre aspas ou outro delimitador antes de poderem ser usados.

O Visual Basic (e VBScript) também permitirá espaço em branco nos identificadores se você o envolver entre colchetes.

Dim [Hello World]
[Hello World] = 123

No entanto, fazer isso é bastante raro.

O SQL conta?

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

Bem Whitespace é toda sobre ... o espaço em branco:

A maioria das linguagens de programação modernas não considera sintaxe de caracteres de espaço em branco (espaços, tabulações e novas linhas), ignorando-os, como se não estivessem lá. Consideramos que isso é uma injustiça grosseira para esses membros perfeitamente amigáveis ​​do conjunto de caracteres. Eles devem ser ignorados, apenas porque são invisíveis? Espaço em branco é uma linguagem que busca corrigir o equilíbrio. Quaisquer caracteres que não sejam espaços em branco são ignorados; apenas espaços, tabulações e novas linhas são consideradas sintaxe.

Infelizmente, o Markdown não suporta sua sintaxe e não posso mostrar algum código, mas a Wikipedia possui um exemplo de código amigável para humanos .

No Algol 68, você poderia ter espaço nos identificadores (não me lembro se eram significativos ou não). Mas as palavras-chave foram marcadas por stropping . Usar nomes com espaço neles era idiomático (pelo menos ao meu redor).

VHDL permite identificadores com espaços significativos na deles escapou: \foo bar\. Isso permite também usar palavras-chave como identificador \and\, qualquer caractere e distinção entre \n<42>\maiúsculas e minúsculas nos identificadores ( \Foo\e \foo\são diferentes enquanto Fooe foosão equivalentes e diferentes de \Foo\e\foo\!). A Verilog também possui identificadores espaçados com a maioria dessas características (identificadores normais diferenciam maiúsculas de minúsculas e escapá-los desnecessariamente não cria outro identificador), mas não permite espaços neles. A necessidade de identificadores de escape no VHDL e no Verilog vem do fato de que eles geralmente são produzidos automaticamente de outras fontes (como esquemas) onde os identificadores normalmente não têm a mesma restrição que na linguagem de programação; AFAIK, eles não são usados ​​idiomamente em outras circunstâncias.

Não sei se você considera o wikitext do MediaWiki uma linguagem, mas nomes com espaços são definitivamente idiomáticos:

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

Onde "seção de expansão" é o nome de um modelo (http://en.wikipedia.org/wiki/Template:Expand_section)

Eu acho que ele atende aos critérios - uma linguagem na qual os identificadores rotineiramente contêm espaços. Nunca é (acho?) Ambíguo porque os identificadores estão sempre cercados por muita pontuação para separá-los do texto bruto da wiki.

O Inform 7 é um sistema para desenvolver ficção interativa usando sintaxe semelhante à linguagem natural, na qual identificadores de várias palavras são comuns:

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

A restrição, é claro, é que um identificador não pode conter uma palavra-chave quando isso seria ambíguo.

De maneira semelhante, identificadores com sublinhados no Agda podem ser usados ​​mixfix, cujo exemplo mais simples é provavelmente o 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 arbitrários usando backticks. O uso usual para isso é invocar Thread.`yield`porque yieldé uma palavra reservada em Scala. Isso pode ser (ab) usado para ter espaços nos nomes, embora isso esteja longe do código idiomático do Scala:

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

Caramba, você pode até ter guias nos identificadores:

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

Suponho que isto poderia concebivelmente ser idiomática para o povo de programação alfabetizada. Talvez.

O F # permite espaço em branco nos nomes dos identificadores, mas eles devem ser cercados com reticulares duplos. Veja a resposta a esta pergunta: https://stackoverflow.com/questions/6639688/using-keywords-as-identifiers-in-f .

Você pode considerar esse o caso em Cucumber / Gherkin , em que os nomes das funções são efetivamente sentenças com os argumentos incorporados neles.

Como uma extensão, eu esperaria que isso fosse mais comum em pequenas DSLs , onde a linguagem deveria ser amigável para não desenvolvedores. Por exemplo, muitos mecanismos de regras fornecem a capacidade de definir regras com uma descrição semelhante ao inglês, onde espaços podem ser usados ​​em identificadores.

FWIW, Tcl permite espaços (e quase todos os outros caracteres) nos identificadores, embora não seja comum tirar proveito desse recurso. O principal motivo pelo qual não é usado com muita frequência é apenas o fato de você precisar usar as aspas apropriadas. Por exemplo, o seguinte define uma variável chamada "meu nome" como "bob" e, em seguida, imprime

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

OTOH, é muito útil ao criar variáveis ​​dinamicamente, pois, ao criar essas variáveis, não é preciso se preocupar com caracteres ilegais

Existem poucos que eu conheço. Eu estou trabalhando em um , e a linguagem de programação flexível . O Inform faz, mas não é exatamente uma linguagem de programação de uso geral.

Se você considera um DSL de teste automatizado uma linguagem, a estrutura do robô permite espaços nos nomes das palavras-chave, e é muito idiomático. No exemplo a seguir "Diga olá" é um nome de palavra-chave, "Exemplo de caso de teste" é um nome de caso de teste e "$ {first name}" é uma variável:

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

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

A linguagem 4D permite espaço em branco nos nomes e variáveis ​​dos métodos. Geralmente é desaprovado na comunidade, mas todos os métodos e variáveis ​​internos os usam quando aplicável ( SET MENU ITEM PARAMETERpor exemplo)

O Smalltalk apresenta métodos de palavras-chave, como os a:b:c:que envolvem espaços em branco quando chamados. Por exemplo: a: 100 b: 200 c: 300. Este é um idioma padrão no idioma.

O PowerShell permite espaços em nomes de variáveis:

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

PS C:\> ${the var}
100

Eu vi menção de similar para VB, mas em JS isso é muito usado na verdade. Qualquer propriedade de um objeto em JavaScript pode ser acessada e configurada em forma de string com colchetes ou simplesmente como strings em literais de objeto. Os nomes de propriedades que não seguem as regras de nomeação de variáveis ​​de JS são inacessíveis via. notação, mas eles são úteis. Por exemplo, você pode mapear URLs para comportamento ou fazer referência a um grupo de pessoas por nome quando tiver certeza de que todas elas são únicas. Geralmente, é muito conveniente e fácil de ler:

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

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

Isso também facilita a reestruturação do JSON para facilitar o uso, sem perder o fator de objeto instantâneo quando inserido no JS.

O Power Query usa muito código gerado automaticamente. Eu acho que mais da metade dos identificadores gerados usam espaço em branco:

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 você pode ver, como em muitos idiomas, há uma sintaxe extra para desambiguar qual é o identificador.

Mas em lugares onde é inequívoco, nenhuma sintaxe extra é necessária:

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

Se você contar como um idioma real, a linguagem de script JMP ( http://www.jmp.com/support/downloads/pdf/jmp_scripting_guide.pdf ). Ele permite que os identificadores tenham espaço em branco (para torná-los mais "legíveis") e incentiva mais ou menos isso.

A linguagem de programação o42a que estou desenvolvendo atualmente suporta nomes de várias palavras . O idioma não possui palavras-chave e os nomes geralmente são separados por algum símbolo. Nos casos raros em que os dois nomes se seguem, o sublinhado é usado para separá-los.

O Authorware, cuja linguagem de script era baseada em Pascal não orientado a objetos, permitia espaços em nomes de variáveis, embora, com o tempo, as pessoas descobrissem os problemas de usá-los e se afastassem dele http://books.google.com/books?id= bHC88YignAkC & pg = PA428 & lpg = PA428 .

Editar: Esta resposta foi mostrada como incorreta. Consulte os comentários.

Se entendi sua pergunta corretamente, um compilador não pode permitir espaço (s) no nome do identificador porque pode causar nomes duplicados (a menos que um delimitador seja usado). Por exemplo:

int meu = 0; bool minha contagem = false; int count = 0; se (meu conde) ...

o termo 'minha contagem' é confuso; pode se referir à variável chamada 'minha contagem' ou talvez o desenvolvedor tenha esquecido de escrever um operador de relação como> entre minha e contagem.

O COBOL permitiu que os nomes de divisão e seção fossem separados por espaço, mas esses não são identificadores e variáveis, como na sua pergunta.