StreamData

https://github.com/whatyouhide/stream_data
Admin
StreamData is an Elixir library for data generation and property-based testing that provides...
Tokens:8,888
Snippets:94
Trust Score:9.9
Update:6 months ago
Show doc for...
Tokens:
Raw
### Generate Dates with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Examples of generating dates using origin, ranges, or Date.Range.

```elixir
Enum.take(StreamData.date(origin: ~D[2025-09-01]), 3)
#=> [~D[2025-08-31], ~D[2025-08-31], ~D[2025-09-04]]
```

```elixir
Enum.take(StreamData.date(min: ~D[2025-01-01], max: ~D[2025-01-31]), 3)
#=> [~D[2025-01-27], ~D[2025-01-21], ~D[2025-01-16]]
```

```elixir
Enum.take(StreamData.date(Date.range(~D[2025-01-01], ~D[2025-01-31])), 3)
#=> [~D[2025-01-29], ~D[2025-01-03], ~D[2025-01-15]]
```

--------------------------------

### Generate and Transform Integers with StreamData

Source: https://github.com/whatyouhide/stream_data/blob/main/README.md

Use StreamData generators as infinite streams. This example generates integers, takes their absolute values, and returns the first three.

```elixir
StreamData.integer() |> Stream.map(&abs/1) |> Enum.take(3)
```

--------------------------------

### Property Test: Binary Concatenation

Source: https://github.com/whatyouhide/stream_data/blob/main/README.md

Write a property test using ExUnitProperties to verify that the concatenation of two binaries always starts with the first binary. This demonstrates property-based testing with StreamData.

```elixir
use ExUnitProperties

property "bin1 <> bin2 always starts with bin1" do
  check all bin1 <- binary(),
            bin2 <- binary() do
    assert String.starts_with?(bin1 <> bin2, bin1)
  end
end
```

--------------------------------

### Pick a single random value from a generator

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Picks a single random value from a generator using ExUnit's seed for reproducibility. Useful for getting a specific example value.

```elixir
ExUnitProperties.pick(StreamData.integer())
#=> -21

ExUnitProperties.pick(StreamData.list_of(StreamData.string(:alphanumeric)))
#=> ["abc", "xyz"]
```

--------------------------------

### Generate Random Integers with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates integers bound by the generation size. Values shrink towards 0. Use Enum.take to get a sample.

```elixir
Enum.take(StreamData.integer(), 5)
#=> [1, -1, -3, 4, -2]
```

--------------------------------

### Configure StreamData Formatter

Source: https://github.com/whatyouhide/stream_data/blob/main/README.md

Import StreamData's formatter configuration by adding it to your .formatter.exs file.

```elixir
[
  import_deps: [:stream_data]
]
```

--------------------------------

### Generate Binaries with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates binaries with configurable length options using :length, :min_length, and :max_length.

```elixir
Enum.take(StreamData.binary(), 3)
#=> [<<1>>, "", "@Q"]
```

```elixir
Enum.take(StreamData.binary(length: 4), 3)
#=> [<<12, 45, 89, 200>>, <<0, 128, 64, 32>>, <<255, 1, 2, 3>>]
```

```elixir
Enum.take(StreamData.binary(min_length: 2, max_length: 5), 3)
#=> [<<1, 2>>, <<45, 89, 200, 12>>, <<0, 128, 64>>]
```

--------------------------------

### Generate Keyword Lists with StreamData.keyword_of/1

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates keyword lists with atom keys and generated values.

```elixir
Enum.take(StreamData.keyword_of(StreamData.integer()), 3)
#=> [[], [sY: 1], [t: -1]]
```

--------------------------------

### Run property tests with generated values

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Runs property tests with generated values and supports options like `:max_runs`, `:max_run_time`, `:initial_size`, and `:max_shrinking_steps`. Use for basic checks, filtering, or time-limited tests.

```elixir
use ExUnitProperties

# Basic check
check all int <- integer() do
  assert is_integer(int)
end

# With filtering clause
check all int1 <- integer(),
          int2 <- integer(),
          int1 > 0 and int2 > 0,
          sum = int1 + int2 do
  assert sum > int1
  assert sum > int2
end

# With options
check all list <- list_of(integer()),
          member <- member_of(list),
          max_runs: 50 do
  assert member in list
end

# Time-limited check
check all data <- term(),
          max_run_time: 5000 do  # 5 seconds
  assert data == data
end
```

