again verbose

report.go

@@ -58,17 +58,33 @@ func ReportSince(ctx context.Context, w io.Writer, s Storage, t time.Time) error
 		return err
 	}
 
-	events, err := s.EventsSince(ctx, t)
+	eventIDs, err := s.EventsSince(ctx, t)
 	if err != nil {
 		return err
 	}
 
+	type aThread struct {
+		Thread   string
+		Messages []Message
+		First    Message
+		Last     Message
+	}
+	type anEvent struct {
+		Event   string
+		Threads []aThread
+		First   Message
+		Last    Message
+	}
+	type someEvents struct {
+		Events []anEvent
+	}
+
 	return tmpl.Execute(w, map[string]any{
 		"since": t.Format("2006-01-02"),
-		"events": func() any {
+		"events": func() someEvents {
-			threads := make([]any, len(events))
+			events := make([]anEvent, len(eventIDs))
-			for i, event := range events {
+			for i, event := range eventIDs {
-				threads[i] = func() any {
+				events[i] = func() anEvent {
 					threadNames := []string{}
 					for _, m := range messages {
 						if m.Event == event {
@@ -77,9 +93,9 @@ func ReportSince(ctx context.Context, w io.Writer, s Storage, t time.Time) error
 					}
 					slices.Sort(threadNames)
 					slices.Compact(threadNames)
-					threads := make([]any, len(threadNames))
+					threads := make([]aThread, len(threadNames))
 					for i, thread := range threadNames {
-						threads[i] = func() any {
+						threads[i] = func() aThread {
 							messages := []Message{}
 							for _, m := range messages {
 								if m.Thread == thread {
@@ -89,16 +105,16 @@ func ReportSince(ctx context.Context, w io.Writer, s Storage, t time.Time) error
 							sort.Slice(messages, func(i, j int) bool {
 								return messages[i].TS < messages[j].TS
 							})
-							return map[string]any{
+							return aThread{
-								"thread":   thread,
+								Thread:   thread,
-								"messages": messages,
+								Messages: messages,
-								"first": func() any {
+								First: func() Message {
 									if len(messages) == 0 {
 										return Message{}
 									}
 									return messages[0]
 								}(),
-								"last": func() any {
+								Last: func() Message {
 									if len(messages) == 0 {
 										return Message{}
 									}
@@ -108,28 +124,28 @@ func ReportSince(ctx context.Context, w io.Writer, s Storage, t time.Time) error
 						}()
 					}
 					sort.Slice(threads, func(i, j int) bool {
-						return threads[i].(map[string]any)["first"].(Message).TS < threads[j].(map[string]any)["first"].(Message).TS
+						return threads[i].First.TS < threads[j].First.TS
 					})
-					return map[string]any{
+					return anEvent{
-						"event":   event,
+						Event:   event,
-						"threads": threads,
+						Threads: threads,
-						"first": func() any {
+						First: func() Message {
 							if len(threads) == 0 {
 								return Message{}
 							}
-							return threads[0].(map[string]any)["first"]
+							return threads[0].First
 						}(),
-						"last": func() any {
+						Last: func() Message {
 							if len(threads) == 0 {
 								return Message{}
 							}
-							return threads[len(threads)-1].(map[string]any)["last"]
+							return threads[len(threads)-1].Last
 						}(),
 					}
 				}()
 			}
-			return map[string]any{
+			return someEvents{
-				"threads": threads,
+				Events: events,
 			}
 		}(),
 		"messages":   messages,

report.tmpl

@@ -60,15 +60,8 @@
                 <th>Source</th>
               </tr>
               {{ range .events }}
-                {{ $first_ts := 0 }}
-                {{ $event := "" }}
-                {{ $event_name := "" }}
-                {{ $last_plaintext := "" }}
-                {{ $source := "" }}
-                {{ range . }}
-                {{ end }}
                 <tr>
-                  <td>{{ time "Unix" $first_ts | time "Time.Format" "Mon Jan 02" }}</td>
+                  <td>{{ time "Unix" .threads.first.TS | time "Time.Format" "Mon Jan 02" }}</td>
                 </tr>
               {{ end }}
             </table>