Supporto per legatura OTF in Emacs

PragmataPro è un carattere tipografico fornito con una serie di legature di programmazione . La mia comprensione è che si tratta di legature per facciate OpenType (OTF).

Sono consapevole che Emacs supporta la sostituzione programmatica di combinazioni di caratteri (ad esempio ->verso ⟶o lambdaverso λ). Tuttavia, si tratta di legature false unicode, poiché hanno i loro punti di codice, cosa che le legature reali non hanno.

Ho ragione che Emacs (a partire da 25) non supporta automaticamente le legature OTF? A un livello inferiore, sono disponibili opzioni per specificare manualmente i mapping dei glifi?

Se le legature non sono supportate, cosa deve essere fatto affinché Emacs supporti le legature?

emacs per ora non supporta le legature (su OSX c'è del supporto, ma non su altre piattaforme). Tuttavia, emacs 24.4+ supporta prettify-symbols-modeche in qualche modo è migliore del normale supporto delle legature.

Tale modalità consente di sostituire per visualizzare qualsiasi regex con qualsiasi glifo. Sto usando personalmente questo frammento per far funzionare le legature del codice Fira in emacs su linux. (EDIT: sfortunatamente il link è ora morto, la politica di stackoverflow per copiare sempre in linea è ovviamente quella buona ...)

Il link che ho inserito inizialmente è morto e non sono sicuro di cosa contenga, ma penso che questi link dovrebbero essere buoni: https://github.com/tonsky/FiraCode/wiki/Emacs-instructions#using-prettify-symbols e https://github.com/tonsky/FiraCode/issues/312#issuecomment-262878734

Dato il problema del dead link, questa volta inserirò il codice:

(defun fira-code-mode--make-alist (list)
  "Generate prettify-symbols alist from LIST."
  (let ((idx -1))
    (mapcar
     (lambda (s)
       (setq idx (1+ idx))
       (let* ((code (+ #Xe100 idx))
          (width (string-width s))
          (prefix ())
          (suffix '(?\s (Br . Br)))
          (n 1))
     (while (< n width)
       (setq prefix (append prefix '(?\s (Br . Bl))))
       (setq n (1+ n)))
     (cons s (append prefix suffix (list (decode-char 'ucs code))))))
     list)))

(defconst fira-code-mode--ligatures
  '("www" "**" "***" "**/" "*>" "*/" "\\\\" "\\\\\\"
    "{-" "[]" "::" ":::" ":=" "!!" "!=" "!==" "-}"
    "--" "---" "-->" "->" "->>" "-<" "-<<" "-~"
    "#{" "#[" "##" "###" "####" "#(" "#?" "#_" "#_("
    ".-" ".=" ".." "..<" "..." "?=" "??" ";;" "/*"
    "/**" "/=" "/==" "/>" "//" "///" "&&" "||" "||="
    "|=" "|>" "^=" "$>" "++" "+++" "+>" "=:=" "=="
    "===" "==>" "=>" "=>>" "<=" "=<<" "=/=" ">-" ">="
    ">=>" ">>" ">>-" ">>=" ">>>" "<*" "<*>" "<|" "<|>"
    "<$" "<$>" "<!--" "<-" "<--" "<->" "<+" "<+>" "<="
    "<==" "<=>" "<=<" "<>" "<<" "<<-" "<<=" "<<<" "<~"
    "<~~" "</" "</>" "~@" "~-" "~=" "~>" "~~" "~~>" "%%"
    "x" ":" "+" "+" "*"))

(defvar fira-code-mode--old-prettify-alist)

(defun fira-code-mode--enable ()
  "Enable Fira Code ligatures in current buffer."
  (setq-local fira-code-mode--old-prettify-alist prettify-symbols-alist)
  (setq-local prettify-symbols-alist (append (fira-code-mode--make-alist fira-code-mode--ligatures) fira-code-mode--old-prettify-alist))
  (prettify-symbols-mode t))

(defun fira-code-mode--disable ()
  "Disable Fira Code ligatures in current buffer."
  (setq-local prettify-symbols-alist fira-code-mode--old-prettify-alist)
  (prettify-symbols-mode -1))

(define-minor-mode fira-code-mode
  "Fira Code ligatures minor mode"
  :lighter " Fira Code"
  (setq-local prettify-symbols-unprettify-at-point 'right-edge)
  (if fira-code-mode
      (fira-code-mode--enable)
    (fira-code-mode--disable)))

(defun fira-code-mode--setup ()
  "Setup Fira Code Symbols"
  (set-fontset-font t '(#Xe100 . #Xe16f) "Fira Code Symbol"))

(provide 'fira-code-mode)

Ho detto che per certi versi è meglio delle normali legature. Questo perché è "a la carte". Puoi mescolare e abbinare, prendi solo i simboli che ti piacciono. Puoi dire, voglio il ";;" legatura, TRANNE se il carattere successivo è di nuovo ";" in quel caso non lo voglio ... E riguardo al mix-and-matching ... Sto usando il carattere 'Fira Mono', insieme alle legature 'Fira Code'. Non è necessario acquistare l'intero carattere.

È peggio delle pure legature perché non funziona immediatamente e richiede che il carattere sia sintonizzato in un certo modo per renderlo possibile.

Se sei su OS X, credo che la porta Emacs di Carbon Mac supporti le legature.