Struct Rng 

pub struct Rng { /* private fields */ }

Seeded RNG wrapper for deterministic generation

Implementations

impl Rng

pub fn new(seed: u64) -> Self

Examples found in repository

examples/bsp_analysis.rs (line 10)

fn main() {
    println!("=== BSP Algorithm Analysis ===\n");

    let mut grid = Grid::new(40, 30);
    algorithms::get("bsp").unwrap().generate(&mut grid, 12345);

    let extractor = SemanticExtractor::for_rooms();
    let mut rng = Rng::new(12345);
    let semantic = extractor.extract(&grid, &mut rng);

    println!("Generated map analysis:");
    println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
    println!("  Total regions: {}", semantic.regions.len());

    println!("\nRegion breakdown:");
    let mut region_counts = std::collections::HashMap::new();
    for region in &semantic.regions {
        *region_counts.entry(&region.kind).or_insert(0) += 1;
    }

    for (kind, count) in &region_counts {
        println!("  {}: {}", kind, count);
    }

    println!("\nMarker breakdown:");
    let mut marker_counts = std::collections::HashMap::new();
    for marker in &semantic.markers {
        *marker_counts.entry(marker.tag()).or_insert(0) += 1;
    }

    for (tag, count) in &marker_counts {
        println!("  {}: {}", tag, count);
    }
}

examples/phase1_demo.rs (line 23)

fn demo_hierarchical_markers() {
    println!("🎯 Demo 1: Hierarchical Marker Types");

    let mut grid = Grid::new(40, 30);
    algorithms::get("bsp").unwrap().generate(&mut grid, 12345);

    let extractor = SemanticExtractor::for_rooms();
    let mut rng = Rng::new(12345);
    let mut semantic = extractor.extract(&grid, &mut rng);

    // Add hierarchical markers manually for demo
    if let Some(region) = semantic.regions.first() {
        let (x, y) = region.cells[0];

        // Quest markers
        semantic.markers.push(Marker::new(
            x,
            y,
            MarkerType::QuestObjective { priority: 1 },
        ));
        semantic
            .markers
            .push(Marker::new(x + 2, y, MarkerType::QuestStart));

        // Loot markers
        semantic
            .markers
            .push(Marker::new(x, y + 2, MarkerType::LootTier { tier: 3 }));
        semantic
            .markers
            .push(Marker::new(x + 1, y + 2, MarkerType::Treasure));

        // Encounter zones
        semantic.markers.push(Marker::new(
            x + 3,
            y + 1,
            MarkerType::EncounterZone { difficulty: 5 },
        ));
        semantic
            .markers
            .push(Marker::new(x + 4, y + 1, MarkerType::BossRoom));
    }

    // Show marker categories
    let mut categories = std::collections::HashMap::new();
    for marker in &semantic.markers {
        *categories.entry(marker.marker_type.category()).or_insert(0) += 1;
    }

    for (category, count) in categories {
        println!("  {} markers: {}", category, count);
    }

    println!("  Sample markers:");
    for marker in semantic.markers.iter().take(3) {
        println!("    {} at ({}, {})", marker.tag(), marker.x, marker.y);
    }
    println!();
}

examples/phase2_demo.rs (line 21)

fn demo_conditional_pipeline() {
    println!("🔀 Demo 1: Conditional Pipeline Operations");

    let mut grid = Grid::new(30, 20);
    let mut context = PipelineContext::new();
    let mut rng = Rng::new(12345);

    // Create conditional pipeline
    let mut pipeline = ConditionalPipeline::new();

    // Add algorithm operation
    pipeline.add_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
        name: "bsp".to_string(),
        seed: Some(12345),
    }));

    // Add conditional operation based on floor density
    pipeline.add_operation(ConditionalOperation::conditional(
        PipelineOperation::Log {
            message: "Evaluating floor density".to_string(),
        },
        PipelineCondition::Density {
            min: Some(0.2),
            max: Some(0.6),
        },
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "density_status".to_string(),
                value: "acceptable".to_string(),
            },
        )],
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "density_status".to_string(),
                value: "out_of_range".to_string(),
            },
        )],
    ));

    // Execute pipeline
    let result = pipeline.execute(&mut grid, &mut context, &mut rng);

    println!(
        "  Pipeline execution: {}",
        if result.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    if let Some(msg) = result.message {
        println!("  Message: {}", msg);
    }

    println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
    println!(
        "  Density status: {}",
        context
            .get_parameter("density_status")
            .unwrap_or(&"unknown".to_string())
    );
    println!("  Execution log: {:?}", context.execution_history());
    println!();
}

