So one thing would be to change 

fun edgecases(): ...

 to 

fun edgecases(rs: RandomSource):...

 and then it’s up to the arb if they want to return a static list or not,

another way would be to return a function that accepts the RS and then returns, so 

fun edges() : (RandomSource) -> List<A>

 which defaults to just 

= { edgecases() }

I think the easiest way would be to pass the random source into the edgecases method, and then Arb.bind can use that RS to call .sample on whatever it needs

data class EdgeCases<out A>(val generate: (RandomSource) -> NonEmptyList<A>)

Arb<A>

emptyList()

Arb<A> {
   fun edgecases(rs: RandomSource): List<A>
}

bind(arbA, arbB): Arb<B> {
   fun edgecases(rs: RandomSource): List<A> = // find out if any of the A or B edgecases is empty and default accordingly
}

Arb<A>.flatMap(fn: (A) -> Arb<B>): Arb<B> {
   fun edgecases(rs: RandomSource): List<B> = this@flatMap.edgecases(rs).flatMap { a -> fn(a) // resolve edges here }
}

the bind impl might need to change too, currently bindN delegates to bindN-1

genA.bind(genB).bind(genC).bind(genD).bind(genE).bind(genF).bind(genG).map { (abcdef, g) ->
   val (abcde, f) = abcdef
   val (abcd, e) = abcde
   val (abc, d) = abcd
   val (ab, c) = abc
   val (a, b) = ab
   bindFn(a, b, c, d, e, f, g)

Applicative[F[_]] {
   product(a: F[A], b: F[B]): F[(A, B)]
}

Arb<A>.withEdgecases(fn: (RandomSeed) -> List<A>): Arb<A>

Arb<A>.modifyEdgecases(fn: (initial: List<A>, rs: RandomSeed) -> List<A>): Arb<A>

Overload resolution ambiguity. All these functions match.
public fun <A> Arb<TypeVariable(A)>.modifyEdgecases(f: (initial: List<TypeVariable(A)>, randomSource: RandomSource) → List<TypeVariable(A)>): Arb<TypeVariable(A)> defined in io.kotest.property.arbitrary in file arbs.kt

public fun <A> Arb<TypeVariable(A)>.modifyEdgecases(f: (List<TypeVariable(A)>) → List<TypeVariable(A)>): Arb<TypeVariable(A)> defined in io.kotest.property.arbitrary in file arbs.kt

fun <A> Arb<A>.modifyEdgecases(f: RandomSource.(List<A>) -> List<A>): Arb<A> =
   arbitrary({ rs -> f(rs, this@modifyEdgecases.edgecases(rs)) }, { this.next(it) })

fun <A> Arb<A>.modifyEdgecases(f: (List<A>) -> List<A>): Arb<A> = TODO()
fun <A> Arb<A>.modifyEdgecases(f: (List<A>, RandomSource) -> List<A>): Arb<A> = TODO()

fun <A> Arb<A>.modifyEdgecases(f: (List<A>) -> List<A>): Arb<A> = TODO()

@JvmName("modifyEdgecasesRandom")
fun <A> Arb<A>.modifyEdgecases(f: (List<A>, RandomSource) -> List<A>): Arb<A> = TODO()

listOf(2,3) + it

listOf(2,3) + it

 

a -> a + listOf(2,3)

Arb<A> {
   fun edgecases(rs: RandomSource): List<A>
}

"Arb.bind(a,b,c,d) should compute the cartesian product of edges" {
   val arbA = Arb.string(1)
   val arbB = Arb.string().withEdgecases("a", "b")
   val arbC = Arb.string(1)
   val arbD = Arb.string().withEdgecases("a", "b")
   val arb = Arb.bind(arbA, arbB, arbC, arbD) { a, b, c, d -> a + b + c + d }
   arb.edgecases(RandomSource.seeded(1234L)) shouldContainExactlyInAnyOrder listOf(
      "Uaka", "%bca", "?aCb", "KbGb"
   )
}

["Uaka", "%bca", "?aCb", "KbGb"]

["Uaka", "Uakb", "%bca", "%bcb"]

private fun <A, B, C> Gen<A>.bind(other: Gen<B>, fn: (A, B) -> C): Arb<C> {
   val thisArb = when (this) {
      is Arb -> this
      is Exhaustive -> this.toArb()
   }

   val otherArb = when (other) {
      is Arb -> other
      is Exhaustive -> other.toArb()
   }

   val arb = thisArb.flatMap { a -> otherArb.map { b -> fn(a, b) } }

   return object : Arb<C>() {
      override fun edgecases(): List<C> = arb.edgecases()
      override fun edgecases(rs: RandomSource): List<C> {
         val maybeEdgesA = NonEmptyList.fromList(thisArb.edgecases(rs))
         val maybeEdgesB = NonEmptyList.fromList(otherArb.edgecases(rs))
         return maybeEdgesA.fold(
            ifEmpty = {
               maybeEdgesB.fold(
                  ifEmpty = {
                     fn(thisArb.single(rs), otherArb.single(rs)).nel()
                  },
                  ifDefined = { edgesB ->
                     edgesB.map { b ->
                        val a = thisArb.single(rs)
                        fn(a, b)
                     }
                  }
               )
            },
            ifDefined = { edgesA ->
               maybeEdgesB.fold(
                  ifEmpty = {
                     edgesA.map { a: A ->
                        val b = otherArb.single(rs)
                        fn(a, b)
                     }
                  },
                  ifDefined = { edgesB ->
                     edgesA.flatMap { a: A ->
                        edgesB.map { b: B ->
                           fn(a, b)
                        }
                     }
                  }
               )
            }
         ).all
      }

      override fun sample(rs: RandomSource): Sample<C> = arb.sample(rs)

      override fun values(rs: RandomSource): Sequence<Sample<C>> = arb.values(rs)
   }
}

Arb<A> {
   fun edgecases(): (rs: RandomSource) -> List<A>
}

edgesOrSample

r1 a r2 a
r3 a r4 b
r5 b r6 a
r7 b r8 b

r1 a r2 a
r1 a r2 b
r3 b r4 a
r3 b r4 b

List<Edge<A>>

Edge<A> -> A

a, *

val arbA = Arb.string().withEdgecases("a", "b")
val arbB = Arb.string().withEdgecases("c", "d")
val arbC = Arb.string().withEdgecases("e", "f")
val arbD = Arb.string(1)

In that scenario, I would probably expect (a, c, e, Z), (b, c, e, Z), (a, d, e, Z), (b, d, e, Z) and so on. Z being a random, but fixed element.

list.flatMap

fun list() = edgesOrSample(maybeEdgesA, this@bind, rs) // e.g. r1, r2
fun anotherList() = edgesOrSample(maybeEdgesB, this@bind, rs) // e.g. a, b
list.flatMap { first -> anotherList.map { second -> first to second } }
// r1 -> a
// r1 -> b
// r2 -> a
// r2 -> b

(a, c, e, Z), (b, c, e, Z), (a, d, e, Z), (b, d, e, Z)

(a, c, e, Z), (b, c, e, Z), (a, d, e, Z), (b, d, e, Z)