--------------------------------

### Build complex generators with filtering and binding

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Provides syntactic sugar for building complex generators with filtering and binding. Use for creating custom generators like email or time formats.

```elixir
use ExUnitProperties

# Email generator
email_generator = gen all name <- string(:alphanumeric, min_length: 1),
                         domain <- member_of(["gmail.com", "yahoo.com"])
  "#{name}@#{domain}"

Enum.take(email_generator, 2)
#=> ["abc@gmail.com", "xyz@yahoo.com"]

# Time generator
valid_time_generator = gen all hour <- integer(0..23),
                              minute <- integer(0..59),
                              second <- integer(0..59) do
  Time.new!(hour, minute, second)
end

# Non-noon time with filter
non_noon_generator = gen all time <- valid_time_generator,
                            time != ~T[12:00:00] do
  time
end
```

--------------------------------

### Create size-aware generators

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.sized/1` to create generators that adapt their behavior based on the current generation size, allowing for dynamic data generation.

```elixir
data = StreamData.sized(fn size ->
  StreamData.resize(StreamData.integer(), size * 2)
end)
Enum.take(data, 3)
#=> [0, -1, 5]
```

--------------------------------

### Generate Lists with StreamData.list_of/2

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates lists with configurable length constraints.

```elixir
# Basic list of integers
Enum.take(StreamData.list_of(StreamData.integer()), 3)
#=> [[-1], [], [2, 3, 1]]

# Fixed length lists
Enum.take(StreamData.list_of(StreamData.integer(), length: 3), 3)
#=> [[0, 0, -1], [2, -1, 1], [0, 3, -3]]

# Bounded length
Enum.take(StreamData.list_of(StreamData.integer(), min_length: 1, max_length: 3), 3)
#=> [[1], [2, -1], [0, 3, -3]]
```

--------------------------------

### Generate Floats with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates floats with optional bounds using :min and :max options. Values shrink towards simpler floats.

```elixir
Enum.take(StreamData.float(), 3)
#=> [0.5119, -1.234, 0.892]
```

```elixir
Enum.take(StreamData.float(min: 0.0, max: 1.0), 3)
#=> [0.234, 0.891, 0.123]
```

```elixir
Enum.take(StreamData.float(min: 100.0), 3)
#=> [105.67, 200.34, 150.89]
```

--------------------------------

### Low-level function to check properties programmatically

Source: https://context7.com/whatyouhide/stream_data/llms.txt

A low-level function to check properties programmatically, returning `{:ok, map}` or `{:error, map}`. Useful for integrating property testing into custom workflows or reporting.

```elixir
options = [initial_seed: :os.timestamp()]

result = StreamData.check_all(StreamData.integer(), options, fn int ->
  if int == 0 or rem(int, 11) != 0 do
    {:ok, nil}
  else
    {:error, Integer.to_string(int)}
  end
end)

case result do
  {:ok, _} ->
    IO.puts("All tests passed!")
  {:error, metadata} ->
    IO.puts("Failed! Original: #{metadata.original_failure}")
    IO.puts("Shrunk to: #{metadata.shrunk_failure}")
    IO.puts("Nodes visited: #{metadata.nodes_visited}")
end
```

--------------------------------

### Generate Dates with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates dates with optional bounds using :origin, :min, :max options or a Date.Range.

```elixir
Enum.take(StreamData.date(), 3)
#=> [~D[2023-11-24], ~D[2023-11-25], ~D[2023-11-23]]
```

--------------------------------

### Create a constant generator

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.constant/1` to create a generator that always produces the same value. This generator does not shrink.

```elixir
Enum.take(StreamData.constant(:some_term), 3)
#=> [:some_term, :some_term, :some_term]
```

--------------------------------

### Generate values with specified probability weights

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.frequency/1` to generate values from a list of generators, where each generator has a specified weight determining its probability of being chosen.

```elixir
# 75% integers, 25% binaries
ints_and_some_bins = StreamData.frequency([
  {3, StreamData.integer()},
  {1, StreamData.binary()}
])
Enum.take(ints_and_some_bins, 4)
#=> [1, -2, "", -1]
```

--------------------------------

### Generate Codepoints with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates valid UTF-8 codepoints of specified kind: :ascii, :alphanumeric, or :printable.

```elixir
Enum.take(StreamData.codepoint(:ascii), 3)
#=> ~c"Kk:"
```

```elixir
Enum.take(StreamData.codepoint(:alphanumeric), 3)
#=> ~c"aB9"
```

--------------------------------

### StreamData Binary and String Generators

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Functions for generating binary data, bitstrings, strings, and codepoints with configurable constraints.

```APIDOC
## StreamData.binary/1

