Emacs Org-mode Babel: “Emaranhado” para o bloco Results

Question

Eu quero usar o modo de organização para calcular trechos longos ao concatenar trechos.

Estou aberto a uma abordagem não-Babel. Tabelas me ocorreram, mas não consegui ver como referenciar uma célula de fora da tabela de uma maneira que importasse o conteúdo da célula, não apenas links para ela.

Com o Babel, eu tenho blocos de texto que eu referencio via noweb em um bloco de texto final. Não consigo descobrir como fazer um bloco de texto emitir algo para #+RESULTS: . Não há mecanismo eval. Eu tentei usar o elisp, mas as novas linhas o ativaram, e eu não posso M-q formatar a saída de outra forma, já que as funções incorporadas são interativas. Para o modo de texto, posso me enredar em um arquivo externo, mas não inline.

Alguma ideia? Eu devo estar esquecendo alguma coisa. Eu não posso imaginar isso é difícil.

[EDITAR]:

#+NAME: abc
#+BEGIN_SRC text
  This is a string that is way too long to be on one line.
  The point of this whole question is that blocks with hard paragraph
  breaks don't work with the elisp noweb block.
#+END_SRC

#+NAME: def
#+BEGIN_SRC text
  This is also a string that is way too long to be on one line.
  Again, the point of this whole question is that blocks
  with hard paragraph breaks don't work with the elisp
  noweb block.
#+END_SRC

#+BEGIN_SRC elisp :noweb yes :results output
  (princ "<<abc>>")
  (princ "<<def>>")
#+END_SRC

Ao avaliar, recebo a mensagem "Fim do arquivo durante a análise". Quando me deparo com um arquivo externo para inspecionar, o que eu vejo é isto:

(princ "This is a string that is way too long to be on one line.
(princ "The point of this whole question is that blocks with hard paragraph
(princ "breaks don't work with the elisp noweb block.")
(princ "This is also a string that is way too long to be on one line.
(princ "Again, the point of this whole question is that blocks
(princ "with hard paragraph breaks don't work with the elisp
(princ "noweb block.")

Observe como as linhas que não são de terminal em cada bloco de texto não recebem aspas duplas ou parênteses de fechamento. Isto é obviamente mal formado.

Mais uma vez, não me importa como isso é feito. Eu só quero ser capaz de calcular longas passagens de texto que envolvem bem a linha ou preservam meus envoltórios de linha dura.

Parece que nem as tabelas de modo organizacional nem o babel de modo orgânico podem fazer isso. Não consigo encontrar uma função elisp que faça o equivalente a fill-paragraph em uma string, por exemplo, em uma lista. Isso resolveria isso.

    

Answer 1

Espero que eu não tenha entendido mal a questão, mas, aqui está uma tentativa:

Eu começo com isso em uma tabela organizacional:

#+BEGIN_SRC emacs-lisp
(setq s1 "hello")
(setq s2 " world")
(setq s3 "!")
(concat s1 s2 s3)
#+END_SRC 

#+RESULTS:
: hello world!

para obter os resultados Coloquei meu cursor dentro da seção SRC e chamei a função:

M + x org-babel-execute-src-bloco

que para mim é mapeado para um atalho de teclado CTRL + c CTRL + c (o mapeamento padrão )

pede confirmação para executar o comando. Ou eu entendi mal os requisitos? elisp deve funcionar com emacs sem instalar nada (para python, JS você terá que instalar coisas).

    

Answer 2

Ah! programação alfabetizada. Eu pensei que era uma questão puramente org-mode. Isso pode ajudar:

#+NAME: getString1
#+BEGIN_SRC text
"do your homework"
#+END_SRC

#+NAME: getString2
#+BEGIN_SRC text
"if you want to learn computer science"
#+END_SRC

#+NAME: getString3
#+BEGIN_SRC text
"as well as Prof. D. Knuth"
#+END_SRC

#+NAME: elispProg
#+BEGIN_SRC elisp :noweb yes
(concat <<getString1>> " " <<getString2>> " " <<getString3>>)
#+END_SRC

#+RESULTS: elispProg
: do your homework if you want to learn computer science as well as Prof. D. Knuth

#+NAME: pythonProg
#+BEGIN_SRC python :noweb yes
return "{} {} {}".format(<<getString1>>, <<getString2>>, <<getString3>>)
#+END_SRC

#+RESULTS: pythonProg
: do your homework if you want to learn computer science as well as Prof. D. Knuth

Neste exemplo, existem três strings (chamadas de "texto") e dois exemplos de programas que usam essas strings. Você pode ver o padrão na descrição do tipo. Algumas coisas são "texto", "elisp" e python. elisp e python são duas linguagens de programação diferentes. Se você colocar seu cursor na seção chamada elispProg ou pythonProg e fazer um CTRL + c CTRL + c ( aka org-babel-execute-src-block) você deve ver os resultados. O sinalizador nas seções de código ": agora sim" é da documentação no editor do emacs: "Expansão das referências de sintaxe do Noweb no corpo do 'src'      bloco de código ao avaliar, enrolar ou exportar ". Tangling é a palavra do Prof. Kunth para executar as seções de código. Portanto, a longa história é que o dobro" < < < "referencie outros blocos e expanda se a bandeira": now yes " Você pode controlar exatamente o que acontece quando a avaliação (exec src block) ocorre.Aqui estão os documentos: link

    

Answer 3

Eu vejo que entendi mal o problema. Aqui está outra tentativa. É um pouco rápido / hacky, mas parece funcionar. Ele apenas copia a longa cadeia concatenada em um buffer tmp marcando todo o buffer, chamando o parágrafo de preenchimento, colocando o resultado no anel de clipe e retornando a string formatada. Então, agora é apenas um parágrafo de preenchimento que consome uma string, formata-a e retorna a string formatada.

(setq noNewlines "This is a string that is way too long to be on one line. The point of this whole question is that blocks with hard paragraph  breaks don't work with the elisp noweb block.")

(setq newLines "This is also a string that is way too long to be on one line.
  Again, the point of this whole question is that blocks
                          with hard paragraph breaks don't work with the elisp
  noweb block.")

(setq my-paragraph (concat noNewlines newLines))

(defun wrap-string (str)
  "here we are going to wrap a long string so that is a nicely formatted paragraph"
  (interactive)
  (save-excursion
    (let* ((buf-name "*tmp-fill-paragraph*")
           (buffer (get-buffer-create buf-name))
           (result))
      (set-buffer buffer)
      (erase-buffer)
      (insert str)
      (mark-whole-buffer)
      (fill-paragraph)
      (copy-region-as-kill (point-min) (point-max))
      (kill-buffer buf-name)
      (car kill-ring-yank-pointer) )))

(wrap-string my-paragraph)

isto é o que eu vejo como resultado: