DEV Community: kamya

SQL for the Potterhead: Outer Joins

kamya — Wed, 26 Feb 2020 04:07:00 +0000

In this article we will cover the Left Outer Join as well as the Right Outer Join. Let's dive in!

Hagrid has some extra pets, and he's thinking about giving some away as Christmas gifts. To do this, he wants to find the names of all the students who don't have pets. Can we help him?

We want all the students who don't have pets. Let's start by visualizing this:

Looking at the diagram, this looks very similar to the one for our left join, except that we now want to exclude data that is present in both the tables.

Let's start writing the query.

1.First, we will write a left join. This will give us all the wizards, and attach their pets if they have them:

postgres=#
SELECT * FROM wizard LEFT JOIN pet ON wizard.id = pet.owner_id;
 id |        name        |   house    | id |    name     | species | owner_id 
----+--------------------+------------+----+-------------+---------+----------
  1 | Neville Longbottom | Gryffindor |  2 | Trevor      | toad    |        1
  2 | Ronald Weasley     | Gryffindor |  1 | Scabbers    | rat     |        2
  3 | Harry Potter       | Gryffindor |  3 | Hedwig      | owl     |        3
  5 | Seamus Finnigan    | Gryffindor |    |             |         |         
  6 | Hermione Granger   | Gryffindor |  4 | Crookshanks | cat     |        6
  4 | Draco Malfoy       | Slytherin  |  5 | unknown      | owl     |        4
(6 rows)

All 6 rows in our wizards table are present. If a wizard has a pet, they have been added.

2.Looking at the data above, you might notice that the owner_id is blank for the wizards that did not have pets. Let's use that to filter down to just the wizards that have no pets:

SELECT * FROM wizard LEFT JOIN pet ON wizard.id = pet.owner_id WHERE pet.owner_id IS NULL;
 id |      name       |   house    | id | name | species | owner_id 
----+-----------------+------------+----+------+---------+----------
  5 | Seamus Finnigan | Gryffindor |    |      |         |         
(1 row)

3.Let's break down this query to make sure we understand it

SELECT *: We want to select all the fields from the tables
FROM wizard LEFT JOIN pet: We want to JOIN the wizard and pet table. We are using a left join, where the wizards table is to the left hand side, and the pets table is to the right hand side
ON wizard.id = pet.owner_id: This is the join condition, which tells our query how to join the results
WHERE pet.owner_id IS NULL; We only want to select the rows where the pet's owner_id is NULL

According to our dataset, Seamus Finnigan is the only wizard without a pet, which should match our understanding of the Harry Potter Universe.

3.2 Right Outer Join:

Hagrid is very worried about abandoned pets, and wants to make sure that all pets without owners are being fed. Can we help him find all the pets that don't have owners listed?

Let's start by visualizing the data we need, using a set diagram:

This is very similar to the example we just discussed with the LEFT OUTER JOIN above. Let's try and write some SQl.

Let's write a RIGHT JOIN, that will give us all the pets, and attach their owners if they have them:

postgres=#                                                                                                     
SELECT * FROM wizard RIGHT JOIN pet ON wizard.id = pet.owner_id;
 id |        name        |   house    | id |    name     | species | owner_id 
----+--------------------+------------+----+-------------+---------+----------
  1 | Neville Longbottom | Gryffindor |  2 | Trevor      | toad    |        1
  2 | Ronald Weasley     | Gryffindor |  1 | Scabbers    | rat     |        2
  3 | Harry Potter       | Gryffindor |  3 | Hedwig      | owl     |        3
  6 | Hermione Granger   | Gryffindor |  4 | Crookshanks | cat     |        6
  4 | Draco Malfoy       | Slytherin  |  5 | unknown      | owl     |        4
    |                    |            |  7 | Brodwin     | owl     |       10
    |                    |            |  6 | Norbert     | Dragon  |      100
(7 rows)

The pet's without owners have the wizard.id field blank. Let's use this to just return the pet's with no listed owners:

postgres=# 
SELECT pet.name FROM wizard RIGHT JOIN pet ON wizard.id = pet.owner_id WHERE wizard.name IS null;
  name   
---------
 Brodwin
 Norbert
(2 rows)

That looks good! Hedwig, Scabbers, Crookshanks and Malfoy's nameless owl are absent from this list!

Let's examine the SQL:

SELECT pet.name : Select only the pet's name
FROM wizard : the table on the left
RIGHT JOIN pet : the table on the right
ON wizard.id = pet.owner_id : the join clause, which specifies how we want the rows from the two tables to be joined
WHERE wizard.name IS null; : We want to filter out all the rows that are present in both tables. This will leave behind only the rows that are exclusive to the pet table

We have learnt about left and a right outer joins!

Like always, you can view this on github

SQL for the Potterhead: Inner Joins

kamya — Wed, 19 Feb 2020 05:01:35 +0000

Luna Lovegood wants to send a letter but none of the school owls are available. Can we write a query that will return the name of all the students who have owls, so she can find one to borrow??

Let's start by thinking of the data we need from each table:

From the pet table, we want all the pets that are owls
From the wizard table, we want all the wizards who have pets that are owls

Drawing a quick venn diagram, the relationship might look something like this:

Since we are only interested in data present in both tables, we will write an inner join. Let's write some SQL:

First, let's get all pets that are owls:


postgres=# 
SELECT * FROM pet WHERE species = 'owl';
 id |  name   | species | owner_id 
----+---------+---------+----------
  3 | Hedwig  | owl     |        3
  5 | unknown  | owl     |        4
  7 | Brodwin | owl     |       10
(3 rows)

Our query returned 3 owls. We can't just send someone's owl on an errand, so we will have to join this with the owners table

Let's write a JOIN:

postgres=# 
SELECT * FROM pet JOIN wizard ON wizard.id = pet.owner_id WHERE pet.species = 'owl';
 id |  name  | species | owner_id | id |     name     |   house    
----+--------+---------+----------+----+--------------+------------
  3 | Hedwig | owl     |        3 |  3 | Harry Potter | Gryffindor
  5 | unknown | owl     |        4 |  4 | Draco Malfoy | Slytherin
(2 rows)

Nice, it looks like we only have 2 rows. There is no wizard with an owner_id of 10 in the wizards table, so it's appropriate that Brodwin the owl is not present in our data.

Let's now just filter down to the columns we need:

postgres=#
SELECT wizard.name, pet.name FROM pet JOIN wizard ON wizard.id = pet.owner_id WHERE pet.species = 'owl';
     name     |  name  
--------------+--------
 Harry Potter | Hedwig
 Draco Malfoy | unknown
(2 rows)

We have the data we need -- let's step through this query.

SELECT wizard.name, pet.name : We want to select just two fields; the name of the pet, and the name of the wizard.
FROM pet : pet is our first table, or the table to the left
JOIN wizard : When we don't specify a type of join, it is assumed we want to run an inner join
ON wizard.id = pet.owner_id : The ON clause
WHERE pet.species = 'owl'; : We filter down to only pets that are owls

The INNER JOIN clause also comes with alternate syntax, which has slightly fewer words to type.
You could run:

SELECT wizard.name, pet.name
FROM pet, wizard
WHERE wizard.id = pet.owner_id
AND pet.species = 'owl'

Notice that the JOIN .. ON statement is absent. Instead, we specify both the tables in the FROM clause, and specify the condition with WHERE. Let's see this in action

postgres=#
SELECT wizard.name, pet.name FROM pet, wizard WHERE wizard.id = pet.owner_id AND pet.species = 'owl';
     name     |  name  
--------------+--------
 Harry Potter | Hedwig
 Draco Malfoy | unknown
(2 rows)

Nice, this returned the same data. We've learnt about the INNER JOIN!

You can find this github here
A cool article about the owls of harry potter can be found here
The schema for the pet and wizard tables can be found in the introduction to the series here. You should be able to follow along without any prior reading!

SQL for the Potterhead: Left Joins

kamya — Tue, 18 Feb 2020 04:06:27 +0000

The Fat Lady's portrait is updating her knowledge to make sure only authorized students have access to the Gryffindor dorm. Can we write a query that will inform us of all the students and pets that are allowed in the Gryffindor dormitory?

Let's break down the requirements. We need:

All the students who are allowed in the Gryffindor dormitory
Any pets that belong to students from Gryffindor

Let's start by using a set diagram to understand what data we need:

It looks like we need all the data in the left hand side table, along with any common data. Thinking about the join's available to us, this sounds a lot like a LEFT JOIN. Let's write some SQL.

1.Start by extracting the data we need from the wizards table. We want to filter the data to the students who are in the Gryffindor house. We can do that with a WHERE clause.