### Description
Generates binaries with configurable length options such as :length, :min_length, and :max_length.

## StreamData.bitstring/1

### Description
Generates bitstrings with configurable length options.

## StreamData.string/2

### Description
Generates strings based on character sets like :ascii, :alphanumeric, :printable, or custom ranges.

## StreamData.codepoint/1

### Description
Generates valid UTF-8 codepoints of specified kinds.
```

--------------------------------

### Create Custom Email Generators

Source: https://github.com/whatyouhide/stream_data/blob/main/README.md

Define a custom email generator using StreamData and ExUnitProperties.gen. This generator combines random alphanumeric names with a predefined list of domains.

```elixir
require ExUnitProperties

domains = [
  "gmail.com",
  "hotmail.com",
  "yahoo.com",
]

email_generator = 
  ExUnitProperties.gen all name <- StreamData.string(:alphanumeric),
                           name != "",
                           domain <- StreamData.member_of(domains) do
    name <> "@" <> domain
  end

Enum.take(StreamData.resize(email_generator, 20), 2)
```

--------------------------------

### Define a property test in ExUnit

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Defines a property test using ExUnit. Imports all StreamData functions. Use to assert properties that should hold true for generated data.

```elixir
defmodule MyTest do
  use ExUnit.Case
  use ExUnitProperties

  property "reversing a list doesn't change its length" do
    check all list <- list_of(integer()) do
      assert length(list) == length(:lists.reverse(list))
    end
  end

  property "string concatenation" do
    check all a <- binary(),
              b <- binary() do
      assert String.starts_with?(a <> b, a)
      assert String.ends_with?(a <> b, b)
    end
  end
end
```

--------------------------------

### Add StreamData to Mix Dependencies

Source: https://github.com/whatyouhide/stream_data/blob/main/README.md

Add StreamData to your project's dependencies, typically only for the test environment.

```elixir
defp deps() do
  [{:stream_data, "~> 1.0", only: :test}]
end
```

--------------------------------

### Generate Bitstrings with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates bitstrings with configurable length options, similar to binary/1.

```elixir
Enum.take(StreamData.bitstring(), 3)
#=> [<<0::size(1)>>, <<2::size(2)>>, <<5::size(3)>>]
```

--------------------------------

### Generate values by calling a function repeatedly

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates values by calling a function repeatedly. This generator is not shrinkable. Useful for generating unique or complex values.

```elixir
# Unique integers
integer_gen = StreamData.repeatedly(&System.unique_integer([:positive, :monotonic]))
Enum.take(integer_gen, 3)
#=> [1, 2, 3]

# UUIDs (with Ecto)
# uuid_gen = StreamData.repeatedly(&Ecto.UUID.generate/0)
```

--------------------------------

### Shuffle Enumerables with StreamData.shuffle/1

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates shuffled versions of an enumerable, shrinking towards the original order.

```elixir
StreamData.shuffle([1, 2, 3, 4, 5])
|> Enum.take(3)
#=> [[4, 2, 5, 3, 1], [1, 3, 4, 5, 2], [3, 2, 5, 4, 1]]
```

--------------------------------

### Generate Positive Integers with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates positive integers (>= 1) bound by the generation size. Values shrink towards 1.

```elixir
Enum.take(StreamData.positive_integer(), 5)
#=> [1, 1, 3, 2, 5]
```

--------------------------------

### Generate Maps with StreamData.map_of/3

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates maps with keys and values from specified generators.

```elixir
Enum.take(StreamData.map_of(StreamData.integer(), StreamData.boolean()), 3)
#=> [%{}, %{1 => false}, %{-2 => true, -1 => false}]

# String to integer map with bounded size
Enum.take(StreamData.map_of(
  StreamData.string(:alphanumeric, min_length: 1),
  StreamData.integer(),
  max_length: 3
), 2)
#=> [%{"a" => 1, "b" => -2}, %{"xyz" => 5}]
```

--------------------------------

### Generate Optional Maps with StreamData.optional_map/2

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates maps where specific keys are optional.

```elixir
# All keys optional
data = StreamData.optional_map(%{
  integer: StreamData.integer(),
  binary: StreamData.binary()
})
Enum.take(data, 3)
#=> [%{binary: "", integer: 1}, %{integer: -2}, %{binary: "R1^"}]