fn demo_pipeline_templates() {
    println!("📋 Demo 2: Pipeline Templates");

    // Create custom template
    let template = PipelineTemplate::new("custom_dungeon", "Customizable dungeon template")
        .with_parameter("algorithm", "cellular")
        .with_parameter("seed", "54321")
        .with_parameter("type", "dungeon")
        .with_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
            name: "{algorithm}".to_string(),
            seed: Some(54321),
        }))
        .with_operation(ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "generation_type".to_string(),
                value: "{type}".to_string(),
            },
        ));

    // Instantiate with custom parameters
    let mut custom_params = std::collections::HashMap::new();
    custom_params.insert("algorithm".to_string(), "bsp".to_string());
    custom_params.insert("type".to_string(), "fortress".to_string());

    let pipeline = template.instantiate(Some(custom_params));

    let mut grid = Grid::new(25, 25);
    let mut context = PipelineContext::new();
    let mut rng = Rng::new(98765);

    let result = pipeline.execute(&mut grid, &mut context, &mut rng);

    println!("  Template: {}", template.name);
    println!("  Description: {}", template.description);
    println!(
        "  Execution: {}",
        if result.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!(
        "  Generation type: {}",
        context
            .get_parameter("generation_type")
            .unwrap_or(&"unknown".to_string())
    );
    println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
    println!();
}

fn demo_template_library() {
    println!("📚 Demo 3: Template Library");

    let library = TemplateLibrary::new();

    println!("  Available templates:");
    for name in library.template_names() {
        if let Some(template) = library.get_template(name) {
            println!("    - {}: {}", name, template.description);
        }
    }

    // Use built-in template
    if let Some(template) = library.get_template("simple_dungeon") {
        let pipeline = template.instantiate(None);

        let mut grid = Grid::new(40, 30);
        let mut context = PipelineContext::new();
        let mut rng = Rng::new(11111);

        let result = pipeline.execute(&mut grid, &mut context, &mut rng);

        println!("\n  Executed 'simple_dungeon' template:");
        println!(
            "    Result: {}",
            if result.success {
                "✅ Success"
            } else {
                "❌ Failed"
            }
        );
        println!("    Floor tiles: {}", grid.count(|t| t.is_floor()));
        println!("    Steps executed: {}", context.execution_history().len());
    }
    println!();
}

examples/hierarchical_markers.rs (line 11)

