How to use nested for in clojure [closed] - clojure

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 6 years ago.
Improve this question
I have a list of lists,((1,2,3,4)(2,3,4,5)(3,4,5,6)) and I want to implement for loop in clojure. I want to first get the first list i.e, (1,2,3,4) and then again implement for loop in this to get each element.
Thank you

Answer 1

Clojure's for is not a looping structure.
It is a macro that generates a combination of the necessary nested
map, filter, and take-while calls. These operate on sequences.
It always produces a lazy sequence.
From your question, I infer that you make sense of (1), but make nothing of (2) or (3). If you want to use Clojure effectively, understand their terms, and your question will answer itself.

Answer 2

If you want to loop through all the numbers as if they were in one list you can flatten the list:
> (flatten `((1,2,3,4)(2,3,4,5)(3,4,5,6)))
(1 2 3 4 2 3 4 5 3 4 5 6)
After that, to do an action against all the numbers you could use any function that takes in a list of numbers. Here's an example using reduce and +:
> (reduce + (flatten `((1,2,3,4)(2,3,4,5)(3,4,5,6))))
42

Answer 3

A for expression is meant to transform a collection into another collection, which is the return value. A doseq expression is meant to have side effects and always returns nil.
Here is some example code & results. Note that I usually prefer forv instead of for, as forv is not lazy and always returns results in a vector.
(ns xyz
(:require [tupelo.core :as t] ))
(t/refer-tupelo)
(def data
'[ (1,2,3,4)
(2,3,4,5)
(3,4,5,6) ] )
(newline)
(println "forv demo")
(spyx (forv [i [1 2 3]]
(spyx i )))
(newline)
(println "doseq demo")
(spyx (doseq [i [1 2 3]]
(spyx i )))
(println "-----------------------------------------------------------------------------")
(newline)
(println "for 1d")
(println "final result ="
(forv [sub-list data]
(spyx sub-list )))
(newline)
(println "for 2d")
(println "final result ="
(forv [sub-list data
int-val sub-list]
(spyx int-val )))
(newline)
(newline)
(println "for 2d-2")
(println "final result ="
(forv [sub-list data]
(forv [int-val sub-list]
(spyx int-val ))))
(newline)
(println "-----------------------------------------------------------------------------")
(newline)
(println "doseq 1d")
(doseq [sub-list data]
(println "sub-list =" sub-list ))
(newline)
(println "doseq 2d")
(doseq [sub-list data]
(doseq [int-val sub-list]
(spyx int-val )))
(newline)
(println "doseq 2d-2")
(doseq [sub-list data
int-val sub-list]
(spyx int-val ))
The first shows that both loop over data, but for/forv return a new collection, while doseq returns nil and is only intended for side effects.
forv demo
i => 1
i => 2
i => 3
(forv [i [1 2 3]] (spyx i)) => [1 2 3]
doseq demo
i => 1
i => 2
i => 3
(doseq [i [1 2 3]] (spyx i)) => nil
The second part shows how for can be used for 1-d or 2-d loops. Also, a single forv statement can to 2-d looping, or you can nest the forv statements. Notice the difference in nesting in the final result for the 3 cases.
-----------------------------------------------------------------------------
for 1d
sub-list => (1 2 3 4)
sub-list => (2 3 4 5)
sub-list => (3 4 5 6)
final result = [(1 2 3 4) (2 3 4 5) (3 4 5 6)]
for 2d
int-val => 1
int-val => 2
int-val => 3
int-val => 4
int-val => 2
int-val => 3
int-val => 4
int-val => 5
int-val => 3
int-val => 4
int-val => 5
int-val => 6
final result = [1 2 3 4 2 3 4 5 3 4 5 6]
for 2d-2
int-val => 1
int-val => 2
int-val => 3
int-val => 4
int-val => 2
int-val => 3
int-val => 4
int-val => 5
int-val => 3
int-val => 4
int-val => 5
int-val => 6
final result = [[1 2 3 4] [2 3 4 5] [3 4 5 6]]
-----------------------------------------------------------------------------
The doseq syntax is similar to for, but only the side effects like print are visible to the outside world. doseq always returns nil. This also implies there is no nesting difference in the return value like with forv.
doseq 1d
sub-list = (1 2 3 4)
sub-list = (2 3 4 5)
sub-list = (3 4 5 6)
doseq 2d
int-val => 1
int-val => 2
int-val => 3
int-val => 4
int-val => 2
int-val => 3
int-val => 4
int-val => 5
int-val => 3
int-val => 4
int-val => 5
int-val => 6
doseq 2d-2
int-val => 1
int-val => 2
int-val => 3
int-val => 4
int-val => 2
int-val => 3
int-val => 4
int-val => 5
int-val => 3
int-val => 4
int-val => 5
int-val => 6
Note that your project.clj will need to include the following for spyx to work
:dependencies [
[tupelo "0.9.10"]