# Only some keys optional
data = StreamData.optional_map(%{
  id: StreamData.positive_integer(),
  name: StreamData.string(:alphanumeric),
  email: StreamData.string(:alphanumeric)
}, [:email])  # email is optional, id and name are required
Enum.take(data, 2)
#=> [%{id: 1, name: "abc"}, %{id: 2, name: "xyz", email: "test@example"}]
```

--------------------------------

### Generate Fixed Lists with StreamData.fixed_list/1

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates lists of a fixed length where each position uses a specific generator.

```elixir
data = StreamData.fixed_list([StreamData.integer(), StreamData.binary()])
Enum.take(data, 3)
#=> [[1, <<164>>], [2, ".T"], [1, ""]]

# HTTP response tuple
response_generator = StreamData.fixed_list([
  StreamData.member_of([:ok, :error]),
  StreamData.integer(200..599),
  StreamData.string(:alphanumeric)
])
Enum.take(response_generator, 2)
#=> [[:ok, 200, "success"], [:error, 404, "notfound"]]
```

--------------------------------

### Generate Strings with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates strings of various kinds: :ascii, :alphanumeric, :printable, :utf8, a range, or a list of ranges/codepoints.

```elixir
Enum.take(StreamData.string(:ascii), 3)
#=> ["c", "9A", ""]
```

```elixir
Enum.take(StreamData.string(:alphanumeric, min_length: 5), 3)
#=> ["abc12", "XyZ99", "Hello"]
```

```elixir
Enum.take(StreamData.string(?a..?z, length: 3), 3)
#=> ["abc", "xyz", "def"]
```

```elixir
Enum.take(StreamData.string([?a..?z, ?0..?9]), 3)
#=> ["a1b", "x9", "3z2c"]
```

--------------------------------

### Generate nullable values

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.nullable/2` to generate either `nil` or a value from a specified generator. The `:ratio` option controls the frequency of `nil`.

```elixir
# 50% nil by default
Enum.take(StreamData.nullable(StreamData.integer()), 10)
#=> [1, -1, nil, nil, 5, 4, -3, nil, nil, 1]
```

```elixir
# 25% nil
Enum.take(StreamData.nullable(StreamData.integer(), ratio: 0.25), 10)
#=> [1, nil, -3, 0, 3, -3, 0, 3, nil, 5]
```

--------------------------------

### Make generation deterministic with a seed

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Makes data generation deterministic by fixing the seed. This ensures the same sequence of generated values is produced on every run.

```elixir
int = StreamData.seeded(StreamData.integer(), 10)

Enum.take(int, 3)
#=> [-1, -2, 1]
Enum.take(int, 3)  # Same result every time
#=> [-1, -2, 1]
```

--------------------------------

### Combine binding with filtering

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.bind_filter/3` to conditionally generate values. Return `{:cont, generator}` to continue generation with a new generator, or `:skip` to filter out the current value.

```elixir
require Integer

list_data = StreamData.list_of(StreamData.integer(), min_length: 1)

data = StreamData.bind_filter(list_data, fn
  list when Integer.is_even(length(list)) ->
    inner_data = StreamData.bind(StreamData.member_of(list), fn member ->
      StreamData.constant({list, member})
    end)
    {:cont, inner_data}
  _odd_list ->
    :skip
end)

Enum.at(data, 0)
#=> {[-6, -7, -4, 5], -4}
```

--------------------------------

### Generate Bytes with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates bytes (integers between 0 and 255). Shrinks towards 0.

```elixir
Enum.take(StreamData.byte(), 5)
#=> [102, 161, 13, 255, 42]
```

--------------------------------

### Scale data generation size

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Transforms the generation size using a provided function. Use for slower growth or to cap maximum size.

```elixir
# Slower growth using logarithm
data = StreamData.scale(StreamData.integer(), fn size ->
  trunc(:math.log(max(size, 1)))
end)
Enum.take(data, 3)
#=> [0, 0, -1]

# Cap maximum size
small_binaries = StreamData.scale(StreamData.binary(), fn size ->
  min(size, 64)
end)
```

--------------------------------

### Generate from one of multiple generators

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.one_of/1` to randomly select and generate values from a list of provided generators.

