Hallelujah, Nested Collections! (pt 1)

A collection of boxes containing collections of files containing collections of papers.

After the first run through of Launch School’s rb110 course and working through problem sets, I was still struggling to merge all of the concepts covered in the study guide into a cohesive story. One learning technique emphasized by “Make it Stick” is asking and answering questions. Here are some I had:

• How are method chaining and looping related?
• Why the relaxed attitude about not knowing every iterating, selection, or transformation function available?
• Why exactly are shallow copies relevant here? None of the practice problems seem to use .clone or .dup ?

All of Launch School’s assessments have incredible study guides, so one of my final study prep exercises is to create something with code that touches each of the concepts listed. A little like a story prompt, “Write a ‘man vs himself’ story with these things: A witch, a scooter, someone buying groceries, a soccer game, algebra, and a swarm of geese.” The goal is in seeing all these things come together — even if it’s a little contrived or convoluted.

As a beginner, I’m always reminded of the song line, “The baffled king composing hallelujah!” (If you’re not familiar, go listen to it here. Then come back.) Sometimes you have to start writing code before you understand exactly what’s going on.

The baffled queen (natch) composing hallelujah. (Generated by Bing, thanks AI!)

So I started at the beginning: by just creating what looked like a relatively complex nested collection that contained a variety of types of objects. It’s got Hashes! It’s got Arrays! It’s got Strings!

But I wanted it to be realistic, so I made up this little grade book structure.

grade_book = [
  {subject: "English",
   grades: [
            {grade_id: 17, type: "Exam", score: 4},
            {grade_id: 18, type: "Quiz", score: 3.5},
            {grade_id: 19, type: "Quiz", score: 3},
            {grade_id: 20, type: "Quiz", score: 3.5},
            {grade_id: 21, type: "Quiz", score: 2.5}
          ]
  },
  {subject: "Band",
   grades: [
            {grade_id: 200, type: "Exam", score: 2},
            {grade_id: 201, type: "Performance", score: 4},
            {grade_id: 202, type: "Assignment", score: 4}
          ]
  }
]

Talking about nested structures and Referencing specific items

“It goes like this…”

The first thing I like to do when synthesizing many interrelated concepts together is to get my language consistent. What kind of object is it, and what kind of objects does it contain?

So here are my observations on the collection I created (I’ve included it as a code block because Medium does not support nested lists.):

* grade_book IS an Array object, it CONTAINS a series of (2) Hash Objects.
  * Each Hash object contains two key-value pairs:
    * the :subject key has a String object as a value
    * the :grades key has an Array object as a value
      * the :grades Array contains a series of Hash objects
        * each of these Hash objects contain three key-value pairs:
          * :grade_id's value is an Integer
          * :type's value is a String object
          * :score's value is a Number (may or may not be a float)

I am no graphic designer, but I’ve made this rough sketch to illustrate

A graphic representation of the grade_book structure.

Manual Mode

“… the fourth, the fifth … “

Ok, so now I can talk about it. Let’s see if I can retrieve data from it manually, and assuming I’m omnipotent. (Hey, I like this!) I’ll decide on a distinct value I want to address — let’s say the value of the score in the same “grade” Hash with :grade_id 200. It’s also handy that this is the only score of 2, so I’ll know for sure if I get it right.

So I start composing like I’m navigating a maze. That score is inside the second element of the array grade_book, I’ll use [] to retrieve that object element.

grade_book[1]

The object is a hash, and the value I want is inside the :grades path. I can retrieve the value object by referencing the key.

grade_book[1][:grades]

The object I have now is an array. The value I want is inside the first element of the array.

grade_book[1][:grades][0]

Ok, the object I have now is another hash. I want the value tied to the :score key.

grade_book[1][:grades][0][:score]

Printing this gives me 2, as expected.

Well, ok. But if I were that intimately familiar with the data, I’d probably not need to retrieve it in the first place. What’s something more realistic?

Let’s do things with data!

So here’s the part where I make up a question for myself and then solve it wrong, solve it right, and solve it again another way. Very important to do it wrong, so please don’t skip that step.

My question is: “What is the average of the Quiz scores in English class?”

I can bring a little bit of the “problem” in PEDAC here and think about the problem domain and things I’ll “allow” myself to know, or assumptions I’m going to make.

• There is one and only one hash element in the array that matches subject: "English"
• There is at least one grade with type: "Quiz"

I can also think about what my output will look like (“examples”)

• "The average of (number) English quiz scores is (avg)"

Then I can think about the things I will need to gather. This could be part of the problem domain. For an average, I’ll need:

• A sum of the Quizzes
• The number of quizzes

And finally, a little bit on the “algorithm” thinking side, I’ll need to: (My initial thoughts on how to approach this specifically are in italics)

