Encounters concept exercise

config.json

@@ -292,6 +292,18 @@
         ],
         "status": "beta"
       },
+      {
+        "slug": "encounters",
+        "name": "Encounters",
+        "uuid": "68001762-8a35-4494-9de4-624ca9efb5cd",
+        "concepts": [
+          "multiple-dispatch"
+        ],
+        "prerequisites": [
+          "parametric-types"
+        ],
+        "status": "beta"
+      },
       {
         "slug": "old-elyses-enchantments",
         "name": "Old Elyse's Enchantments",
@@ -364,14 +376,6 @@
         "prerequisites": [],
         "status": "deprecated"
       },
-      {
-        "slug": "old-encounters",
-        "name": "Old Encounters",
-        "uuid": "68001762-8a35-4494-9de4-624ca9efb5cd",
-        "concepts": [],
-        "prerequisites": [],
-        "status": "deprecated"
-      },
       {
         "slug": "old-emoji-times",
         "name": "Old 🕑🕤🕗",

exercises/concept/encounters/.docs/design.md

@@ -0,0 +1,32 @@
+# Design
+
+## Goal
+
+The goal of this exercise is to introduce the student to multiple dispatch, Julia's central paradigm.
+
+## Learning objectives
+
+- Understand how to create multiple methods for a function.
+- Understand something of how Julia chooses the "best" method to dispatch.
+- Understand something of why multiple dispatch is so important in making Julia performant.
+
+## Out of scope
+
+These features are not currently covered, though this could be up for discussion in future.
+
+- Method ambiguity
+- Parametric methods
+
+## Concepts
+
+The Concepts this exercise unlocks are:
+
+- None.
+
+## Prerequisites
+
+- `parametric-types`
+
+## Source
+
+This exercise is based on an example used in the talk "The Unreasonable Effectiveness of Multiple Dispatch" given by Stefan Karpinski at JuliaCon 2019, available on [YouTube](https://youtu.be/kc9HwsxE1OY?t=422).

exercises/concept/encounters/.docs/hints.md

@@ -0,0 +1,38 @@
+# Hints
+
+## 1. Define custom types
+
+Abstract types and type inheritance were discussed in the [Composite Types][composite] Concept.
+
+## 2. Get the name of the pet.
+
+- This is trivial for Dogs and Cats, but helpful to the tests for fallback methods.
+
+## 3. Define what happens when cats and dogs meet
+
+- How many combinations for cat/dog encounters are there?
+- Remember that a cat meeting a dog reacts differently to a dog meeting a cat.
+- We need the response of the first argument: `a` in `meet(a, b)`.
+
+## 4. Define an encounter between two entities.
+
+- The return value is a longer string than for `meet()`.
+- Only use a single method for `encounter()`.
+- [String interpolation][interpolation] is your friend when assembling a return value.
+
+## 5. Define a fallback reaction for encounters between pets
+
+- The second argument is now a `Pet` other than `Cat` or `Dog`, so add a `meet` method.
+- Declaring abstract parameter types or constraining them via parametric methods are two ways to accomplish this.
+
+## 6. Define a fallback if a pet encounters something it doesn't know
+
+- The second argument can now be anything.
+
+## 7. Define a generic fallback
+
+- Both arguments can now be anything.
+- At the end of the exercise, you will have 7 methods for `meet`.
+
+[composite]: https://exercism.org/tracks/julia/concepts/composite-types
+[interpolation]: https://docs.julialang.org/en/v1/manual/strings/#string-interpolation

exercises/concept/encounters/.docs/instructions.md

@@ -0,0 +1,110 @@
+# Instructions
+
+In this exercise you will be implementing a simulation of encounters.
+This will familiarise you with the basics of multiple dispatch, Julia's main paradigm.
+
+~~~~exercism-important
+For this exercise, all function definitions should be a single-line declaration with no if/else logic.
+~~~~
+
+In general, encounters involve one entity `a` meeting another entity `b` and reacting to it.
+
+```julia
+encounter(a, b) = "$(name(a)) meets $(name(b)) and $(meets(a, b))."
+```
+
+At first, we will simulate what happens when cats and dogs meet.
+
+## 1. Define custom types
+
+First add an abstract type `Pet`.
+
+Then define types `Cat` and `Dog` as subtypes of `Pet`.
+Each has a single field `name`.
+
+## 2. Get the name of the pet.
+
+Implement a function `name()` which returns the name of a pet.
+
+```julia-repl
+julia> fido = Dog("Fido")
+Dog("Fido")
+
+julia> name(fido)
+"Fido"
+```
+
+## 3. Define what happens when cats and dogs meet
+
+Implement `meets()` methods for the following encounters:
+
+- When two dogs meet, they **sniff** each other.
+- When a cat meets a dog, it **hisses** at the dog.
+- When a dog meets a cat, it **chases** the cat.
+- When two cats meet, they **slink**.
+
+```julia-repl
+julia> ginger = Cat("Ginger")
+Cat("Ginger")
+
+julia> meets(ginger, fido)
+"hisses"
+```
+
+## 4. Define an encounter between two entities.
+
+Implement the `encounter()` function with one method, to report what happens when two named entities meet.
+
+```julia-repl
+julia> encounter(ginger, fido)
+"Ginger meets Fido and hisses."
+```
+
+## 5. Define a fallback reaction for encounters between pets
+
+What happens if they encounter a different pet on their walk, like a [horse](https://www.dw.com/en/horse-takes-daily-stroll-through-frankfurt-without-owner/a-47833431)?
+
+- If a pet meets another pet that it doesn't recognize, it **is cautious**.
+
+```julia-repl
+julia> bella = Horse("Bella")
+Horse("Bella")
+
+julia> encounter(fido, bella)
+"Fido meets Bella and is cautious."
+```
+
+## 6. Define a fallback if a pet encounters something it doesn't know
+
+There are many other things that pets may encounter that aren't pets: cars, humans, plants, natural disasters, asteroids… What happens then?
+
+- If a pet meets something it has never seen before, it **runs away**.
+
+```julia-repl
+julia> colnago = Bicycle("Colnago")
+Bicycle("Colnago")
+
+julia> encounter(ginger, colnago)
+"Ginger meets Colnago and runs away."
+```
+
+## 7. Define a generic fallback
+
+There are many other encounters that could occur in our simulation.
+A car meets a dog, two electrons encounter each other and interact…
+
+It is impossible to cover all encounters in advance, therefore we will implement a generic fallback.
+
+- If two unknown things or beings encounter each other, **nothing happens**.
+
+```julia-repl
+julia> γ1 = Photon("γ1")
+Photon("γ1")
+
+julia> γ2 = Photon("γ2")
+Photon("γ2")
+
+julia> encounter(γ1, γ2)
+"γ1 meets γ2 and nothing happens." 
+# This is true, photons just pass through each other.
+```