```elixir
data = StreamData.one_of([StreamData.integer(), StreamData.binary()])
Enum.take(data, 5)
#=> [-1, <<28>>, "", 3, <<1, 2>>]
```

--------------------------------

### Fix generation size

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.resize/2` to control the size of generated data, ensuring consistency for specific test cases or scenarios.

```elixir
data = StreamData.resize(StreamData.integer(), 10)
Enum.take(data, 3)
#=> [4, -5, -9]
```

--------------------------------

### Generate Fixed Maps with StreamData.fixed_map/1

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates maps with a fixed set of keys and generated values.

```elixir
data = StreamData.fixed_map(%{
  integer: StreamData.integer(),
  binary: StreamData.binary()
})
Enum.take(data, 3)
#=> [%{binary: "", integer: 1}, %{binary: "", integer: -2}, %{binary: "R1^", integer: -3}]

# User struct generation
user_generator = StreamData.fixed_map(%{
  name: StreamData.string(:alphanumeric, min_length: 1),
  age: StreamData.integer(0..120),
  active: StreamData.boolean()
})
Enum.take(user_generator, 2)
#=> [%{name: "John", age: 25, active: true}, %{name: "Jane", age: 42, active: false}]
```

--------------------------------

### Generate iodata

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates values of type `t:iodata/0`. Useful for functions that accept iodata as input.

```elixir
Enum.take(StreamData.iodata(), 3)
#=> [[""], <<198>>, [115, 172]]
```

--------------------------------

### Generate iolists

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates values of type `t:iolist/0`. Useful for functions that accept iolists as input.

```elixir
Enum.take(StreamData.iolist(), 3)
#=> [[164 | ""], [225], ["" | ""]]
```

--------------------------------

### StreamData Generator Functions

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Core functions for creating and transforming data generators.

```APIDOC
## StreamData.constant/1

### Description
Creates a generator that always produces the same value. Does not shrink.

### Parameters
- **term** (any) - Required - The value to be generated.

## StreamData.map/2

### Description
Maps a function over a generator's values.

### Parameters
- **generator** (generator) - Required - The source generator.
- **mapper** (function) - Required - The function to apply to generated values.

## StreamData.bind/2

### Description
Binds generated values to create new generators. Essential for dependent generation.

### Parameters
- **generator** (generator) - Required - The source generator.
- **binder** (function) - Required - A function that returns a new generator based on the value.

## StreamData.bind_filter/3

### Description
Combines binding with filtering. Returns {:cont, generator} to continue or :skip to filter out.

### Parameters
- **generator** (generator) - Required - The source generator.
- **binder_filter** (function) - Required - A function returning {:cont, generator} or :skip.

## StreamData.filter/3

### Description
Filters generated values using a predicate.

### Parameters
- **generator** (generator) - Required - The source generator.
- **predicate** (function) - Required - A function returning a boolean.

## StreamData.one_of/1

### Description
Generates values from one of the given generators, chosen randomly.

### Parameters
- **generators** (list) - Required - A list of generators.

## StreamData.frequency/1

### Description
Generates values from generators with specified probability weights.

### Parameters
- **weighted_generators** (list) - Required - A list of tuples {weight, generator}.

## StreamData.member_of/1

### Description
Generates random elements from an enumerable.

### Parameters
- **enumerable** (enumerable) - Required - The collection to pick from.

## StreamData.nullable/2

### Description
Generates either nil or a value from the given generator.

### Parameters
- **generator** (generator) - Required - The source generator.
- **options** (keyword) - Optional - :ratio option to control nil frequency.

## StreamData.nonempty/1

### Description
Constrains a generator of enumerables to be non-empty.

### Parameters
- **generator** (generator) - Required - The source generator.

## StreamData.tree/2

### Description
Generates recursive tree structures.

### Parameters
- **leaf_generator** (generator) - Required - Generator for leaves.
- **node_function** (function) - Required - Function to create inner nodes.
```

--------------------------------

### Generate Tuples with StreamData.tuple/1

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates tuples with elements derived from corresponding generators.

```elixir
data = StreamData.tuple({StreamData.integer(), StreamData.binary()})
Enum.take(data, 3)
#=> [{-1, <<170>>}, {1, "<"}, {1, ""}]
```

--------------------------------

### Bind generated values to create new generators

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.bind/2` for dependent generation, where the output of one generator influences the next. Essential for creating complex, related data structures.

