Clojure seq return function vs direct 'def' of seq

Question

Newbie Clojure вопрос. Каковы плюсы и минусы следующих двух способов реализации/представления последовательности Фибоначчи? (В частности, есть все, чтобы полностью исключить один или другой как плохая идея.)

(ns clxp.fib 
    (:gen-class)) 

; On the one hand, it seems more natural in code to have a function that 
; returns 'a' Fibonacci sequence. 
(defn fib-1 
    "Returns an infinite sequence of Fibonnaci numbers." 
    [] 
    (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1]))) 

; > (take 10 (fib-1)) 
; (0 1 1 2 3 5 8 13 21 34) 

; On the other hand, it seems more mathematically natural to define 'the' 
; Fibonacci sequence once, and just refer to it. 
(def fib-2 
    "The infinite sequence of Fibonnaci numbers." 
    (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1]))) 

; > (take 10 fib-2) 
; (0 1 1 2 3 5 8 13 21 34) 

а) Каковы плюсы и минусы этих двух подходов к определению бесконечную последовательность? (Я знаю, что это несколько особый случай в том, что эта конкретная последовательность не требует никаких аргументов - в отличие, скажем, от бесконечной последовательности кратных «n», которая, по моему мнению, потребует первого подхода, чтобы указать значение «n».)

b) Есть ли какая-либо чрезмерная причина, чтобы предпочесть одну из этих реализаций другой? (Потребление памяти, применимость при использовании в качестве аргумента и т. Д.)

Answer 1

fib-2 является предпочтительным в пользу времени, если его элементы просматриваются несколько раз, потому что в ленивом seq их нужно только рассчитывать один раз.

В связи с глобальным связыванием seq вряд ли когда-либо станет сборщиком мусора, поэтому, если ваша программа пройдет через миллион фибоначчи, чтобы сделать некоторые вычисления один раз, тем более, если ему не нужно удерживать голову seqs, вызов fib-1 в локальном контексте предпочтительнее в отношении производительности пространства.

Answer 2

Это зависит от вашего использования и того, насколько важно не переваривать fib seq несколько раз. Однако из моих экспериментов ниже у меня были проблемы с def при использовании длинных последовательностей.

Если вы собираетесь ссылаться на множество элементов, то вам нужно будет следить за удержанием головы, как сказал Леон.

Это можно проиллюстрировать следующим образом (они расширяют несколько примеров из Clojure программирования):

(let [[t d] (split-with #(< % 10) (take 1e6 (fib-1)))] 
    [(count d) (count t)]) 
=> OutOfMemoryError Java heap space 

(let [[t d] (split-with #(< % 10) (take 1e6 (fib-1)))] 
    [(count t) (count d)]) 
=> [7 999993] 

Note, я должен изменить реализацию, чтобы использовать исходный вектор [0 1N] избежать ArithmeticException integer overflow при приеме больших последовательности чисел fib.

Интересно, изменение к использованию Фибо-2 вместо дает ту же ошибку ООМ для удержания головы случай, но без головы, удерживающие версии брейки:

(let [[t d] (split-with #(< % 10) (take 1e6 fib-2))] 
    [(count t) (count d)]) 
=> [7 270036] 

Последняя цифра должна быть 999993.

причина ООМ в обоих случаях, как указано в Clojure Программирование:

так как последнее обращение т не происходит до обработки д, не ссылка на голова последовательности диапазона сохраняется, и не возникает памяти .