Выполнение ленивой последовательности (строки) Clojure в REPL

Question

Я пытаюсь реализовать ленивую последовательность (которая должна сгенерировать одну строку) в REPL, без везения. Исходный код работает отлично:

(def word_list ["alpha" "beta" "gamma" "beta" "alpha" "alpha" "beta" "beta" "beta"]) 
(def word_string (reduce str (interpose " " word_list))); 
word_string ; "alpha beta gamma beta alpha alpha beta beta beta" 

Но не желая оставить в покое, я задавался вопросом, что еще будет работать, и попытался удалить reduce, думая, что str может иметь тот же эффект. Это не ...

(def word_string (str (interpose " " word_list))) 
word_string ; "clojure.lang.LazySeq@304a9790" 

Я попробовал очевидное, используя reduce снова, но это не сработало. Там в another question о реализации ленивых последовательностей, которые казались многообещающими, но ничего я пытался не работал:

(reduce str word_string) ; "clojure.lang.LazySeq@304a9790" 
(apply str word_string) ; "clojure.lang.LazySeq@304a9790" 
(println word_string)  ; "clojure.lang.LazySeq@304a9790" 
(apply list word_string) ; [\c \l \o \j \u \r \e \. \l \a \n \g \. \L \a \z \y...] 
(vec word_string)   ; [\c \l \o \j \u \r \e \. \l \a \n \g \. \L \a \z \y...] 
(apply list word_string) ; (\c \l \o \j \u \r \e \. \l \a \n \g \. \L \a \z \y...) 
(take 100 word_string)  ; (\c \l \o \j \u \r \e \. \l \a \n \g \. \L \a \z \y...) 

Тот факт, что некоторые из вариантов, дал мне символы в «clojure.lang.LazySeq» также беспокоит меня - сделал Я как-то теряю фактическое значение строки, а моя ссылка имеет значение «clojure.lang.LazySeq»? Если нет, то как я действительно реализую ценность?

Чтобы уточнить: учитывая, что word_string назначен ленивой последовательности, как бы я это понял? Что-то вроде (realize word_string), скажем, если это существовало.

Update: на основе принятого Ответ и как str работы, то получается, что я может получить фактическое значение последовательности, а не только его имя:

(reduce str "" word_string) ; "alpha beta gamma beta alpha alpha beta beta beta" 

Да, это ужасно код , :) Я просто пытался понять, что происходит, почему он ломается, и действительно ли фактическое значение там или нет.

Answer 1

Что вы хотите:

(def word_string (apply str (interpose " " word_list))) 

Посмотрите документацию str:

При отсутствии аргументов, возвращает пустую строку. С одним аргументом x возвращает
x.toString(). (str nil) возвращает пустую строку. С более чем
один аргумент arg возвращает конкатенацию значений str аргументов.

Так вы звоните .toString на последовательности, которая создает представление, что вместо применения str к элементам последовательности в качестве аргументов.

BTW, тем более идиоматический способ сделать то, что вы хотите:

(clojure.string/join " " word_list) 

Кроме того, строка не ленивая последовательность. interpose возвращает ленивую последовательность, и вы вызываете .toString.

Answer 2

Вам не нужно ничего делать, чтобы реализовать ленивый seq в clojure, вы просто используете его в любом месте, где ожидается seq.

user=> (def word-list ["alpha" "beta" "gamma" "beta" "alpha" "alpha" "beta" "beta" "beta"]) 
#'user/word-list 
user=> (def should-be-a-seq (interpose " " word_list)) 
#'user/should-be-a-seq 
user=> (class should-be-a-seq) 
clojure.lang.LazySeq 

Итак, мы имеем SEQ, если я использую его в любом случае, что бы пройти через все значения в SEQ, он будет в конечном итоге полностью реализованы. например

user=> (seq should-be-a-seq) 
("alpha" " " "beta" " " "gamma" " " "beta" " " "alpha" " " "alpha" " " "beta" " " "beta" " " "beta") 

Это все еще seq, хотя на самом деле это все тот же объект, что и раньше.

user=> (str should-be-a-seq) 
"clojure.lang.LazySeq@304a9790" 

Как Диего Баш упомянул, называя ул на что-то просто как вызов .ToString, что для метода LazySeq является, по-видимому просто .ToString по умолчанию, который наследуется от Object.

Поскольку это seq, вы можете использовать его как любой seq, независимо от того, было ли это полностью реализовано ранее или нет. например