fn shrink(b : Bool) -> Iter[Bool]

source

fn shrink(x : Byte) -> Iter[Byte]

source

fn shrink(c : Char) -> Iter[Char]

source

fn shrink(x : Int) -> Iter[Int]

source

fn shrink(x : Int64) -> Iter[Int64]

source

fn shrink(x : UInt) -> Iter[UInt]

source

fn shrink(x : UInt64) -> Iter[UInt64]

source

fn shrink(x : Float) -> Iter[Float]

source

fn shrink(x : Double) -> Iter[Double]

source

fn shrink(s : String) -> Iter[String]

source

fn[T : Shrink] shrink(x : T?) -> Iter[T?]

source

fn[T : Shrink, E : Shrink] shrink(x : Result[T, E]) -> Iter[Result[T, E]]

source

fn[X : Shrink] shrink(xs : FixedArray[X]) -> Iter[FixedArray[X]]

source

fn shrink(bytes : Bytes) -> Iter[Bytes]

source

fn[X : Shrink] shrink(xs : Array[X]) -> Iter[Array[X]]

source

fn[X : Shrink] shrink(xs : ArrayView[X]) -> Iter[ArrayView[X]]

source

fn[K : Shrink + Hash + Eq, V : Shrink] shrink(xs : 
@moonbitlang/core/hashmap.HashMap
HashMap[K, V]) -> Iter[
@moonbitlang/core/hashmap.HashMap
HashMap[K, V]]

source

fn[T : Shrink + Eq + Hash] shrink(xs : 
@moonbitlang/core/hashset.HashSet
HashSet[T]) -> Iter[
@moonbitlang/core/hashset.HashSet
HashSet[T]]

source

fn[K : Shrink + Eq + Hash, V : Shrink] shrink(xs : 
@moonbitlang/core/immut/hashmap.HashMap
HashMap[K, V]) -> Iter[
@moonbitlang/core/immut/hashmap.HashMap
HashMap[K, V]]

source

fn[T : Shrink + Eq + Hash] shrink(xs : 
@moonbitlang/core/immut/hashset.HashSet
HashSet[T]) -> Iter[
@moonbitlang/core/immut/hashset.HashSet
HashSet[T]]

source

fn[K : Shrink + Compare + Eq, V : Shrink] shrink(xs : 
@moonbitlang/core/immut/sorted_map.SortedMap
SortedMap[K, V]) -> Iter[
@moonbitlang/core/immut/sorted_map.SortedMap
SortedMap[K, V]]

source

fn[T : Shrink + Compare + Eq] shrink(xs : 
@moonbitlang/core/immut/sorted_set.SortedSet
SortedSet[T]) -> Iter[
@moonbitlang/core/immut/sorted_set.SortedSet
SortedSet[T]]

source

fn[T : Shrink] shrink(xs : 
@moonbitlang/core/immut/vector.Vector
Vector[T]) -> Iter[
@moonbitlang/core/immut/vector.Vector
Vector[T]]

source

fn[T : Shrink] shrink(xs : 
@moonbitlang/core/list.List
List[T]) -> Iter[
@moonbitlang/core/list.List
List[T]]

source

fn[T : Shrink] shrink(xs : 
@moonbitlang/core/queue.Queue
Queue[T]) -> Iter[
@moonbitlang/core/queue.Queue
Queue[T]]

source

fn[K : Shrink + Compare + Eq, V : Shrink] shrink(xs : 
@moonbitlang/core/sorted_map.SortedMap
SortedMap[K, V]) -> Iter[
@moonbitlang/core/sorted_map.SortedMap
SortedMap[K, V]]

source

fn[T : Shrink + Compare + Eq] shrink(xs : 
@moonbitlang/core/sorted_set.SortedSet
SortedSet[T]) -> Iter[
@moonbitlang/core/sorted_set.SortedSet
SortedSet[T]]

source

fn[A : Shrink, B : Shrink] shrink(x : (A, B)) -> Iter[(A, B)]

source

fn[A : Shrink, B : Shrink, C : Shrink] shrink(x : (A, B, C)) -> Iter[(A, B, C)]

source

fn[A : Shrink, B : Shrink, C : Shrink, D : Shrink] shrink(x : (A, B, C, D)) -> Iter[(A, B, C, D)]

source

fn[A : Shrink, B : Shrink, C : Shrink, D : Shrink, E : Shrink] shrink(x : (A, B, C, D, E)) -> Iter[(A, B, C, D, E)]

source

fn[A : Shrink, B : Shrink, C : Shrink, D : Shrink, E : Shrink, F : Shrink] shrink(x : (A, B, C, D, E, F)) -> Iter[(A, B, C, D, E, F)]

source

fn[A : Shrink, B : Shrink, C : Shrink, D : Shrink, E : Shrink, F : Shrink, G : Shrink] shrink(x : (A, B, C, D, E, F, G)) -> Iter[(A, B, C, D, E, F, G)]

source

fn[A : Shrink, B : Shrink, C : Shrink, D : Shrink, E : Shrink, F : Shrink, G : Shrink, H : Shrink] shrink(x : (A, B, C, D, E, F, G, H)) -> Iter[(A, B, C, D, E, F, G, H)]

source

fn[A : Shrink, B : Shrink, C : Shrink, D : Shrink, E : Shrink, F : Shrink, G : Shrink, H : Shrink, I : Shrink] shrink(x : (A, B, C, D, E, F, G, H, I)) -> Iter[(A, B, C, D, E, F, G, H, I)]

source