Use module instead of remainder where needed.

Author: objecthub

Sources/LispKit/Base/Global.swift

@@ -18,6 +18,13 @@
 //  limitations under the License.
 //
 
+infix operator %%: MultiplicationPrecedence
+
+func %%<T: BinaryInteger>(lhs: T, rhs: T) -> T {
+  let rem = lhs % rhs
+  return rem >= 0 ? rem : rem + rhs
+}
+
 internal func log(_ str: String) {
   #if LOG
     print(str)

Sources/LispKit/Data/HashTable.swift

@@ -116,7 +116,7 @@ public final class HashTable: ManagedObject, CustomStringConvertible {
     for bucket in oldBuckets {
       var current = bucket
       while case .pair(.pair(let key, let value), let next) = current {
-        let bid = self.hash(key) % capacity
+        let bid = self.hash(key) %% capacity
         self.buckets[bid] = .pair(.pair(key, value), self.buckets[bid])
         current = next
       }
@@ -311,22 +311,22 @@ public final class HashTable: ManagedObject, CustomStringConvertible {
   }
 
   public func get(_ key: Expr) -> Expr? {
-    return self.get(self.hash(key) % self.buckets.count, key, self.eql)
+    return self.get(self.hash(key) %% self.buckets.count, key, self.eql)
   }
 
   @discardableResult public func set(key: Expr, mapsTo value: Expr) -> Bool {
     return self.remove(key: key) != nil && self.add(key: key, mapsTo: value)
   }
 
   @discardableResult public func add(key: Expr, mapsTo value: Expr) -> Bool {
-    return self.add(self.hash(key) % self.buckets.count, key, value)
+    return self.add(self.hash(key) %% self.buckets.count, key, value)
   }
 
   public func remove(key: Expr) -> Expr? {
     guard self.mutable else {
       return nil
     }
-    return self.remove(self.hash(key) % self.buckets.count, key: key)
+    return self.remove(self.hash(key) %% self.buckets.count, key: key)
   }
 
   private func remove(_ bid: Int, key: Expr) -> Expr? {
@@ -355,7 +355,7 @@ public final class HashTable: ManagedObject, CustomStringConvertible {
     for bucket in map.buckets {
       var current = bucket
       while case .pair(.pair(let key, let value), let next) = current {
-        let bid = self.hash(key) % self.buckets.count
+        let bid = self.hash(key) %% self.buckets.count
         if self.get(bid, key, self.eql) == nil {
           self.add(bid, key, value)
         }

Sources/LispKit/Primitives/HashTableLibrary.swift

@@ -508,7 +508,7 @@ public final class HashTableLibrary: NativeLibrary {
   private func hBuckets(_ expr: Expr, hval: Expr?) throws -> Expr {
     let map = try expr.asHashTable()
     if let hashValue = try hval?.asInt64() {
-      return map.bucketList(Int(hashValue % Int64(map.bucketCount)))
+      return map.bucketList(Int(hashValue %% Int64(map.bucketCount)))
     } else {
       return map.bucketList()
     }
@@ -521,15 +521,15 @@ public final class HashTableLibrary: NativeLibrary {
     if !key.isAtom || !value.isAtom {
       self.context.objects.manage(map)
     }
-    map.add(Int(try hval.asInt64() % Int64(map.bucketCount)), key, value)
+    map.add(Int(try hval.asInt64() %% Int64(map.bucketCount)), key, value)
     return .void
   }
 
   private func hBucketRepl(_ expr: Expr, hval: Expr, bucket: Expr) throws -> Expr {
     guard case .table(let map) = expr else {
       throw RuntimeError.type(expr, expected: [.tableType])
     }
-    map.replace(Int(try hval.asInt64() % Int64(map.bucketCount)), bucket)
+    map.replace(Int(try hval.asInt64() %% Int64(map.bucketCount)), bucket)
     return .void
   }
 }

Sources/LispKit/Primitives/MathLibrary.swift

@@ -1595,9 +1595,7 @@ public final class MathLibrary: NativeLibrary {
   }
 
   private func fxModulo(_ x: Expr, _ y: Expr) throws -> Expr {
-    let rhs = try y.asInt64()
-    let res = try x.asInt64() % rhs
-    return .fixnum((res < 0) == (rhs < 0) ? res : res + rhs)
+    return .fixnum(try x.asInt64() %% y.asInt64())
   }
 
   private func fxAbs(_ x: Expr) throws -> Expr {