···

       
33
       
 
       
fn do_find_happiest_table(

     

       
34
       
 
       
  happiness_dict,

     

       
35
       
 
       
  people,

     

       
36
       
-
       
  happiest_table,

     

       
37
       
 
       
  first_person first_person,

     

       
38
       
 
       
  last_person last_person,

     

       
39
       
 
       
  table table,

     
···

       
43
       
 
       
      let assert Ok(relation) =

     

       
44
       
 
       
        happiness_dict |> dict.get(Relation(last_person, first_person))

     

       
45
       
 
       
        as "There should be more than one person"

     

       
46
       
-
       
      let table = table + relation

     

       
47
       
-
       
      case table > happiest_table {

     

       
48
       
-
       
        True -> table

     

       
49
       
-
       
        False -> happiest_table

     

       
50
       
-
       
      }

     

       
51
       
 
       
    }

     

       
52
       
 
       
    False -> {

     

       
53
       
 
       
      people

     
···

       
64
       
 
       
          do_find_happiest_table(

     

       
65
       
 
       
            happiness_dict,

     

       
66
       
 
       
            people |> set.delete(person),

     

       
67
       
-
       
            happiest_table,

     

       
68
       
 
       
            first_person,

     

       
69
       
 
       
            last_person: person,

     

       
70
       
 
       
            table: table + relation,

     
···

       
84
       
 
       
  do_find_happiest_table(

     

       
85
       
 
       
    happiness_dict,

     

       
86
       
 
       
    people |> set.delete(person),

     

       
87
       
-
       
    0,

     

       
88
       
 
       
    first_person: person,

     

       
89
       
 
       
    last_person: person,

     

       
90
       
 
       
    table: 0,

     

···

       
33
       
 
       
fn do_find_happiest_table(

     

       
34
       
 
       
  happiness_dict,

     

       
35
       
 
       
  people,

     

       
0
       
 
       

     

       
36
       
 
       
  first_person first_person,

     

       
37
       
 
       
  last_person last_person,

     

       
38
       
 
       
  table table,

     
···

       
42
       
 
       
      let assert Ok(relation) =

     

       
43
       
 
       
        happiness_dict |> dict.get(Relation(last_person, first_person))

     

       
44
       
 
       
        as "There should be more than one person"

     

       
45
       
+
       
      table + relation

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
46
       
 
       
    }

     

       
47
       
 
       
    False -> {

     

       
48
       
 
       
      people

     
···

       
59
       
 
       
          do_find_happiest_table(

     

       
60
       
 
       
            happiness_dict,

     

       
61
       
 
       
            people |> set.delete(person),

     

       
0
       
 
       

     

       
62
       
 
       
            first_person,

     

       
63
       
 
       
            last_person: person,

     

       
64
       
 
       
            table: table + relation,

     
···

       
78
       
 
       
  do_find_happiest_table(

     

       
79
       
 
       
    happiness_dict,

     

       
80
       
 
       
    people |> set.delete(person),

     

       
0
       
 
       

     

       
81
       
 
       
    first_person: person,

     

       
82
       
 
       
    last_person: person,

     

       
83
       
 
       
    table: 0,