postgres=# `SELECT * FROM wizard WHERE house = 'Gryffindor'` 

id |        name        |   house    
----|--------------------|------------
  1 | Neville Longbottom | Gryffindor
  2 | Ronald Weasley     | Gryffindor
  3 | Harry Potter       | Gryffindor
  5 | Seamus Finnigan    | Gryffindor
  6 | Hermione Granger   | Gryffindor

The query returned every student in the table except Malfoy, who is in Slytherin.

2.Now, let's write a JOIN to combine this data with that of the pet table:


postgres=#
SELECT * FROM wizard LEFT JOIN pet ON wizard.id = pet.owner_id WHERE house = 'Gryffindor'; 
 id |        name        |   house    | id |    name     | species | owner_id 
----+--------------------+------------+----+-------------+---------+----------
  1 | Neville Longbottom | Gryffindor |  2 | Trevor      | toad    |        1
  2 | Ronald Weasley     | Gryffindor |  1 | Scabbers    | rat     |        2
  3 | Harry Potter       | Gryffindor |  3 | Hedwig      | owl     |        3
  6 | Hermione Granger   | Gryffindor |  4 | Crookshanks | cat     |        6
  5 | Seamus Finnigan    | Gryffindor |    |             |         |         
(5 rows)

I see all the student's in Gryffindor, and all the appropriate pets. But, we have too many columns.

3.Let's filter down to only select the data we need.


postgres= #
SELECT wizard.name, pet.name FROM wizard LEFT JOIN pet ON wizard.id = pet.owner_id WHERE house = 'Gryffindor';
        name        |    name     
--------------------+-------------
 Neville Longbottom | Trevor
 Ronald Weasley     | Scabbers
 Harry Potter       | Hedwig
 Hermione Granger   | Crookshanks
 Seamus Finnigan    | 
(5 rows)

This looks good, let's step through this query.

SELECT wizard.name, pet.name: The SELECT clause specifies the fields we want to see in our results. We're only interested in the wizard's name, and the pet's name
FROM wizard : The first table, or the table on the left for our join
LEFT JOIN pet : the LEFT JOIN clause
ON wizard.id = pet.owner_id : We specify what we are joining ON. This is generally a field present in both tables, that has a foreign-key-esque relationship
WHERE house = 'Gryffindor'; : We filter down our results to only include rows where the wizard's house is in Gryffindor. We don't need to specify wizard.house, because the pet table does not include that column.

Our table has very few rows, so we probably won't run into any performance issues. However, I generally like looking at the query planner and look at the execution plan. We can use postgres's EXPLAIN ANALYZE clause for this.

postgres=#
EXPLAIN ANALYZE SELECT wizard.name, pet.name FROM wizard
LEFT JOIN pet ON wizard.id = pet.owner_id WHERE wizard.house = 'Gryffindor';
                                                  QUERY PLAN                                                   
---------------------------------------------------------------------------------------------------------------
 1. Hash Right Join  (cost=14.90..29.05 rows=3 width=236) (actual time=0.045..0.056 rows=5 loops=1)
 2.   Hash Cond: (pet.owner_id = wizard.id)
 3.   ->  Seq Scan on pet  (cost=0.00..13.00 rows=300 width=122) (actual time=0.006..0.008 rows=6 loops=1)
 4.   ->  Hash  (cost=14.88..14.88 rows=2 width=122) (actual time=0.030..0.030 rows=5 loops=1)
 5.         Buckets: 1024  Batches: 1  Memory Usage: 9kB
 6.         ->  Seq Scan on wizard  (cost=0.00..14.88 rows=2 width=122) (actual time=0.020..0.023 rows=5 loops=1)
 7.              Filter: ((house)::text = 'Gryffindor'::text)
 8.              Rows Removed by Filter: 1
 Planning Time: 0.122 ms
 Execution Time: 0.091 ms
(10 rows)

In general, the most indented piece of the EXPLAIN output is executed first. Towards the bottom of the output, we see that we performed a scan on the wizards table, and filtered out all rows whose owners were not in Gryffindor. This means that we won't be scanning and joining unnecessary data.

You might see the Hash Right Join at the start output, and be confused about the discrepency between our SQL syntax, and how the query planner wants to operate.

The answer can be found in Postgres's documentation.

hash join: the right relation is first scanned and loaded into a hash table, using its join attributes as hash keys. Next the left relation is scanned and the appropriate values of every row found are used as hash keys to locate the matching rows in the table.

