--- a/progs/lecture4.scala	Fri Dec 05 10:20:00 2025 +0000
+++ b/progs/lecture4.scala	Thu Dec 11 13:23:30 2025 +0000
@@ -37,7 +37,7 @@
 length(List(1, 2, 3, 4))
 
 
-length[String](List(1, 2, 3, 4))
+length[Int](List(1, 2, 3, 4))
 
 
 def map[A, B](lst: List[A], f: A => B): List[B] = lst match {
@@ -247,9 +247,13 @@
 // Tail recursion
 //================
 
+@tailrec
 def fact(n: BigInt): BigInt = 
   if (n == 0) 1 else n * fact(n - 1)
 
+fact(3) -> fact(2)
+
+
 
 fact(10)          
 fact(1000)        
@@ -260,7 +264,7 @@
   if (n == 0) acc else factT(n - 1, n * acc)
 
 
-factT(1000,1)
+factT(10,1)
 println(factT(100000, 1))
 
 
@@ -303,14 +307,17 @@
   case _ :: tail => 1 + length(tail)
 }
 
-length(List.fill(100000)(1))
+val long_lst = List.fill(100000)(1)
+
+length(long_lst)
+long_lst.length
 
 def lengthT[A](xs: List[A], acc : Int = 0) : Int = xs match {
   case Nil => acc
   case _ :: tail => lengthT(tail, 1 + acc)
 }
 
-lengthT(List.fill(100000)(1))
+      
 
 
 
@@ -628,15 +635,15 @@
 // Regular expressions - the power of DSLs in Scala
 //==================================================
 
-abstract class Rexp
-case object ZERO extends Rexp                     // nothing
-case object ONE extends Rexp                      // the empty string
-case class CHAR(c: Char) extends Rexp             // a character c
-case class ALT(r1: Rexp, r2: Rexp) extends Rexp   // alternative  r1 + r2
-case class SEQ(r1: Rexp, r2: Rexp) extends Rexp   // sequence     r1 . r2  
-case class STAR(r: Rexp) extends Rexp             // star         r*
-
-
+enum Rexp {
+  case ZERO                      // nothing
+  case ONE                       // the empty string
+  case CHAR(c: Char)             // a character c
+  case ALT(r1: Rexp, r2: Rexp)   // alternative  r1 + r2
+  case SEQ(r1: Rexp, r2: Rexp)   // sequence     r1 . r2  
+  case STAR(r: Rexp)             // star         r*
+}
+import Rexp._
 
 // writing (ab)* in the format above is 
 // tedious
@@ -676,7 +683,15 @@
 val number = sign ~ digit ~ digit.% 
 
 
+extension (n: Int) {
+  def ++ = n + 1
+}
 
+def --(n: Int) = n - 1
+
+val n = 3
+val m = (n.++)  
+val k = --(n)  
 
 // In mandelbrot.scala I used complex (imaginary) numbers 
 // and implemented the usual arithmetic operations for complex