Como determinar se o caractere atual é uma letra

Como posso determinar se o caractere atual é uma letra (um caractere alfabético) (isto é, pertence à classe de sintaxe [:alpha:]nas noções de expressão regular). Gostaria de escrever uma função simples como abaixo:

(defun test-letter () (interactive)
(if char-after-is-a-letter
    (message "This is a letter")
    (message "This is not a letter")
    )
)

Atualização Infelizmente, minha suposição sobre a equivalência da classe das letras e da classe da sintaxe [:alpha:]parece ser falsa.

Usar propriedades de caracteres Unicode

Definitivamente, isso deve funcionar:

(memq (get-char-code-property (char-after) 'general-category)
      '(Ll Lu Lo Lt Lm Mn Mc Me Nl))

Como bônus, também deve ser mais rápido que looking-at.

O Emacs armazena todas as propriedades de caracteres especificadas pelo padrão Unicode. Eles são acessíveis com get-char-code-property. Especificamente, a general-categorypropriedade especifica quais caracteres são letras ( Llsão minúsculas, Lumaiúsculas e não me perguntam o que os outros são).

EDIT: Esta resposta deve ser perfeitamente válida em 25.5 (onde o bug foi corrigido). Para versões mais antigas, use a outra opção .

Isso deve indicar se o caractere atual é uma letra e deve funcionar em qualquer idioma.

 (looking-at-p "[[:alpha:]]")

Eu acho que você pode se safar com isso:

(defun test-letter ()
  (interactive)
  (let ((char (char-after)))
    (if (and (eq (char-syntax char) ?w)
             (or (> char ?9)
                 (< char ?1)))
        (message "This is a letter")
      (message "This is not a letter"))))

Atualizar

Isso é menos eficiente, mas mais próximo do que você deseja:

(defun test-letter ()
  (interactive)
  (if (looking-at "[a-z-A-Z]")
      (message "This is a letter")
    (message "This is not a letter")))

Caso você estivesse muito preocupado com os caracteres nacionais e com o tratamento preciso das classes de caracteres Unicode, a única solução que encontrei até agora é a regexbiblioteca Python . Ambos grepe Perl(para minha total surpresa!) Não fizeram o trabalho corretamente.

Assim, a expressão regular que você está depois é este: \p{L}. Isso é conhecido como versão abreviada da propriedade Unicode, a versão completa é \p{Letter}ou mesmo p\{General_Category=Letter}. Letteré uma classe composta, mas não vou entrar em detalhes, a melhor referência que pude encontrar sobre o assunto está aqui .

A biblioteca Python não está embutida na linguagem (é uma alternativa à rebiblioteca embutida ). Então, você precisaria instalá-lo, por exemplo:

# pip install regex

Então, você pode usá-lo da seguinte maneira:

import regex
>>> regex.match(ur'\p{L}+', u'۱۲۳۴۵۶۷۸۹۰')
>>> regex.match(ur'\p{L}+', u'абвгд')
<regex.Match object; span=(0, 5), match=u'\u0430\u0431\u0432\u0433\u0434'>
>>> regex.match(ur'\p{L}+', u'123')
>>> regex.match(ur'\p{L}+', u'abcd')
<regex.Match object; span=(0, 4), match=u'abcd'>
>>> 

Você também pode colocar esse script em algum lugar onde você pode acessá-lo:

#!/usr/bin/env python
import regex
import sys

if __name__ == "__main__":
    for match in regex.finditer(ur'\p{L}+', sys.argv[1].decode('utf-8')):
        print match.string

E chame-o do Emacs assim (suponha que você tenha salvo esse script ~/bin):

(defun unicode-character-p ()
  (interactive)
  (let* ((current (char-after (point)))
         (result (shell-command-to-string
                  (format "~/bin/is-character.py '%c'" current))))
    (message
     (if (string= result "") "Character %c isn't a letter"
        "Character %c is a letter")
     current)))