This doesn't impact the data we will see, just how we will get it. Lines 1-4 specify the type of join Postgres is running (a hash join), and lists how the query planner will access the data. There is timing information in the output, which we will ignore for now.

View this on github
1. Postgres docs for planner optimizer

SQL for the Potterhead: Joins Introduction

kamya — Tue, 18 Feb 2020 03:51:16 +0000

Querying data with SQL can feel magical, and JOINS are one of the things that feel the most magical to me. In the following article, I'm going to explain the magic behind joins.

We will cover:

Left Joins
Inner Joins
Outer Joins

Let's start with some setup and talk about the pets of the wizarding world. Students at Hogwarts are allowed to bring with them an owl OR a cat OR a toad.

Let's consider a table to hold some of the students at Hogwarts. The table will have the following schema:

id : A unique id used to identify a wizarding student
name : The student's full name
house : Their Hogwarts house

Here's the table, populated with some students:

id	name	house
1	Neville Longbottom	Gryffindor
2	Ronald Weasley	Gryffindor
3	Harry Potter	Gryffindor
4	Draco Malfoy	Slytherin
5	Seamus Finnigan	Gryffindor
6	Hermione Granger	Gryffindor

Now, let's create a table to hold information about the student's pets. The table will have the following schema:

id: Unique id used to identify the pet
name : The name of the pet
species: The species of the pet.
owner_id: The id of the owner of the pet. In general, pet.owner_id equals wizard.id. In database-ey terms, we think of this as a foreign key. (We will not be explicitly specifying a foreign key relation here)

Here is a table with some pets.

id	name	species	owner_id
2	Trevor	toad	1
1	Scabbers	rat	2
3	Hedwig	owl	3
4	Crookshanks	cat	6
5	unknown	owl	4
6	Norbert	Dragon	100
7	Brodwin	owl	10

Let's confirm our understanding of this table is correct, by looking at the pet with id = 3. The pet's name is Hedwig, and it's owner_id is 3. Looking at the wizard table, Harry Potter has an id of 3. The data indicates that Harry Potter owns Hedwig, which is what we would expect.

Now that we have table schemas ready, let's learn about joins!

View this on github
Pottermore's guide to wizarding world pets

Scala for the Potterhead: Pattern Matching

kamya — Wed, 22 Jan 2020 04:14:56 +0000

Pattern Matching might seem a bit puzzling. But imagine having to solve a puzzle to prevent Voldemort from getting his hands on the Sorceror's Stone! The Potions Puzzle was one of the challenges that protected the Sorcerers Stone in the very first Harry Potter book. As we all know, this stone could be used to create the elixer of life and grant it's owner immortality.

There are seven potion bottles in the puzzle. Drinking the wrong bottle could kill you -- but one bottle contained a potion that would allow you to progress. Let's write some scala code to represent our potion bottles.


case class Potion(content:String) {}

val bottle1 = Potion("poison")
val bottle2 = Potion("nettle wine")
val bottle3 = Potion("move ahead")
val bottle4 = Potion("poison")
val bottle5 = Potion("poison")
val bottle6 = Potion("nettle wine")
val bottle7 = Potion("go back")

We now have 7 bottles ready to go. Next, we want to write a function that will tell us what will happen if a wizard chooses a bottle.
We could represent this logic with a if-elseif block. Here's a function that does that:


def checkBottle(bottle:Potion): String =
   if (bottle.content == "poison") {
     "you are dead"
   } else if (bottle.content == "move ahead") {
     "go ahead and find the mirror"
   } else if (bottle.content == "nettle wine") {
     "Well I guess you're drunk now"
   } else if (bottle.content == "go back") {
     "go and get Dumbledore -- quick!"
   } else {
     "this bottle has an unknown substance"
   }

If we pass in our bottles to this function, it will accurately tell us the effect the potion had on the wizard.
If the wizard drank the potion in bottle 6, our function will accurately inform the wizard of their intoxicated state.

scala> checkBottle(bottle6)
res4: String = Well I guess you're drunk now

We can simplify this function by using pattern matching. If you are familiar with the switch statement found in many programming languages, the following code block might look familiar.


def checkBottle(bottle:Potion): String =

  bottle.content match {
    case "poison" => "you are dead"
    case "move ahead" => "go ahead and find the mirror"
    case "nettle wine" => "Well I guess you're drunk now"
    case "go back" => "go and get Dumbledore -- quick!"
    case _ => "this bottle has an unknown substance"
  }