fn main() {
    println!("=== Hierarchical Marker Types Demo ===\n");

    // Generate a basic dungeon
    let mut grid = Grid::new(30, 20);
    algorithms::get("bsp").unwrap().generate(&mut grid, 12345);

    let extractor = SemanticExtractor::for_rooms();
    let mut rng = Rng::new(12345);
    let mut semantic = extractor.extract(&grid, &mut rng);

    // Add hierarchical markers
    if let Some(region) = semantic.regions.first() {
        let (x, y) = region.cells[0];

        // Quest markers with priorities
        semantic.markers.push(Marker::new(
            x,
            y,
            MarkerType::QuestObjective { priority: 1 },
        ));
        semantic.markers.push(Marker::new(
            x + 2,
            y,
            MarkerType::QuestObjective { priority: 3 },
        ));
        semantic
            .markers
            .push(Marker::new(x + 4, y, MarkerType::QuestStart));

        // Loot with different tiers
        semantic
            .markers
            .push(Marker::new(x, y + 2, MarkerType::LootTier { tier: 1 }));
        semantic
            .markers
            .push(Marker::new(x + 2, y + 2, MarkerType::LootTier { tier: 3 }));
        semantic
            .markers
            .push(Marker::new(x + 4, y + 2, MarkerType::Treasure));

        // Encounter zones
        semantic.markers.push(Marker::new(
            x,
            y + 4,
            MarkerType::EncounterZone { difficulty: 2 },
        ));
        semantic
            .markers
            .push(Marker::new(x + 2, y + 4, MarkerType::BossRoom));
        semantic
            .markers
            .push(Marker::new(x + 4, y + 4, MarkerType::SafeZone));
    }

    // Show marker categories and types
    println!("Generated {} markers:", semantic.markers.len());
    for marker in &semantic.markers {
        println!(
            "  {} at ({}, {}) - Category: {}",
            marker.tag(),
            marker.x,
            marker.y,
            marker.marker_type.category()
        );
    }

    // Group by category
    let mut categories = std::collections::HashMap::new();
    for marker in &semantic.markers {
        *categories.entry(marker.marker_type.category()).or_insert(0) += 1;
    }

    println!("\nMarker distribution:");
    for (category, count) in categories {
        println!("  {}: {} markers", category, count);
    }
}

examples/conditional_pipelines.rs (line 48)

fn main() {
    println!("=== Conditional Pipeline Demo ===\n");

    // Demo 1: Simple conditional pipeline
    println!("1. Density-Based Conditional Pipeline:");

    let mut pipeline = ConditionalPipeline::new();

    // Generate initial map
    pipeline.add_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
        name: "cellular".to_string(),
        seed: Some(12345),
    }));

    // Check density and apply different effects
    pipeline.add_operation(ConditionalOperation::conditional(
        PipelineOperation::Log {
            message: "Checking density".to_string(),
        },
        PipelineCondition::Density {
            min: Some(0.3),
            max: Some(0.7),
        },
        vec![
            ConditionalOperation::simple(PipelineOperation::SetParameter {
                key: "quality".to_string(),
                value: "good".to_string(),
            }),
            ConditionalOperation::simple(PipelineOperation::Log {
                message: "Density is acceptable".to_string(),
            }),
        ],
        vec![
            ConditionalOperation::simple(PipelineOperation::SetParameter {
                key: "quality".to_string(),
                value: "poor".to_string(),
            }),
            ConditionalOperation::simple(PipelineOperation::Log {
                message: "Density needs adjustment".to_string(),
            }),
        ],
    ));

    let mut grid = Grid::new(40, 30);
    let mut context = PipelineContext::new();
    let mut rng = Rng::new(12345);

    let result = pipeline.execute(&mut grid, &mut context, &mut rng);

    println!(
        "  Result: {}",
        if result.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!("  Floor tiles: {}", grid.count(|t| t.is_floor()));
    println!(
        "  Quality assessment: {}",
        context
            .get_parameter("quality")
            .unwrap_or(&"unknown".to_string())
    );
    println!("  Execution steps: {}", context.execution_history().len());

    // Demo 2: Floor count conditional
    println!("\n2. Floor Count Conditional Pipeline:");

    let mut pipeline2 = ConditionalPipeline::new();

    pipeline2.add_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
        name: "bsp".to_string(),
        seed: Some(54321),
    }));

    pipeline2.add_operation(ConditionalOperation::conditional(
        PipelineOperation::Log {
            message: "Evaluating floor count".to_string(),
        },
        PipelineCondition::FloorCount {
            min: Some(100),
            max: Some(500),
        },
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "size_category".to_string(),
                value: "medium".to_string(),
            },
        )],
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "size_category".to_string(),
                value: "large_or_small".to_string(),
            },
        )],
    ));

    let mut grid2 = Grid::new(35, 25);
    let mut context2 = PipelineContext::new();
    let mut rng2 = Rng::new(54321);

    let result2 = pipeline2.execute(&mut grid2, &mut context2, &mut rng2);

    println!(
        "  Result: {}",
        if result2.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!("  Floor tiles: {}", grid2.count(|t| t.is_floor()));
    println!(
        "  Size category: {}",
        context2
            .get_parameter("size_category")
            .unwrap_or(&"unknown".to_string())
    );

    println!("\n  Execution log:");
    for (i, step) in context2.execution_history().iter().enumerate() {
        println!("    {}. {}", i + 1, step);
    }
}