1. Get the hash whose :subject key matches “English”. (That sure sounds like a selection — maybe I’ll use .select)
2. Tally up the scores inside that hash on the grades whose :type matches “Quiz”, and also count them. (This sounds like iteration to me, maybe I’ll .each through the array, if it’s a quiz, I’ll sum and increment a counter.)

“… the minor fall …”

Here’s my first attempt:

sum = 0
count = 0
english_grades = grade_book.select {|subj| subj[:subject] == "English"}[:grades]
english_grades.each do |grade|
  if grade[:type] == "Quiz"
    sum += grade[:score]
    count += 1
  end
end
p "The average of #{count} English quizzes is: #{sum/count}"

… well shoot. Symbol to integer conversion, what?

example.rb:40:in `<main>': no implicit conversion of Symbol into Integer (TypeError)

english_grades = grade_book.select {|subj| subj[:subject] == "English"}[:grades]
                                                                        ^^^^^^^

OH YEAH. .select returns an array containing the elements whose block returns true. I “know” it’s only one element, but it’s stuck inside that array, and I can’t address an array location with a symbol!

This is where that method info table is important: What does the method do with the return value of the block? What does the method itself return?

Well, ok. Easy pitfall. Because I just want to get it to work, I’ll manually iterate through all the subjects and only act on the ones in the “English” hash.

grade_book.each do |subject|
  if subject[:subject] == "English"
    subject[:grades].each do |grade|
      if grade[:type] == "Quiz"
        sum += grade[:score]
        count += 1
      end
    end
  end
end

Ooooor… I can use my assumption that there will be only one item in that array, and I’ll go ahead and chain a [0] in line with the .select to “break out” the hash I want from the array. It feels kind of kludgy, so I make a mental note to return and see if there’s a better solution later.

sum = 0
count = 0

english_grades = grade_book.select {|subj| subj[:subject] == "English"}[0][:grades]
english_grades.each do |grade|
  if grade[:type] == "Quiz"
    sum += grade[:score]
    count += 1
  end
end
p "The average of #{count} English quizzes is: #{sum/count}"

Revelation: nested looping & comparisons can be accomplished via method chaining and vice versa!

“… the major lift …”

Alright, well that works. And now I know that if a method doesn’t work the way I expect, I can ‘downshift’ to basic loops and checks. And when I have a bunch of loops that work, I can ‘upshift’ using the right method.

Further, I can see a few things I want to explore:

• sum/count might go awry if my scores didn’t happen to have decimals; easy enough to add in a .to_f there
• Can I figure out a more precise method to use than .select so that I can get that [0] out of there?
• The .each iteration through all the grades feels a little wordy there, and I’m only doing things based on a single choice…

So here is where I squint at what I’m doing and say, “Well, I wouldn’t even need to make that check if I simply .select only the entries that are quizzes. That will give me an array of only the grades I want — I can use the length of this one as the count!”

sum = 0
english_quiz_grades = grade_book.select {|subj| subj[:subject] == "English"}[0][:grades].select {|grd| grd[:type] == "Quiz"}
english_quiz_grades.each do |grade|
  sum += grade[:score]
end
p "The average of #{english_quiz_grades.size} English quizzes is #{sum/english_quiz_grades.size.to_f}"

Hey! Looking good! But I do know there’s a built in .sum method I can use.

english_quiz_grades = grade_book.select {|subj| subj[:subject] == "English"}[0][:grades].select {|grd| grd[:type] == "Quiz"}
sum = english_quiz_grades.sum {|grade| grade[:score]}
p "The average of #{english_quiz_grades.size} English quizzes is #{sum/english_quiz_grades.size.to_f}"

Is it confusing in line 2 to pass a block into .sum? Maybe instead of an array of grade hashes and summing based on the return value from a particular key, it’d be easier with just the array of scores.

english_quiz_scores = grade_book.select {|subj| subj[:subject] == "English"}[0][:grades].select {|grd| grd[:type] == "Quiz"}.map {|grd| grd[:score]}
sum = english_quiz_scores.sum
p "The average of #{english_quiz_scores.size} English quizzes is #{sum/english_quiz_scores.size.to_f}"

This kind of review/revise cycle looks like it can continue for some time. It can be hard to decide when to stop! At this point I searched for “ruby method chaining long lines of code” and found myself unprepared to enter allegiance with either the “Trailing Dot” or “Leading Dot” factions, so I’ll leave that as an exercise for future meditations.

So now…

Now I understand how to sketch something out with rough iteration and progressively exchange those wordy checks and loops with chained methods!

Tune in next time to traipse through documentation and discover why knowing a few key details is more important than memorizing every single method out there. Forge your way through the Ruby Docs with me here.