apr 1 files

Author: tnelson

S25/vignettes/apr1/.gitignore

@@ -0,0 +1 @@
+node_modules

S25/vignettes/apr1/package-lock.json

@@ -0,0 +1,16 @@
+{
+  "name": "apr1",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  }
+}

S25/vignettes/apr1/package.json

@@ -0,0 +1,67 @@
+export {}
+
+/* Here is one thing we could do. In Java, we could just create a 
+   new class for each, probably a record with only one argument. 
+   Then its nominal type system would see the error. In TypeScript, 
+   we need to force its structural type system to see the two kinds 
+   of IDs as different somehow. 
+   
+   Enter: "branding".
+   */
+
+type StudentId = (string & {readonly _StudentId: unique symbol})
+interface Student { 
+  id: StudentId,
+  studentName: string,
+  concentration: string
+}
+
+type CourseId = (string & {readonly _CourseId: unique symbol})
+interface Course { 
+  id: CourseId, 
+  name: string,
+  enrollment: Set<Student>
+}   
+
+/** The registrar maps student IDs to the number of credits taken. */
+type RegistrarCredits = {[id: StudentId]: number}
+let registrar: RegistrarCredits = {}
+/** ...and is told to give credit by invoking this function (which 
+    in reality would return a promise...) */
+function registrarGiveCredit(studentId: StudentId) {
+  registrar[studentId] = registrar[studentId] + 1
+}
+
+/** The course is over, and, to keep the example simple all students 
+ *  enrolled passed. Great! Let's give them credit. */
+function courseFinished(c: Course) {
+  c.enrollment.forEach((s: Student) => {
+    console.log(`Congratulations ${s}.`)
+    registrarGiveCredit(c.id)  // ERROR! Huzzah
+  })}
+
+
+  
+/////////////////////////////////////////////////////////////////////
+
+
+
+// Whenever we do some type gymnastics, we want to make sure we have 
+// not made the new type impossible to instantiate!  
+const nimTelson: Student = {
+    id: '123',
+    studentName: "Nim Telson",
+    concentration: "undeclared"
+}
+// Uh oh. This shouldn't be surprising: there's no brand in '123'. 
+// But we also don't want to spend actual memory storing the field...
+function makeStudentId(id: string): StudentId {
+    // Yes! A typecast! But invoking this function "blesses" the use
+    // of this string as a StudentId
+    return id as StudentId
+}
+const nimTelson2: Student = {
+    id: makeStudentId('123'),   // not a "constructor" really. 
+    studentName: "Nim Telson",
+    concentration: "undeclared"
+}

S25/vignettes/apr1/src/branding.ts

@@ -0,0 +1,37 @@
+/*
+    Both Java and TypeScript (like most languages, today) are 
+    "call by value". This means that before a function or method 
+    can be called, its arguments need to be evaluated. 
+
+    There are a few ways this can manifest.
+*/
+
+function printTwice(value: number) {
+    console.log(value)
+    console.log(value)
+}
+function halfOf(value: number): number { 
+    console.log(`halfOf called on ${value}`)
+    return value / 2
+}
+printTwice(halfOf(100)) // 150
+/* We only see "halfOf called on 50" _once_, because the value 
+   of halfOf(100) must be computed before printTwice can be called. */
+console.log('----------------------------------')
+
+///////////////////////////////////////////////////////////
+
+/* Maybe that seems obviously right. In this case I think it is, too. 
+   Here's a situation where you might need to do some work, though. */
+
+/**
+* Call this function to increment a numeric value. 
+* @param value The numeric variable to increment
+*/
+function incrementValue(value: number) {
+    value++
+}
+let x = 0
+incrementValue(x)
+console.log(x)
+/* What prints? */