Complete slots terminology renaming and add operator support

- Rename remaining ivarArray references to slots in Object.hrd and types.nim
- Fix classDeriveParentsSlotsMethodsImpl to return the created class
- Add codegen support for == and ~= comparison operators
- Add integer division (//), backslash (\), and modulo (%) operators
- Add percent symbol mangling for selector names

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: gokr

lib/core/Object.hrd

@@ -29,14 +29,14 @@ Object>>clone <primitive primitiveClone>
 # Class-side methods (using class>> syntax)
 #====================================================================
 
-Object class>>derive: ivarArray methods: methodBlock [
-  # Create a subclass with instance variables AND define methods in one expression.
+Object class>>derive: slotsArray methods: methodBlock [
+  # Create a subclass with extra slots AND define methods in one expression.
   # Usage: Person := Object derive: #(name age) methods: [
   #   self >> greet [ "Hello, I am " + name ]
   #   self >> haveBirthday [ age := age + 1 ]
   # ]
   | newClass |
-  newClass := self derive: ivarArray.
+  newClass := self derive: slotsArray.
   newClass extend: methodBlock.
   ^ newClass
 ]

src/harding/codegen/module.nim

@@ -204,9 +204,18 @@ proc genModule*(ctx: var CompilerContext, nodes: seq[Node],
   output.add("# Comparison Operators\n")
   output.add("#####################\n\n")
 
-  for op in ["<", "<=", ">", ">=", "="]:
+  for op in ["<", "<=", ">", ">=", "=", "==", "~="]:
     output.add(genComparisonMethod(op))
 
+  # Generate integer division and modulo operators
+  output.add("\n")
+  output.add("# Integer Division and Modulo\n")
+  output.add("#############################\n\n")
+
+  output.add(genBinaryOpMethod("//"))
+  output.add(genBinaryOpMethod("\\"))
+  output.add(genBinaryOpMethod("%"))
+
   # Generate main proc for top-level statements
   output.add(genMainProc(ctx, topLevel, moduleName))
 

src/harding/compiler/symbols.nim

@@ -46,12 +46,14 @@ proc mangleSelector*(selector: string): string =
   result = result.replace("+", "plus")
   result = result.replace("*", "star")
   result = result.replace("/", "slash")
+  result = result.replace("\\", "backslash")
   result = result.replace("<", "lt")
   result = result.replace(">", "gt")
   result = result.replace("=", "eq")
   result = result.replace("~", "tilde")
   result = result.replace("@", "at")
   result = result.replace("|", "pipe")
+  result = result.replace("%", "percent")
   # Add nt_ prefix
   result = "nt_" & result
 

src/harding/core/types.nim

@@ -751,13 +751,13 @@ proc newClass*(superclasses: seq[Class] = @[], slotNames: seq[string] = @[], nam
 
   # Check for method selector conflicts between superclasses (only for directly-defined methods)
   # Inherited methods should not cause conflicts
-  # Note: use derive:superclasses:ivarArray:methods: to specify method overrides
+  # Note: use derive:parents:slots:methods: to specify method overrides
   var seenInstanceMethods: seq[string] = @[]
   var seenClassMethods: seq[string] = @[]
   for parent in superclasses:
     for selector in parent.methods.keys:  # Only check directly-defined instance methods
       if selector in seenInstanceMethods:
-        raise newException(ValueError, "Method selector conflict: '" & selector & "' exists in multiple superclasses (use derive:superclasses:ivarArray:methods: to specify method overrides)")
+        raise newException(ValueError, "Method selector conflict: '" & selector & "' exists in multiple superclasses (use derive:parents:slots:methods: to specify method overrides)")
       seenInstanceMethods.add(selector)
     for selector in parent.classMethods.keys:  # Only check directly-defined class methods
       if selector in seenClassMethods:

src/harding/interpreter/objects.nim

@@ -1051,63 +1051,74 @@ proc classDeriveParentsSlotsMethodsImpl*(self: Class, args: seq[NodeValue]): Nod
                     self.name & "+Derived"
                   else:
                     "Anonymous"
-  let newClass = newClass(superclasses =actualParents, slotNames = slotNames, name = className)
+  let theClass = newClass(superclasses =actualParents, slotNames = slotNames, name = className)
 
   # Execute method block if provided (to define/override methods and resolve conflicts)
   # For now, skip block execution - it requires an interpreter context
   # This could be enhanced later to support true method definition in the block
   discard
 
+  return NodeValue(kind: vkClass, classVal: theClass)
+
 proc classDeriveParentsSlotsGettersSettersMethodsImpl*(self: Class, args: seq[NodeValue]): NodeValue =
   ## Create a new class with multiple parents, slots, selective getters/setters, and methods
-  ## args[0]: parents array
-  ## args[1]: slot names array (all slots)
-  ## args[2]: getters array (slots to generate getters for)
-  ## args[3]: setters array (slots to generate setters for)
-  ## args[4]: methods dictionary (optional)
-  if args.len < 4:
+  ## args[0]: slot names array (all slots)
+  ## args[1]: parents array
+  ## args[2]: slots array (extra slots)
+  ## args[3]: getters array (slots to generate getters for)
+  ## args[4]: setters array (slots to generate setters for)
+  ## args[5]: methods dictionary (optional)
+  if args.len < 5:
     return nilValue()
 
-  # Extract parents array
-  var parents: seq[Class] = @[]
+  # Extract slot names (from derive: parameter)
+  var slotNames: seq[string] = @[]
   if args[0].kind == vkInstance and args[0].instVal.kind == ikArray:
     for elem in args[0].instVal.elements:
+      if elem.kind == vkString or elem.kind == vkSymbol:
+        let name = if elem.kind == vkString: elem.strVal else: elem.symVal
+        if name.len > 0:
+          slotNames.add(name)
+
+  # Extract parents array
+  var parents: seq[Class] = @[]
+  if args[1].kind == vkInstance and args[1].instVal.kind == ikArray:
+    for elem in args[1].instVal.elements:
       if elem.kind == vkClass:
         parents.add(elem.classVal)
 
   # If no parents provided, use self as the parent
   if parents.len == 0:
     parents.add(self)
 
-  # Extract all slot names
-  var slotNames: seq[string] = @[]
-  if args[1].kind == vkInstance and args[1].instVal.kind == ikArray:
-    for elem in args[1].instVal.elements:
+  # Extract additional slot names (from slots: parameter)
+  if args[2].kind == vkInstance and args[2].instVal.kind == ikArray:
+    for elem in args[2].instVal.elements:
       if elem.kind == vkString or elem.kind == vkSymbol:
         let name = if elem.kind == vkString: elem.strVal else: elem.symVal
-        if name.len > 0:
+        if name.len > 0 and name notin slotNames:
           slotNames.add(name)
 
   # Extract getter slot names
   var getterSlotNames: seq[string] = @[]
-  if args[2].kind == vkInstance and args[2].instVal.kind == ikArray:
-    for elem in args[2].instVal.elements:
+  if args[3].kind == vkInstance and args[3].instVal.kind == ikArray:
+    for elem in args[3].instVal.elements:
       if elem.kind == vkString or elem.kind == vkSymbol:
         let name = if elem.kind == vkString: elem.strVal else: elem.symVal
         if name.len > 0:
           getterSlotNames.add(name)
 
   # Extract setter slot names
   var setterSlotNames: seq[string] = @[]
-  if args[3].kind == vkInstance and args[3].instVal.kind == ikArray:
-    for elem in args[3].instVal.elements:
+  if args[4].kind == vkInstance and args[4].instVal.kind == ikArray:
+    for elem in args[4].instVal.elements:
       if elem.kind == vkString or elem.kind == vkSymbol:
         let name = if elem.kind == vkString: elem.strVal else: elem.symVal
         if name.len > 0:
           setterSlotNames.add(name)
 
   # Create the new class
-  let actualParents = if args[0].kind == vkNil: @[self] else: parents
+  let actualParents = if args[1].kind == vkNil: @[self] else: parents
   let className = if parents.len > 0 and parents[0].name.len > 0:
                     parents[0].name & "+Derived"
                   elif self.name.len > 0:
@@ -1130,8 +1141,8 @@ proc classDeriveParentsSlotsGettersSettersMethodsImpl*(self: Class, args: seq[No
       addMethodToClass(newClass, setterName, setter, isClassMethod = false)
 
   # Extract and add methods from dictionary if provided
-  if args.len >= 5 and args[4].kind == vkInstance and args[4].instVal.kind == ikTable:
-    let methodTable = args[4].instVal
+  if args.len >= 6 and args[5].kind == vkInstance and args[5].instVal.kind == ikTable:
+    let methodTable = args[5].instVal
     for key, value in methodTable.entries.pairs:
       if key.kind == vkSymbol and value.kind == vkBlock:
         let selector = key.symVal