I am trying to make a sequence that will only generate values until it finds the following conditions and return the listed results:

case head =

• 0 - return {:origin [all generated except 0] :pattern 0}
• 1 - return {:origin nil :pattern [all-generated-values] }
• repeated-value - {:origin [values-before-repeat] :pattern [values-after-repeat]

{

; n = int
; x = int
; hist - all generated values

; Keeps the head below x 
(defn trim-head [head x]
  (loop [head head]
    (if (> head x)
      (recur (- head x))
      head)))

; Generates the next head
(defn next-head [head x n]
  (trim-head (* head n) x))

(defn row [x n]
   (iterate #(next-head % x n) n))

; Generates a whole row - 
; Rows are a max of x - 1.
(take (- x 1) (row 11 3))

Examples of cases to stop before reaching end of row:

[9 8 4 5 6 7 4] - '4' is repeated so STOP. Return preceding as origin and rest as pattern.

{:origin [9 8] :pattern [4 5 6 7]}

[4 5 6 1] - found a '1' so STOP, so return everything as pattern

{:origin nil :pattern [4 5 6 1]}

[3 0] - found a '0' so STOP

{:origin [3] :pattern [0]}

:else if the sequences reaches a length of x - 1:

{:origin [all values generated] :pattern nil}

The Problem

I have used partition-by with some success to split the groups at the point where a repeated value is found, but would like to do this lazily. Is there some way I can use take-while, or condp, or the :while clause of the for loop to make a condition that partitions when it finds repeats?

Some Attempts

(take 2 (partition-by #(= 1 %) (row 11 4)))

(for [p (partition-by #(stop-match? %) head) (iterate #(next-head % x n) n)
        :while (or (not= (last p) (or 1 0 n) (nil? (rest p))]
  {:origin (first p) :pattern (concat (second p) (last p))}))

# Updates

What I really want to be able to do is find out if a value has repeated and partition the seq without using the index. Is that possible? Something like this -

{

(defn row [x n]
  (loop [hist [n]
         head (gen-next-head (first hist) x n)
         steps 1]
    (if (>= (- x 1) steps)
      (case head
        0 {:origin [hist] :pattern [0]}
        1 {:origin nil :pattern (conj hist head)}
        ; Speculative from here on out 
        (let [p (partition-by #(apply distinct? %) (conj hist head))]
          (if-not (nil? (next p)) ; One partition if no repeats.
            {:origin (first p) :pattern (concat (second p) (nth 3 p))}
            (recur (conj hist head) (gen-next-head head x n) (inc steps)))))
      {:origin hist :pattern nil})))

}