The above code block looks at potion.content and tries to find a 'pattern' to 'match' it with.
It specifies four strings explicitly to match on. The last case, case _ is a catch-all. You can think of it as a default block, or a match-anything.

Let's test this function:


scala> checkBottle(bottle6)
res6: String = Well I guess you're drunk now

This seems correct! Now let's see what happens if we tried to pass in a bottle containing Amortentia, the strongest love potion.


scala> val bottle8 = Potion("Amortentia")
bottle8: Potion = Potion(Amortentia)

scala> checkBottle(bottle8)
res7: String = this bottle has an unknown substance

As expected, Amortentia matched on our default case statement.

I hope you learnt a little bit about the basics of Pattern Matching in Scala. We will cover a more complex use case soon!

Here are some links that you might find interesting:

Scala for the Potterhead: Options

kamya — Sun, 13 Oct 2019 23:35:29 +0000

Before we dive into Options, let's talk about the spell Prior Incantato. Prior Incantato is an incantation that reveals the last spell cast by a wand.

Let's represent a wand class that can cast spells.

// Collections available to us in Scala are immutable by default. If we want to store a value that can change, we explicitly declare it's mutability
import scala.collection.mutable
case class Wand() {

  // A mutable collection that stores each spell cast by the wand.
  val spellsCast: mutable.ListBuffer[Spell] = new mutable.ListBuffer[Spell]()

  // A function that allows a wizard to cast a spell
  def castSpell(spell:Spell) = {
    // Store the spell
    spellsCast.addOne(spell)
    println("Cast spell!")
  }
}

If we needed to cast the Prior Incantato spell on a wand, we might think of implementing a function like this:

def PriorIncantato(wand:Wand): Spell = {
  wand.spellsCast.last
}

But wait, what would happen if we called priorIncantato on a wand that has never cast a spell.

val wand = Wand() 
priorIncantato(wand)

We would probably expect something to go wrong if we tried this. Sure enough, we see a a runtime error:

scala> java.util.NoSuchElementException: last of empty ListBuffer
  at scala.collection.mutable.ListBuffer.last(ListBuffer.scala:343)
  at .priorIncantato(<console>:2)
  ... 28 elided

We tried to access the last element of an empty list, and the Scala compiler was unhappy. Now there might be some temptation to just use null to fix this problem.

def priorIncantato(wand:Wand): Spell = {
  if( wand.spellsCast.isEmpty) 
    null 
  else 
    wand.spellsCast.last
}

The code above would work just fine!

 scala> val spell:Spell = priorIncantato(wand)
spell: Spell = null

But now, we have to remember that the val spell could potentially be null. If we tried to use it, we might encounter a frustrating NullPointerException.

 scala> spell.getClass
java.lang.NullPointerException
  ... 28 elided

Scala's Option provides us with an abstraction for dealing with values that have the potential to be non-existent. Let's refactor the priorIncantato function.

// We explicitly state that the function optionally returns a spell
def priorIncantato(wand:Wand): Option[Spell] = {
  // The lastOption function can be called on the ListBuffer. Instead of throwing a `NoSuchElementException`, the function will return None if the list is empty
  wand.spellsCast.lastOption
}

Let's see what happens when we run this!

//call the priorIncantato function on a wand that has not cast any spells
scala> val spell = priorIncantato(wand)
spell: Option[Spell] = None

//try to find the name of the spell
scala> spell.getClass
res8: Class[_ <: Option[Spell]] = class scala.None$

Yay -- we don't have a runtime error anymore! We simply get back a class scala.None, which represents to None class.

Let's cast a spell with our wand, and then call the priorIncantato function:

scala> wand.castSpell(expelliarmus)
Cast spell!

scala> val spell = priorIncantato(wand)
spell: Option[Spell] = Some(Expelliarmus())

scala> spell.getClass
res7: Class[_ <: Option[Spell]] = class scala.Some

This time, the function returns Some(Expelliarmus()). The value stored in spell is an Instance of the Some class in scala.

Option is an abstract class in Scala, with two possible subclasses, Some or None.

This means that the priorIncantaton(wand:Wand): Option[Spell] function will return either Some(Spell) or None.
In general, an Option[A] can either be Some(A) or None.

