Top AI Repos — open-source AI, indexed and scored
Top AI Repos tracks AI repositories on GitHub and answers two different questions about each one: is it moving right now, and would you bet a product on it.
Top AI Repos tracks AI repositories on GitHub and answers two different questions about each one: is it moving right now, and would you bet a product on it.
🎱 Composable, transformable, controllable randomness.
| Date | Stars |
|---|---|
| 2026-07-24 | 304 |
| 2026-07-25 | 304 |
| 2026-07-28 | 304 |
| 2026-07-30 | 304 |
| 2026-08-06 | 304 |
Today
— stars today
This week
— stars this week
This month
— stars this month
Momentum
0.0
growth rate 0.00%/day
# 🎱 Gen
[](https://github.com/pointfreeco/swift-gen/actions/workflows/ci.yml)
[](https://swiftpackageindex.com/pointfreeco/swift-gen)
[](https://swiftpackageindex.com/pointfreeco/swift-gen)
Composable, transformable, controllable randomness.
## Table of Contents
- [Motivation](#motivation)
- [Examples](#examples)
- [Installation](#installation)
- [Interested in learning more?](#interested-in-learning-more)
- [License](#license)
## Motivation
Swift's randomness API is powerful and simple to use. It allows us to create random values from many basic types, such as booleans and numeric types, and it allows us to randomly shuffle arrays and pluck random elements from collections.
However, it does not make it easy for us to extend the randomness API, nor does it provide an API that is composable, which would allow us to create complex types of randomness from simpler pieces.
Gen is a lightweight wrapper over Swift's randomness APIs that makes it easy to build custom generators of any kind of value.
## Examples
Gen's namesake type, `Gen`, is responsible for producing random values. Most often you will reach for one of the static variables inside `Gen` to get access to a `Gen` value:
``` swift
Gen.bool
// Gen<Bool>
```
Rather than immediately producing a random value, `Gen` describes a random value that can be produced by calling its `run` method:
``` swift
let myGen = Gen.bool
// Gen<Bool>
myGen.run() // true
myGen.run() // true
myGen.run() // false
```
Every random function that comes with Swift is also available as a static function on `Gen`:
| Swift's API | Gen's API |
| --- | --- |
| `Int.random(in: 0...9)` | `Gen.int(in: 0...9)` |
| `Double.random(in: 0...9)` | `Gen.double(in: 0...9)` |
| `Bool.random()` | `Gen.bool` |
| `[1, 2, 3].randomElement()` | `Gen.element(of: [1, 2, 3])` |
| `[1, 2, 3].shuffled()` | `Gen.shuffle([1, 2, 3])` |
The reason it is powerful to wrap randomness in the `Gen` type is that we can make the `Gen` type composable. For example, a generator of integers can be turned into a generator of numeric strings with a simple application of the `map` function:
``` swift
let digit = Gen.int(in: 0...9) // Gen<Int>
let stringDigit = digit.map(String.init) // Gen<String>
stringDigit.run() // "7"
stringDigit.run() // "1"
stringDigit.run() // "3"
```
Already this is a form of randomness that Swift's API's do not provide out of the box.
Gen provides many operators for generating new types of randomness, such as `map`, `flatMap` and `zip`, as well as helper functions for generating random arrays, sets, dictionaries, strings, distributions and more! A random password generator, for example, is just a few operators away.
``` swift
// Take a generator of random letters and numbers.
let password = Gen.letterOrNumber
// Generate 6-character strings of them.
.string(of: .always(6))
// Generate 3 segments of these strings.
.array(of: .always(3))
// And join them.
.map { $0.joined(separator: "-") }
password.run() // "9BiGYA-fmvsOf-VYDtDv"
password.run() // "dS2MGr-FQSuC4-ZLEicl"
password.run() // "YusZGF-HILrCo-rNGfCA"
```
This kind of composition makes it simple to generate random values of anything.
``` swift
// Use `zip` to combine generators together and build structures.
let randomPoint = zip(.int(in: -10...10), .int(in: -10...10))
.map(CGPoint.init(x:y:))
// Gen<CGPoint>
```
But composability isn't the only reason the `Gen` type shines. By delaying the creation of random values until theExcerpt of 7,064 characters
Read on GitHubWould you bet a product on this? Bounded 0–100 and slow moving.
matched fp:8c080e3101c13a3b, topic:testing