refactor: introduce Source trait for random generator

Author: peter-jerry-ye

builtin/builtin.mbti

@@ -780,9 +780,8 @@ impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8
 
 pub(open) trait Hash {
   hash_combine(Self, Hasher) -> Unit
-  hash(Self) -> Int
+  hash(Self) -> Int = _
 }
-impl Hash::hash
 impl Hash for Byte
 impl Hash for Int
 impl Hash for UInt
@@ -800,9 +799,8 @@ impl[A : Hash, B : Hash, C : Hash, D : Hash, E : Hash, F : Hash, G : Hash] Hash
 pub(open) trait Logger {
   write_string(Self, String) -> Unit
   write_substring(Self, String, Int, Int) -> Unit
-  write_char(Self, Char) -> Unit
+  write_char(Self, Char) -> Unit = _
 }
-impl Logger::write_char
 
 pub(open) trait Mod {
   op_mod(Self, Self) -> Self
@@ -842,9 +840,8 @@ impl Shl for UInt64
 
 pub(open) trait Show {
   output(Self, &Logger) -> Unit
-  to_string(Self) -> String
+  to_string(Self) -> String = _
 }
-impl Show::to_string
 impl Show for Unit
 impl Show for Bool
 impl Show for Byte

prelude/prelude.mbti

@@ -1,107 +1,111 @@
 package "moonbitlang/core/prelude"
 
+import(
+  "moonbitlang/core/builtin"
+)
+
 // Values
 fn abort[T](String) -> T
 
-fn assert_eq[T : Eq + Show](T, T, loc~ : SourceLoc = _) -> Unit!
+fn assert_eq[T : @builtin.Eq + @builtin.Show](T, T, loc~ : @builtin.SourceLoc = _) -> Unit!
 
-fn assert_false(Bool, loc~ : SourceLoc = _) -> Unit!
+fn assert_false(Bool, loc~ : @builtin.SourceLoc = _) -> Unit!
 
-fn assert_not_eq[T : Eq + Show](T, T, loc~ : SourceLoc = _) -> Unit!
+fn assert_not_eq[T : @builtin.Eq + @builtin.Show](T, T, loc~ : @builtin.SourceLoc = _) -> Unit!
 
-fn assert_true(Bool, loc~ : SourceLoc = _) -> Unit!
+fn assert_true(Bool, loc~ : @builtin.SourceLoc = _) -> Unit!
 
 #deprecated
-fn dump[T](T, name? : String, loc~ : SourceLoc = _) -> T
+fn dump[T](T, name? : String, loc~ : @builtin.SourceLoc = _) -> T
 
-fn fail[T](String, loc~ : SourceLoc = _) -> T!Failure
+fn fail[T](String, loc~ : @builtin.SourceLoc = _) -> T!@builtin.Failure
 
 fn ignore[T](T) -> Unit
 
-fn inspect(&Show, content~ : String = .., loc~ : SourceLoc = _, args_loc~ : ArgsLoc = _) -> Unit!InspectError
+fn inspect(&@builtin.Show, content~ : String = .., loc~ : @builtin.SourceLoc = _, args_loc~ : @builtin.ArgsLoc = _) -> Unit!@builtin.InspectError
 
 fn not(Bool) -> Bool
 
 fn panic[T]() -> T
 
 fn physical_equal[T](T, T) -> Bool
 
-fn println[T : Show](T) -> Unit
+fn println[T : @builtin.Show](T) -> Unit
 
-fn repr[T : Show](T) -> String
+fn repr[T : @builtin.Show](T) -> String
 
 // Types and methods
 
 // Type aliases
-pub typealias ArgsLoc = ArgsLoc
+pub typealias ArgsLoc = @builtin.ArgsLoc
 
-pub typealias Array[X] = Array[X]
+pub typealias Array[X] = @builtin.Array[X]
 
-pub typealias ArrayView[X] = ArrayView[X]
+pub typealias ArrayView[X] = @builtin.ArrayView[X]
 
-pub typealias BigInt = BigInt
+pub typealias BigInt = @builtin.BigInt
 
-pub typealias Failure = Failure
+pub typealias Failure = @builtin.Failure
 
-pub typealias Hasher = Hasher
+pub typealias Hasher = @builtin.Hasher
 
-pub typealias InspectError = InspectError
+pub typealias InspectError = @builtin.InspectError
 
-pub typealias Iter[X] = Iter[X]
+pub typealias Iter[X] = @builtin.Iter[X]
 
-pub typealias Iter2[X, Y] = Iter2[X, Y]
+pub typealias Iter2[X, Y] = @builtin.Iter2[X, Y]
 
-pub typealias IterResult = IterResult
+pub typealias IterResult = @builtin.IterResult
 
-pub typealias Json = Json
+pub typealias Json = @builtin.Json
 
-pub typealias Map[K, V] = Map[K, V]
+pub typealias Map[K, V] = @builtin.Map[K, V]
 
-pub typealias Set[X] = Set[X]
+pub typealias Set[X] = @builtin.Set[X]
 
-pub typealias SnapshotError = SnapshotError
+pub typealias SnapshotError = @builtin.SnapshotError
 
-pub typealias SourceLoc = SourceLoc
+pub typealias SourceLoc = @builtin.SourceLoc
 
-pub typealias StringBuilder = StringBuilder
+pub typealias StringBuilder = @builtin.StringBuilder
 
-pub typealias UninitializedArray[X] = UninitializedArray[X]
+pub typealias UninitializedArray[X] = @builtin.UninitializedArray[X]
 
-pub traitalias Add = Add
+pub traitalias Add = @builtin.Add
 
-pub traitalias BitAnd = BitAnd
+pub traitalias BitAnd = @builtin.BitAnd
 
-pub traitalias BitOr = BitOr
+pub traitalias BitOr = @builtin.BitOr
 
-pub traitalias BitXOr = BitXOr
+pub traitalias BitXOr = @builtin.BitXOr
 
-pub traitalias Compare = Compare
+pub traitalias Compare = @builtin.Compare
 
-pub traitalias Default = Default
+pub traitalias Default = @builtin.Default
 
-pub traitalias Div = Div
+pub traitalias Div = @builtin.Div
 
-pub traitalias Eq = Eq
+pub traitalias Eq = @builtin.Eq
 
-pub traitalias Hash = Hash
+pub traitalias Hash = @builtin.Hash
 
-pub traitalias Logger = Logger
+pub traitalias Logger = @builtin.Logger
 
-pub traitalias Mod = Mod
+pub traitalias Mod = @builtin.Mod
 
-pub traitalias Mul = Mul
+pub traitalias Mul = @builtin.Mul
 
-pub traitalias Neg = Neg
+pub traitalias Neg = @builtin.Neg
 
-pub traitalias Shl = Shl
+pub traitalias Shl = @builtin.Shl
 
-pub traitalias Show = Show
+pub traitalias Show = @builtin.Show
 
-pub traitalias Shr = Shr
+pub traitalias Shr = @builtin.Shr
 
-pub traitalias Sub = Sub
+pub traitalias Sub = @builtin.Sub
 
-pub traitalias ToJson = ToJson
+pub traitalias ToJson = @builtin.ToJson
 
 // Traits
 

random/README.mbt.md

@@ -7,7 +7,7 @@ Internally, it uses the `Chacha8` cipher to generate random numbers. It is a cry
 # Usage
 
 ```moonbit
-  let r = @random.new()
+  let r = @random.Rand::new(@random.chacha8())
   assert_eq!(r.uint(limit=10), 7)
   assert_eq!(r.uint(limit=10), 0)
   assert_eq!(r.uint(limit=10), 5)

random/random.mbt

@@ -13,36 +13,57 @@
 // limitations under the License.
 
 ///|
-/// Currently we only support [chacha8] as the source of randomness.
-struct Rand {
-  src : @random_source.ChaCha8
+/// `Rand` is a pseudo-random number generator (PRNG) that provides various
+/// methods to generate random numbers of different types.
+type Rand &Source
+
+///|
+/// The [Source] trait defines a method to generate random numbers.
+pub(open) trait Source {
+  next(Self) -> UInt64
+}
+
+///|
+impl Source for @random_source.ChaCha8 with next(self : @random_source.ChaCha8) -> UInt64 {
+  for {
+    let x = self.state.next()
+    if x.1 {
+      return x.0
+    }
+    self.state.refill()
+  }
 }
 
 ///|
 /// Create a new random number generator with [seed].
 /// @alert unsafe "Panic if seed is not 32 bytes long"
+#deprecated("Use `Rand::new(chacha8())` instead")
 pub fn new(seed~ : Bytes = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ123456") -> Rand {
   if seed.length() != 32 {
     abort("seed must be 32 bytes long")
   }
-  let src = @random_source.ChaCha8::new(seed)
-  { src, }
+  @random_source.ChaCha8::new(seed) as &Source
+}
+
+///|
+/// Create a new random number generator with [seed].
+/// @alert unsafe "Panic if seed is not 32 bytes long"
+pub fn chacha8(seed~ : Bytes = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ123456") -> &Source {
+  if seed.length() != 32 {
+    abort("seed must be 32 bytes long")
+  }
+  @random_source.ChaCha8::new(seed) as &Source
 }
 
-///| @alert deprecated "use `@random.new` instead"
-pub fn Rand::new(seed~ : Bytes = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ123456") -> Rand {
-  new(seed~)
+///|
+/// Create a new random number generator with a given [Gen] source.
+pub fn Rand::new(generator : &Source) -> Rand {
+  generator
 }
 
 ///|
 fn next(self : Rand) -> UInt64 {
-  for {
-    let x = self.src.state.next()
-    if x.1 {
-      return x.0
-    }
-    self.src.state.refill()
-  }
+  self._.next()
 }
 
 ///|

random/random.mbti

@@ -1,6 +1,8 @@
 package "moonbitlang/core/random"
 
 // Values
+fn chacha8(seed~ : Bytes = ..) -> &Source
+
 fn double(Rand) -> Double
 
 fn float(Rand) -> Float
@@ -9,6 +11,7 @@ fn int(Rand, limit~ : Int = ..) -> Int
 
 fn int64(Rand, limit~ : Int64 = ..) -> Int64
 
+#deprecated
 fn new(seed~ : Bytes = ..) -> Rand
 
 fn shuffle(Rand, Int, (Int, Int) -> Unit) -> Unit
@@ -24,7 +27,7 @@ impl Rand {
   float(Self) -> Float
   int(Self, limit~ : Int = ..) -> Int
   int64(Self, limit~ : Int64 = ..) -> Int64
-  new(seed~ : Bytes = ..) -> Self //deprecated
+  new(&Source) -> Self
   shuffle(Self, Int, (Int, Int) -> Unit) -> Unit
   uint(Self, limit~ : UInt = ..) -> UInt
   uint64(Self, limit~ : UInt64 = ..) -> UInt64
@@ -33,4 +36,7 @@ impl Rand {
 // Type aliases
 
 // Traits
+pub(open) trait Source {
+  next(Self) -> UInt64
+}