Lisp: замена подстрок в строке

pilot

 >>> print "' \\".replace("\\","\\\\").replace("'","\\'")

\' \\ 

Ivan8209

Marinavo_0507

vook

pilot

> (format nil "~A" (cl-ppcre:regex-replace "'" "foo' bar" "\\\\'"

"foo\\' bar"

Ivan8209

(use-modules (srfi srfi-13



(define (qt str)

  (string-concatenate

   (map (lambda (ch) (case ch #\') "\\'")

			   (else (list->string (list ch

	(string->list str



(define (qt str)

  (string-concatenate

   (map (lambda (ch)

	  (list->string (if (member ch '(#\' (list #\\ ch) (list ch

	(string->list str



(begin (display (qt "te'st" (newline





(define (qts str lst qch)

  (string-concatenate

   (map (lambda (ch)

	  (list->string (if (member ch lst) (list qch ch) (list ch

	(string->list str



(begin (display (qts "te'#st" (string->list "'#") #\\   (newline

$ guile -l ~/scm/quote-str.scm

te\'st

te\'\#st

guile> (begin (display (qt "te'st" (newline

te\'st

guile> (qt "te'st")

"te\\'st"

vook

Да, спасибо, ppcre я пробую:

code:> (format nil "~A" (cl-ppcre:regex-replace "'" "foo' bar" "\\\\'"
"foo\\' bar"
но как сделать "foo\' bar"?
Задача в чем: у меня есть БД (postgresql) и я хочу через clsql:insert-records добавить в таблицу строку типа text, в которой встречаются '

CL-USER> (format nil "~A" (cl-ppcre:regex-replace "'" "foo' bar" "\\\\'"

"foo\\' bar"

CL-USER> (length *)

9

  

CL-USER> (loop for x across ** do (print x



#\f 

#\o 

#\o 

#\\ 

#\' 

#\  

#\b 

#\a 

#\r 

NIL

CL-USER> 

pilot

 ( defun string-replace ( str1 sub1 sub2 )

    ( setq str1 ( string str1 ) )

    ( setq str2 "" )

    ( setq sub1 ( string sub1 ) )

    ( setq sub2 ( string sub2 ) )

    ( setq index1 0 )

    

    ( loop 

        ( if

            ( string-equal str1 sub1 :start1 index1 :end1 ( + index1 ( length sub1 ) ) :start2 0 ) 

;        then

            (

                ( setq str2 ( concatenate 'string str2 sub2 ) )

                ( setq index1 ( + index1 ( length sub1 ) ) )

            )

;        else

            (

                ( setq str2 ( concatenate 'string str2 ( char str1 index1 ) ) )

                ( incf index1 )

            )

        )

        ( when ( > index1 ( length str1 ) ) ( return str2 ) )

    )

) 

Ivan8209

[[library procedure]] (write obj)

[[library procedure]] (write obj port)



Writes a written representation of obj to the given port.  Strings that appear

in the written representation are enclosed in doublequotes, and within those

strings backslash and doublequote characters are escaped by backslashes.

Character objects are written using the #\ notation.  Write returns an

unspecified value.  The port argument may be omitted, in which case it defaults

to the value returned by current-output-port.





[[library procedure]] (display obj)

[[library procedure]] (display obj port)



Writes a representation of obj to the given port.  Strings that appear in the

written representation are not enclosed in doublequotes, and no characters are

escaped within those strings.  Character objects appear in the representation

as if written by write-char instead of by write.  Display returns an

unspecified value.  The port argument may be omitted, in which case it defaults

to the value returned by current-output-port.



Rationale:



  Write is intended for producing machine-readable output and display is for

  producing human-readable output.  Implementations that allow "slashification"

  within symbols will probably want write but not display to slashify funny

  characters in symbols.

Ivan8209

pilot

склеивание строк скопом

"\\'".join("foo'bar".split("'"

Ivan8209

(defun string-concatenate (lst) (fold 'string-concatenate-bin "" lst?

(defun string-concatenate-bin (s1 s2) (concatenate 'string str2 sub2 ; нагло выдернуто из твоего сообщения

vook

Из этого следует, что "Common" LISP настолько нечитаем,
что некоторые простейшие вещи оказываются вновинку
даже его апологетам:

pilot

_, строки склеиваются функцией concatenate:
(concatenate 'string "all" " " "together" " " "now") => "all together now"

Ivan8209

Ivan8209

vook

(defun join-strings (string-list delimiter)

           (with-output-to-string (to)

             (loop for x on string-list

                   do (princ (car x) to) 

                   if (cdr x) do (princ delimiter to

  

(defun join-strings (string-list delimiter)

           (reduce (lambda (&optional a b)

                     (when a (concatenate 'string a delimiter b

                   string-list

  

CL-USER> (join-strings '("foo" "bar" "baz") "\\.")

"foo\\.bar\\.baz"

  

pilot

Ivan8209

guile> (string-concatenate (cdr (apply append (map (lambda (elist "," e '("a" "b" "c"

"a,b,c"

Ivan8209

vook

Если человеку нужна программа, то пусть он пишет её сам.
То, что "Common LISP" настолько неподъёмен, что даже ты,
будучи апологетом этого диалекта, не в курсе того, что именно
печатается в REPL (Иначе с чего бы тебе открывать это
определяя длину строки? показывает твоё знание языка.

vook

Я читал "ANSI Common Lisp" Грехэма, а какие еще дельные книжки есть?

Ivan8209

Ivan8209

(use-modules (srfi srfi-1) (srfi srfi-13



(define (string-find s sub)

  (or (string-contains s sub) (string-length s



(define (take-prefix pfx s)

  (if (string-prefix? pfx s)

      (string-take s (string-length pfx

      (string-take s (string-find s pfx



(define (drop-prefix pfx s)

  (string-drop s 

	       (let posn (string-find s pfx

		 (if (zero? posn) (string-length pfx) posn



(define (string-break dlm s)

  (unfold string-null?

	  (lambda (s) (take-prefix dlm s

	  (lambda (s) (drop-prefix dlm s

	  s



(write (string-break "<br>" "Left!<br>Left!<br>Left!"

(newline)

("Left!" "<br>" "Left!" "<br>" "Left!")

vook

Ну-ну!
Сможешь показать, как _минуя_ "princ" достичь "желаемого результата",
заключающегося в выводе строки _как_она_есть_, а не
выворачивая внутренности, что более похоже на распечатку
памяти в отладчике?

 (write "\\aaaa" :escape nil)  

(let *print-escape* nil (write "\\aaaa"  

Ivan8209

vook

Ivan8209

vook

Ivan8209