```elixir
# Generate a list and an element from that list
StreamData.bind(StreamData.list_of(StreamData.integer(), min_length: 1), fn list ->
  StreamData.bind(StreamData.member_of(list), fn elem ->
    StreamData.constant({list, elem})
  end)
end)
|> Enum.take(2)
#=> [{[1, -2], 1}, {[3, 4, -1], 4}]
```

--------------------------------

### Generate Unique Lists with StreamData.uniq_list_of/2

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates lists without duplicate elements, supporting custom uniqueness functions.

```elixir
# Unique integers
Enum.take(StreamData.uniq_list_of(StreamData.integer()), 3)
#=> [[1], [], [2, 3, 1]]

# Unique by custom function
user_generator = StreamData.fixed_map(%{id: StreamData.positive_integer(), name: StreamData.string(:alphanumeric)})
Enum.take(StreamData.uniq_list_of(user_generator, uniq_fun: & &1.id), 2)
#=> [[%{id: 1, name: "abc"}, %{id: 2, name: "xyz"}], [%{id: 5, name: "test"}]]
```

--------------------------------

### Generate random elements from an enumerable

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.member_of/1` to pick random elements from a given enumerable. This generator shrinks towards earlier elements.

```elixir
Enum.take(StreamData.member_of([:ok, 4, "hello"]), 3)
#=> [4, 4, "hello"]
```

```elixir
# Status codes
Enum.take(StreamData.member_of([200, 201, 400, 404, 500]), 3)
#=> [200, 404, 201]
```

--------------------------------

### Generate Non-Negative Integers with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates non-negative integers (>= 0) bound by the generation size. Values shrink towards 0.

```elixir
Enum.take(StreamData.non_negative_integer(), 5)
#=> [0, 2, 0, 3, 1]
```

--------------------------------

### Generate Integers in a Fixed Range with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates integers within a specific range. Supports stepped ranges in Elixir 1.12+. The generation size is ignored.

```elixir
Enum.take(StreamData.integer(1..100), 5)
#=> [67, 42, 89, 15, 73]
```

```elixir
Enum.take(StreamData.integer(0..100//2), 5)
#=> [48, 22, 96, 4, 70]
```

```elixir
age_generator = StreamData.integer(0..120)
Enum.take(age_generator, 3)
#=> [45, 12, 89]
```

--------------------------------

### Generate any Elixir term

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates any Elixir term, including integers, binaries, floats, booleans, atoms, references, lists, maps, and tuples. Useful for comprehensive testing.

```elixir
Enum.take(StreamData.term(), 3)
#=> [0.5119, {{true, ""}}, :WJg]
```

--------------------------------

### Generate chardata

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates values of type `t:IO.chardata/0`. Useful for functions that accept chardata as input.

```elixir
Enum.take(StreamData.chardata(), 3)
#=> ["", [""], [12174]]
```

--------------------------------

### Generate Boolean Values with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates boolean values. Shrinks towards false.

```elixir
Enum.take(StreamData.boolean(), 5)
#=> [true, true, false, true, false]
```

--------------------------------

### Generate MapSets with StreamData.mapset_of/2

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates MapSets containing unique values from a generator.

```elixir
Enum.take(StreamData.mapset_of(StreamData.integer()), 3)
#=> [#MapSet<[-1]>, #MapSet<[1, 2]>, #MapSet<[-3, 2, 3]>]
```

--------------------------------

### Prevent values from shrinking

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Ensures that generated values do not shrink during property-based testing. Useful for generators where shrinking is not desired or applicable.

```elixir
byte = StreamData.unshrinkable(StreamData.integer(0..255))
Enum.take(byte, 3)
#=> [190, 181, 178]
```

--------------------------------

### StreamData Integer Generators

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Functions for generating various types of integers, including bounded, positive, and non-negative variants.

```APIDOC
## StreamData.integer/0

### Description
Generates integers bound by the generation size. The range grows as the generation size increases.

## StreamData.integer/1

### Description
Generates an integer within a specific range. Supports stepped ranges in Elixir 1.12+.

## StreamData.positive_integer/0

### Description
Generates positive integers (>= 1) bound by the generation size.

## StreamData.non_negative_integer/0

### Description
Generates non-negative integers (>= 0) bound by the generation size.
```

--------------------------------

### Map a function over generator values

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.map/2` to apply a function to each value generated. This is useful for transforming data types or creating new structures.

```elixir
data = StreamData.map(StreamData.integer(), &Integer.to_string/1)
Enum.take(data, 3)
#=> ["1", "0", "3"]
```

```elixir
# Create email generator
email_gen = StreamData.map(
  {StreamData.string(:alphanumeric, min_length: 1), StreamData.member_of(["gmail.com", "yahoo.com"])},
  fn {name, domain} -> "#{name}@#{domain}" end
)
Enum.take(email_gen, 2)
#=> ["abc@gmail.com", "xyz@yahoo.com"]
```

--------------------------------

### StreamData Miscellaneous Generators

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Functions for generating floats, booleans, bytes, atoms, and dates.

```APIDOC
## StreamData.float/1

### Description
Generates floats with optional :min and :max bounds.

## StreamData.boolean/0

### Description
Generates boolean values.

## StreamData.byte/0

### Description
Generates bytes (integers between 0 and 255).

## StreamData.atom/1

### Description
Generates atoms of specified kind: :alphanumeric or :alias.

## StreamData.date/1

### Description
Generates dates with optional :origin, :min, :max options or a Date.Range.
```

--------------------------------

### Generate recursive tree structures

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.tree/2` to generate nested or recursive data structures. The first argument generates leaves, and the second is a function that creates inner nodes.

```elixir
# Nested lists
data = StreamData.tree(StreamData.integer(), &StreamData.list_of/1)
Enum.at(StreamData.resize(data, 10), 0)
#=> [[], [1, 2], -3, [-7, [10]]]
```

```elixir
# Binary tree structure
defmodule Branch do
  defstruct [:left, :right]
end

tree_data = StreamData.tree(StreamData.integer(), fn child_data ->
  StreamData.map({child_data, child_data}, fn {left, right} ->
    %Branch{left: left, right: right}
  end)
end)

Enum.at(StreamData.resize(tree_data, 10), 0)
#=> %Branch{left: %Branch{left: 4, right: -1}, right: -2}
```

```elixir
# JSON-like structure
scalar_gen = StreamData.one_of([
  StreamData.integer(),
  StreamData.boolean(),
  StreamData.string(:ascii),
  StreamData.constant(nil)
])

json_gen = StreamData.tree(scalar_gen, fn nested ->
  StreamData.one_of([
    StreamData.list_of(nested),
    StreamData.map_of(StreamData.string(:ascii, min_length: 1), nested)
  ])
end)
```

--------------------------------

### Constrain enumerables to be non-empty

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.nonempty/1` to ensure that generated enumerables (like lists) are never empty.

```elixir
Enum.take(StreamData.nonempty(StreamData.list_of(StreamData.integer())), 3)
#=> [[1], [-1, 0], [2, 1, -2]]
```

--------------------------------

### Generate Atoms with StreamData

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Generates atoms of specified kind: :alphanumeric or :alias. Alphanumeric atoms are valid Elixir identifiers.

```elixir
Enum.take(StreamData.atom(:alphanumeric), 3)
#=> [:xF, :y, :B_]
```

```elixir
Enum.take(StreamData.atom(:alias), 3)
#=> [Foo, Bar.Baz, A.B.C]
```

--------------------------------

### Filter generated values

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Use `StreamData.filter/3` to exclude values that do not satisfy a given predicate. Use this sparingly to avoid `FilterTooNarrowError`.

```elixir
# Filter non-zero integers
non_zero = StreamData.filter(StreamData.integer(), &(&1 != 0))
Enum.take(non_zero, 5)
#=> [1, -1, 3, -2, 5]
```

```elixir
# Better approach: transform instead of filter for even numbers
even_integers = StreamData.map(StreamData.integer(), &(&1 * 2))
Enum.take(even_integers, 3)
#=> [2, -2, 6]
```

--------------------------------

### StreamData Generator Modifiers

Source: https://context7.com/whatyouhide/stream_data/llms.txt

Functions to modify the size and behavior of generators.

```APIDOC
## StreamData.resize/2

### Description
Fixes the generation size to a specific value.

### Parameters
- **generator** (generator) - Required - The source generator.
- **size** (integer) - Required - The size to fix.

## StreamData.sized/1

### Description
Creates a generator that receives the current size as a parameter.

### Parameters
- **generator_function** (function) - Required - A function that takes size and returns a generator.
```
Tokens:
Raw