Options provide us with a handy way of representing missing values. Here are some other links that you might find interesting:

Scala for the Potterhead: For Comprehensions

kamya — Sat, 24 Aug 2019 20:28:01 +0000

We'll cover For comprehensions, generator expressions, guards and yielding in this tutorial. Before we dive in, let's talk about wands.

Everyone knows that good wands are crafted from the finest wood, and imbued with a token from a magical creature. Here is a wand class represented in Scala:

class wand(typeOfWood: String, lengthOfWand: Long, magicalMaterial:String) {
  val wood = typeOfWood
  val length = lengthOfWand
  val magic = magicalMaterial

  override def toString(): String = {
    wood + " wand of length " + length + " inches with " + magic
  }
}

Notice that we override the toString method. Whenever we call the print function on an object, Scala asks the object's toString method how it should be displayed to the console. Let's see that in action:

scala> val wandA = new wand("english wood", 6, "wampus cat hair")
wandA: wand = english wood wand of length 6 inches with wampus cat hair

That looks good! Now let's create a catalog of more wands in Olivander's shop. We will store them in a List.


val wandA = new wand("english wood", 6, "wampus cat hair")
val wandB = new wand("hazel", 9, "veela hair")
val wandC = new wand("Walnut", 11, "troll whisker")
val wandD = new wand("Cypress", 9, "kelpie hair")
val wandE = new wand("ash", 7, "phoenix feather")
val wandF = new wand("birch", 5, "unicorn tail hair")


val wands = List(wandA, wandB, wandC, wandD, wandE, wandF)

Now, we want to find a wand for a particularly tall wizard. We know that he will require a wand that is greater than 7 inches in length. Let's look at some code that does that:

//For comprehension that prints all wands with length > 7 inches
val wandsLongerThan7Inches: List[wand] = for {
//Generator expression
wand <- wands
//Guard
  if wand.length > 7
//Yielding
} yield wand

Let's talk about each of the pieces:

Generator expression (wand <- wands):
This gives us access to individual elements of the wands list. In python we would write this as for wand in wands. The <- operator is called a left arrow operator, and it's Scala's way of iterating through elements in a List
Guard (if wand.length > 7):
A guard is just an if expression that helps us filter elements in the foor loop. In this case, we only want to keep wands that are greater than 7 inches.
Yielding (yield wand):

Yielding is a way to return values from the For comprehension. In this case, every time a wand passes the guard statement, we yield it to the wandsLongerThan7Inches List.
For comprehension:
This entire block is called a For comprehension. It's similar to a for loop in other programming languages, but we call it a comprehension because it can have side effects. In this case, the side effect is populating the wandsLongerThan7Inches List.

Let's see what the wandsLongerThan7Inches List looks like:


scala> wandsLongerThan7Inches
res30: List[wand] = List(hazelwood wand of length 9 inches with veela hair, Walnutwood wand of length 11 inches with troll whisker, Cypresswood wand of length 9 inches with kelpie hair)

Yay! Our new list only contains wands that are greater than 7 inches in length. But we're not done yet! We think that the wizard will do very well with a wand composed with the hair of a magical creature. Let's add that to our Guard condition:

scala> val wandsLongerThan7InchesWithMagicalCreatureHair: List[wand] = for {
  wand <- wands
  if wand.length > 7
  if wand.magic.contains("hair")
} yield wand

We can add multiple if statements in our guard if we choose to do so. In this case, we also have the option of simplifying the code and grouping the conditions:

scala> val wandsLongerThan7InchesWithMagicalCreatureHair: List[wand] = for {
  wand <- wands
  if wand.length > 7 && wand.magic.contains("hair")
} yield wand

This looks good, let's take a look at the result:

scala> wandsLongerThan7InchesWithMagicalCreatureHair
res1: List[wand] = List(hazel wand of length 9 inches with veela hair, Cypress wand of length 9 inches with kelpie hair)

Nice! The wizard only has to 'swish and flick' two wands, and wait for one of them to pick him!

You can find links below to learn more about for comprehensions or magical wands.

Thanks for reading!

All the example code on github
This neat wand-o-graphic from pottermore
Official documentation about for comprehensions
These examples of for loops from the author of the scala cookbook

Scala for the Potterhead: Generics

kamya — Sun, 18 Aug 2019 02:22:54 +0000

Generics

Before diving into Generics, let's talk about something a bit more benign ... like Horcruxes.