examples/pipeline_templates.rs (line 23)

fn main() {
    println!("=== Pipeline Templates Demo ===\n");

    // Demo 1: Using built-in templates
    println!("1. Built-in Template Library:");

    let library = TemplateLibrary::new();
    println!("  Available templates:");
    for name in library.template_names() {
        if let Some(template) = library.get_template(name) {
            println!("    - {}: {}", name, template.description);
        }
    }

    // Use the simple_dungeon template
    if let Some(template) = library.get_template("simple_dungeon") {
        let pipeline = template.instantiate(None);

        let mut grid = Grid::new(40, 30);
        let mut context = PipelineContext::new();
        let mut rng = Rng::new(11111);

        let result = pipeline.execute(&mut grid, &mut context, &mut rng);

        println!("\n  Executed 'simple_dungeon' template:");
        println!(
            "    Result: {}",
            if result.success {
                "✅ Success"
            } else {
                "❌ Failed"
            }
        );
        println!("    Floor tiles: {}", grid.count(|t| t.is_floor()));
        println!("    Steps executed: {}", context.execution_history().len());
    }

    // Demo 2: Custom template with parameters
    println!("\n2. Custom Parameterized Template:");

    let custom_template = PipelineTemplate::new(
        "adaptive_dungeon",
        "Dungeon that adapts based on size parameter",
    )
    .with_parameter("size", "medium")
    .with_parameter("algorithm", "bsp")
    .with_parameter("complexity", "normal")
    .with_operation(ConditionalOperation::simple(PipelineOperation::Log {
        message: "Generating {size} dungeon with {algorithm}".to_string(),
    }))
    .with_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
        name: "{algorithm}".to_string(),
        seed: Some(22222),
    }))
    .with_operation(ConditionalOperation::simple(
        PipelineOperation::SetParameter {
            key: "dungeon_type".to_string(),
            value: "{size}_{complexity}".to_string(),
        },
    ));

    // Instantiate with default parameters
    println!("  Default parameters:");
    let pipeline1 = custom_template.instantiate(None);
    let mut grid1 = Grid::new(30, 20);
    let mut context1 = PipelineContext::new();
    let mut rng1 = Rng::new(22222);

    let result1 = pipeline1.execute(&mut grid1, &mut context1, &mut rng1);
    println!(
        "    Result: {}",
        if result1.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!(
        "    Dungeon type: {}",
        context1
            .get_parameter("dungeon_type")
            .unwrap_or(&"unknown".to_string())
    );

    // Instantiate with custom parameters
    println!("  Custom parameters:");
    let mut custom_params = std::collections::HashMap::new();
    custom_params.insert("size".to_string(), "large".to_string());
    custom_params.insert("algorithm".to_string(), "cellular".to_string());
    custom_params.insert("complexity".to_string(), "high".to_string());

    let pipeline2 = custom_template.instantiate(Some(custom_params));
    let mut grid2 = Grid::new(50, 40);
    let mut context2 = PipelineContext::new();
    let mut rng2 = Rng::new(33333);

    let result2 = pipeline2.execute(&mut grid2, &mut context2, &mut rng2);
    println!(
        "    Result: {}",
        if result2.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!(
        "    Dungeon type: {}",
        context2
            .get_parameter("dungeon_type")
            .unwrap_or(&"unknown".to_string())
    );
    println!("    Floor tiles: {}", grid2.count(|t| t.is_floor()));

    // Demo 3: Template with conditional logic
    println!("\n3. Template with Conditional Logic:");

    let smart_template = PipelineTemplate::new(
        "smart_generator",
        "Generator that chooses algorithm based on size",
    )
    .with_parameter("width", "40")
    .with_parameter("height", "30")
    .with_operation(ConditionalOperation::simple(PipelineOperation::Algorithm {
        name: "bsp".to_string(),
        seed: Some(44444),
    }))
    .with_operation(ConditionalOperation::conditional(
        PipelineOperation::Log {
            message: "Analyzing generated map".to_string(),
        },
        PipelineCondition::Density {
            min: Some(0.2),
            max: Some(0.6),
        },
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "analysis".to_string(),
                value: "optimal_density".to_string(),
            },
        )],
        vec![ConditionalOperation::simple(
            PipelineOperation::SetParameter {
                key: "analysis".to_string(),
                value: "suboptimal_density".to_string(),
            },
        )],
    ));

    let pipeline3 = smart_template.instantiate(None);
    let mut grid3 = Grid::new(40, 30);
    let mut context3 = PipelineContext::new();
    let mut rng3 = Rng::new(44444);

    let result3 = pipeline3.execute(&mut grid3, &mut context3, &mut rng3);
    println!(
        "  Result: {}",
        if result3.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!(
        "  Analysis: {}",
        context3
            .get_parameter("analysis")
            .unwrap_or(&"unknown".to_string())
    );
    println!(
        "  Density: {:.2}",
        grid3.count(|t| t.is_floor()) as f32 / (grid3.width() * grid3.height()) as f32
    );
}

