Grid layout that puts things in column order

Question

I have the code below which works great. It displays words in alphabetical order in a nice grid. And it works great on different devices, iphone, ipad. Eg, when rotating an ipad from portrait to landscape, I get more columns. It fills the screen no matter what device/orientation, and to see anything missing I scroll vertically. All good.

However, the one issue I'd like to solve is I'd like the items to be displayed in column order. Right now they are displayed in row order, first row1, then row2, etc, but I want to do it by column. First populate col1, then go to col2, etc.

I understand that LazyHGrid does populate in this order but I can't seem to get something that works (eg, I end up with all words in one row). Ideas?

struct ContentView: View {
    
    func getWords() -> [String] {
        var retval: [String] = []
        let alpha = "abcdefghijklmnopqrstuvwxyz"
        
        for _ in 0...500 {
            let length = Int.random(in: 4...16)
            retval.append( String(alpha.shuffled().prefix(length)).capitalized )
        }
        return retval.sorted()
    }
    
    func getColumns() -> [GridItem] {
        return [GridItem(.adaptive(minimum: 150))]
    }
 
    var body: some View {
        ScrollView() {
            LazyVGrid(columns: getColumns(), alignment: .leading) {
                ForEach(getWords(), id: \.self) { word in
                    Text(word)
                }
            }.padding()
        }
    }
}

EDIT: This is a version with the HGrid, but it just displays everything in one row. I don't want to have to specify the number of rows/columns, I really want things to work exactly like the VGrid version, except for the col vs row layout.

    var body: some View {
        ScrollView() {
            LazyHGrid(rows: getColumns(), alignment: .top) {
                ForEach(getWords(), id: \.self) { word in
                    Text(word)
                }
            }.padding()
        }
    }

Answer 1

The LazyHStack is the way to go, and while you do have to specify the number of rows, you don't have to hard code that number. I had to alter your MRE a bit as you do have to have the words initialized before you hit the LazyHGrid(), so your calling the function in the ForEach won't work. In a working app, you would have some variable already initialized to use, so this should not be a problem. So, an example of your view would be this:

struct ContentView: View {
    @State var words: [String] = []
    // The GridItem has to be .flexible, or odd numbers of words will add an extra column
    let row = GridItem(.flexible(), alignment: .leading)
    @State var numberOfColumns = 2.0
    
    var body: some View {
        VStack{
            Stepper("Columns") {
                numberOfColumns += 1
            } onDecrement: {
                if numberOfColumns > 2 {
                    numberOfColumns -= 1
                }
            }
            ScrollView() {
                // The parameter for rows becomes an array that you create on the fly,
                // repeating the row for half the words rounded to give an extra line
                // for an odd number of words.
                LazyHGrid(rows: Array(repeating: row, count: Int((Double(words.count) / numberOfColumns).rounded()))) {
                    ForEach(words, id: \.self) { word in
                        Text(word)
                    }
                }.padding()
            }
        }
        .onAppear {
            // Didn't want to deal with a static func, so just set the words here.
            words = getWords()
        }
    }
    
    func getWords() -> [String] {
        var retval: [String] = []
        let alpha = "abcdefghijklmnopqrstuvwxyz"
        
        for _ in 0...500 {
            let length = Int.random(in: 4...16)
            retval.append( String(alpha.shuffled().prefix(length)).capitalized )
        }
        return retval.sorted()
    }
}

Edit:

I believe this is what you are looking for. The following code will set the columns as above, and automatically compute the number of columns based off of the width of the word. It will also recompute the number of columns upon rotation, or changing of the list of words. I built in some ability to play with the view to see how it works. This was simply a math problem. The PreferenceKeys just give the numbers you need for the computations.

Of course, the PreferenceKeys use GeometryReaders to determine these sizes, but there is no other way to get this information. It is very likely that behind the scenes, LazyVGrid and LazyHGrid are also using GeometryReader.