A Horcrux is a magical object used to store a piece of a person's soul.
The darkest of all magic is needed to create one, so ofcourse Voldemort created 7 of them.
Not all magical objects are nefarious, like the Remembrall, a small orb which turns red when the owner has forgotten something.

Let's represent some magical objects in Scala:

class MagicalObject {
  val isDangerous: Boolean = false;
}

//When all 3 hallows are owned by one wizard, the owner is said to have mastery over death
class DeathlyHallows extends MagicalObject {
  override val isDangerous: Boolean = true;
}
//The smoke contained inside the remembrall turns red if it's owner has forgotten something
class Remembrall extends MagicalObject
//An object containing a piece of a human soul
class Horcrux extends MagicalObject {
  var isDestroyed = false
  override val isDangerous: Boolean = true;
}

//A magical map of Hogwarts
class MaraudersMap extends MagicalObject

An old wizarding story, The tale of the Three Brothers talks about the Deathly Hallows. There is an Unbeatable Wand, a Stone that can bring the dead back to life, and an invisibility cloak! As the legend goes, if a single wizard comes to possess all three of these things, he or she will have complete mastery over death.

Let's represent this in Scala

class InvisibilityCloak extends DeathlyHallows
class ResurrectionStone extends DeathlyHallows
class ElderWand extends DeathlyHallows {
  var owner = "Antioch Peverell"
}

You will never hear a Hogwarts professor mention Horcruxes, and any references to them have been banned from the library. Voldemort turned several items of significance into hosts for his soul.

//Diadem (tiara) of one of the founders of Hogwarts: Rowena Ravenclaw
class RavenclawDiadem extends Horcrux

//The high school diary of Tom Riddle aka Lord Voldemort
class RiddleDiary extends Horcrux

//The ring of Voldemort's maternal grandfather
class MarvoloGauntRing extends Horcrux

Let's create a list of magical objects that have been owned by the famous Harry Potter. Below is some scala code that does just that:

val magicalObjectsOwnedByHarry: List[MagicalObject] = List(elderWand, maraudersMap, riddleDiary, invisibilityCloak)

Let's zoom in on the type of the variable magicalObjectsOwnedByHarry. It is a List that accepts elements of the type MagicalObject. Scala implements the List type as a Generic class, which allows us to do this.

Let's confirm that the scala compiler is happy with our code:

scala> val magicalObjectsOwnedByHarry: List[MagicalObject] = List(elderWand, maraudersMap, riddleDiary, invisibilityCloak)

magicalObjectsOwnedByHarry: List[MagicalObject] = List(ElderWand@66032b8d, MaraudersMap@1fb66050, RiddleDiary@28068327, InvisibilityCloak@65c2610f)

Generics is sometimes known as Parametric Polymorphism. It helps us write code that is more expressive and promotes code reusability without compromising type safety.
When we use Generics, the scala compiler will be able to detect any unexpected type errors at compile time.

In our example, if we try to insert a nonmagical item, the scala compiler will immediately alert us that there is an error with our code.

scala> val magicalObjectsOwnedByHarry: List[MagicalObject] = List(elderWand, maraudersMap, riddleDiary, invisibilityCloak, "Non-magical kettle")
                                                                                                                           ^
       error: type mismatch;
        found   : String("Non-magical kettle")
        required: MagicalObject

You might be tempted to solve for the compile error by removing the type altogether. While this might make our code compile, it might fail later anyway with an error that is harder to debug.

Consider the following snippet where we try and find all the dangerous objects owned by Harry.

scala> scala> val magicalObjectsOwnedByHarryWithoutGenericType = List(elderWand, maraudersMap, riddleDiary, invisibilityCloak, "Non-magical kettle")
magicalObjectsOwnedByHarryWithoutGenericType: List[Object] = List(ElderWand@772357e9, MaraudersMap@22ccd80f, RiddleDiary@45b7b254, InvisibilityCloak@3b47178c, Non-magical kettle)

scala> val dangerousObjects = magicalObjectsOwnedByHarryWithoutStrongTypes.filter(magicObject => magicObject.isDangerous)
                                                                                                             ^
       error: value isDangerous is not a member of Object

scala

Our code fails with an error that is a lot harder to understand, as opposed to the neat type error we saw earlier.

You can check the full code sample here
You can read more about generic classes in the official scaladoc
This fantastic wikipedia entry is a fun read about magical objects