Additional examples can be found in:

• examples/advanced_prefabs.rs
• examples/complete_workflow.rs

pub fn range(&mut self, min: i32, max: i32) -> i32

pub fn range_usize(&mut self, min: usize, max: usize) -> usize

pub fn random(&mut self) -> f64

Examples found in repository

examples/complete_workflow.rs (line 152)

fn main() {
    println!("=== Complete Phase 1 & 2 Feature Demo ===\n");

    // Demo: Complete workflow using all new features
    println!("🏰 Generating Advanced Multi-Feature Dungeon\n");

    // Step 1: Use pipeline template with custom parameters
    println!("1. Pipeline Template Generation:");
    let library = TemplateLibrary::new();
    let template = library.get_template("simple_dungeon").unwrap();

    let mut custom_params = std::collections::HashMap::new();
    custom_params.insert("seed".to_string(), "12345".to_string());

    let pipeline = template.instantiate(Some(custom_params));

    let mut grid = Grid::new(40, 30);
    let mut context = PipelineContext::new();
    let mut rng = Rng::new(12345);

    let result = pipeline.execute(&mut grid, &mut context, &mut rng);
    println!(
        "   Template execution: {}",
        if result.success {
            "✅ Success"
        } else {
            "❌ Failed"
        }
    );
    println!("   Floor tiles: {}", grid.count(|t| t.is_floor()));

    // Step 2: Extract semantic information
    println!("\n2. Semantic Analysis:");
    let extractor = SemanticExtractor::for_rooms();
    let mut semantic = extractor.extract(&grid, &mut rng);

    println!("   Regions found: {}", semantic.regions.len());
    println!("   Original markers: {}", semantic.markers.len());

    // Step 3: Add hierarchical markers based on regions
    println!("\n3. Hierarchical Marker Placement:");
    let mut quest_count = 0;
    let mut loot_count = 0;
    let mut encounter_count = 0;

    for (i, region) in semantic.regions.iter().enumerate() {
        if !region.cells.is_empty() {
            let (x, y) = region.cells[region.cells.len() / 2]; // Middle of region

            match i % 3 {
                0 => {
                    // Quest area
                    semantic.markers.push(Marker::new(
                        x,
                        y,
                        MarkerType::QuestObjective {
                            priority: (i % 3 + 1) as u8,
                        },
                    ));
                    quest_count += 1;
                }
                1 => {
                    // Loot area
                    semantic.markers.push(Marker::new(
                        x,
                        y,
                        MarkerType::LootTier {
                            tier: (i % 3 + 1) as u8,
                        },
                    ));
                    loot_count += 1;
                }
                2 => {
                    // Encounter area
                    if i == 2 {
                        semantic
                            .markers
                            .push(Marker::new(x, y, MarkerType::BossRoom));
                    } else {
                        semantic.markers.push(Marker::new(
                            x,
                            y,
                            MarkerType::EncounterZone {
                                difficulty: (i % 5 + 1) as u8,
                            },
                        ));
                    }
                    encounter_count += 1;
                }
                _ => {}
            }
        }
    }

    println!("   Added {} quest markers", quest_count);
    println!("   Added {} loot markers", loot_count);
    println!("   Added {} encounter markers", encounter_count);

    // Step 4: Validate with requirements
    println!("\n4. Requirement Validation:");
    let mut requirements = SemanticRequirements::none();
    requirements.min_regions.insert("Hall".to_string(), 1);
    requirements
        .required_markers
        .insert(MarkerType::Custom("PlayerStart".to_string()), 1);

    let validation_result = requirements.validate(&semantic);
    println!(
        "   Requirements met: {}",
        if validation_result {
            "✅ Yes"
        } else {
            "❌ No"
        }
    );

    // Step 5: Marker constraints analysis
    println!("\n5. Marker Constraint Analysis:");
    let quest_constraints = MarkerConstraints::quest_objective();
    let loot_constraints = MarkerConstraints::loot();

    println!("   Quest marker constraints:");
    println!(
        "     Min distance (same type): {:?}",
        quest_constraints.min_distance_same
    );
    println!(
        "     Excluded types: {} types",
        quest_constraints.exclude_types.len()
    );

    println!("   Loot marker constraints:");
    println!(
        "     Min distance (same type): {:?}",
        loot_constraints.min_distance_same
    );
    println!(
        "     Min distance (any): {:?}",
        loot_constraints.min_distance_any
    );

    // Step 6: Multi-floor connectivity simulation
    println!("\n6. Multi-Floor Connectivity:");

    // Create a second floor based on the first
    let mut floor2 = Grid::new(40, 30);
    // Copy some areas from floor 1 to create overlapping regions
    for y in 5..25 {
        for x in 5..35 {
            if grid.get(x, y).is_some_and(|t| t.is_floor()) && rng.random() < 0.6 {
                floor2.set(x, y, terrain_forge::Tile::Floor);
            }
        }
    }

    let floors = vec![grid.clone(), floor2];
    let mut connectivity = VerticalConnectivity::new();

    connectivity.analyze_stair_candidates(&floors, 2);
    connectivity.place_stairs(3);

    println!("   Floor 1 tiles: {}", floors[0].count(|t| t.is_floor()));
    println!("   Floor 2 tiles: {}", floors[1].count(|t| t.is_floor()));
    println!(
        "   Stair candidates: {}",
        connectivity.stair_candidates.len()
    );
    println!("   Stairs placed: {}", connectivity.stairs.len());

    // Step 7: Final summary
    println!("\n🎯 Generation Summary:");
    println!("   Grid size: {}x{}", grid.width(), grid.height());
    println!("   Total floor area: {}", grid.count(|t| t.is_floor()));
    println!(
        "   Density: {:.1}%",
        (grid.count(|t| t.is_floor()) as f32 / (grid.width() * grid.height()) as f32) * 100.0
    );
    println!("   Regions: {}", semantic.regions.len());
    println!("   Total markers: {}", semantic.markers.len());

    // Group markers by category
    let mut categories = std::collections::HashMap::new();
    for marker in &semantic.markers {
        *categories.entry(marker.marker_type.category()).or_insert(0) += 1;
    }

    println!("   Marker distribution:");
    for (category, count) in categories {
        println!("     {}: {}", category, count);
    }

    println!(
        "   Pipeline steps executed: {}",
        context.execution_history().len()
    );
    println!("   Multi-floor stairs: {}", connectivity.stairs.len());

    println!("\n✨ Advanced dungeon generation complete!");
}

pub fn next_u64(&mut self) -> u64

pub fn chance(&mut self, probability: f64) -> bool

pub fn pick<'a, T>(&mut self, slice: &'a [T]) -> Option<&'a T>

pub fn shuffle<T>(&mut self, slice: &mut [T])