Learning Rust - Strategy Pattern

2026-07-20T00:00:00+00:00

Disclaimer</h2>
I am not a Rust developer. I am probably doing several things either poorly or not idiomatically. Don’t use this to learn Rust, but it’s probably a reasonable use of the strategy pattern in general.</p>
All code referenced in this post available at this repo</a></p>

Pixel Swapping</h1>
Several years ago I ran across this problem</a> on the code golf stack exchange and it has stuck with me as an interesting problem. I come back to it now and then as a nontrivial problem to use as a basis for learning new language features. It’s particularly interesting because there is no “right” answer, and lots of ways to try to solve it.</p>
The core idea is that we want to take the pixels from picture A and use them to make picture B. As an example, using Starry Night to create Mona Lisa can be done like this: </p>

Strategies</h1>

The Default Strategy</h2>
Let’s see where the lowest-effort strategy gets us. Start at the upper left pixel, iterate over each pixel in order, find the closest pixel in our source palette, place the pixel and remove it from the source palette.</p>
</p>
Not great. We can do better.</p>

Center-Out Strategy</h2>
The middle of the image is probably the most important to get right. Instead of starting in the upper left, just start in the middle and work outward.</p>
</p>
Better, but what else can we try?</p>

Single Shuffle Strategy</h2>
Don’t prioritize any specific part of the picture. Just shuffle the pixels and fill in the best match from the palette and hope that it works out.</p>
</p>
Different, probably better for this particular set of inputs at least.</p>

Repeated Random Substitution Strategy</h2>
Finding the best pixel choice from a palette for a given goal RGB value is slow. What if we just try picking two random pixels and switching them if it brings the overall RGB values closer to the goal, and do that like a whole bunch of times?</p>
</p>
For some sets of inputs, this ends up better than the single shuffle. For some sets of inputs, it ends up worse.</p>

Using the strategies</h1>
Which should we use, then?</p>
All of them! Or, implement them all and pick out which to use at runtime rather than compile time. It’s a user problem if they pick the wrong tool for the job.</p>

MapStrategy trait</h2>

We will be making use of a MappedPixel struct, which contains the source coordinates, destination coordinates, and colors.</p>

First, make a trait that requires a struct to implement a function that takes in an image as a source and an image as a destination, and returns a vector of MappedPixel. How that is implemented is irrelevant, as long as we get a populated vector back.</p>

pub trait</span> MapStrategy</span> {</span></span>
    fn</span> map_pixels</span>(</span>source</span>: &</span>RgbaImage</span>,</span> destination</span>: &</span>RgbaImage</span>)</span> -></span> Vec</span><</span>MappedPixel</span>></span>;</span></span>
}</span></span></code></pre>
Create a struct for the strategy that we want to implement and implement the trait.</p>
pub struct</span> ShuffleStrategy</span>;</span></span>
</span>
impl super</span>::</span>MapStrategy</span> for</span> ShuffleStrategy</span> {</span></span>
    fn</span> map_pixels</span>(</span>source</span>: &</span>RgbaImage</span>,</span> destination</span>: &</span>RgbaImage</span>)</span> -></span> Vec</span><</span>MappedPixel</span>></span> {</span></span>
        let mut</span> palette</span> =</span> MappedPixel</span>::</span>map_source_pixels</span>(</span>source</span>);</span></span>
        let mut</span> dest_palette</span> =</span> MappedPixel</span>::</span>map_source_pixels</span>(</span>destination</span>);</span></span>
        dest_palette</span>.</span>shuffle</span>(</span>&</span>mut</span> thread_rng</span>());</span></span>
</span>
        dest_palette</span>.</span>iter</span>()</span>.</span>for_each</span>(</span>|</span>x</span>|</span> {</span></span>
            let</span> index</span> =</span> MappedPixel</span>::</span>find_closest_pixel</span>(</span>&</span>x</span>,</span> &</span>palette</span>);</span></span>
            palette</span>[</span>index</span>]</span>.</span>dest_x </span>=</span> x</span>.</span>src_x</span>;</span></span>
            palette</span>[</span>index</span>]</span>.</span>dest_y </span>=</span> x</span>.</span>src_y</span>;</span></span>
            palette</span>[</span>index</span>]</span>.</span>used </span>=</span> true</span>;</span></span>
        });</span></span>
</span>
        return</span> palette</span>;</span></span>
    }</span></span>
}</span></span></code></pre>Create a Mapper struct</h2>
This feels</em> like I should be able to do something like pub struct PixelMapper<T:MapStrategy></code> or something, but I could not for the life of me get the compiler to agree so maybe someone can email me the correct way to do this. I just powered through.</p>
I created a struct that just had a string field for the name that we will call as a command line argument and the function that we’ll call to execute the mapping strategy.</p>
pub struct</span> PixelMapper</span> {</span></span>
    pub</span> name</span>:</span> String</span>,</span></span>
    pub</span> map_strategy</span>:</span> fn</span>(</span>&</span>RgbaImage</span>,</span> &</span>RgbaImage</span>)</span> -></span> Vec</span><</span>MappedPixel</span>></span>,</span></span>
}</span></span>
impl</span> PixelMapper</span> {</span></span>
    pub fn</span> new</span>(</span>name</span>:</span> String</span>,</span> map_strategy</span>:</span> fn</span>(</span>&</span>RgbaImage</span>,</span> &</span>RgbaImage</span>)</span> -></span> Vec</span><</span>MappedPixel</span>></span>)</span> -></span> Self</span> {</span></span>
        Self</span> {</span> name</span>,</span> map_strategy</span> }</span></span>
    }</span></span>
}</span></span></code></pre>Initialize the strategy options</h2>
Create a function that initializes all of the strategies that we have available to use. Give the strategy a name and a reference to the function to call. The list is shortened for readability.</p>
fn</span> initialize_strategies</span>()</span> -></span> Vec</span><</span>PixelMapper</span>></span> {</span></span>
    let mut</span> strategies</span> =</span> Vec</span>::</span>new</span>();</span></span>
    strategies</span>.</span>push</span>(</span>PixelMapper</span>::</span>new</span>(</span></span>
        "default"</span>.</span>to_string</span>(),</span></span>
        DefaultStrategy</span>::</span>map_pixels</span>,</span></span>
    ));</span></span>
    strategies</span>.</span>push</span>(</span>PixelMapper</span>::</span>new</span>(</span></span>
        "random"</span>.</span>to_string</span>(),</span></span>
        RandomStrategy</span>::</span>map_pixels</span>,</span></span>
    ));</span></span>
    strategies</span>.</span>push</span>(</span>PixelMapper</span>::</span>new</span>(</span></span>
        "center"</span>.</span>to_string</span>(),</span></span>
        CenterOutStrategy</span>::</span>map_pixels</span>,</span></span>
    ));</span></span>
    //[...]</span></span>
    return</span> strategies</span>;</span></span>
}</span></span></code></pre>Create an execution function</h2>
Create a function that accepts the strategies that we initialized and a key to decide which one to execute, as well as the arguments that will need to be passed on to the chosen function. It returns an Option<Vec<MappedPixel>></code> as it could return None if the key is not found</p>
This is where you can do some logic to decide on the best strategy to implement if not taking it as a user input. For example, you could instead check the size of the images and default to the Repeated Random Substitution strategy over a given size, as the runtime is exponential and larger images take a long time with the other strategies.</p>
fn</span> execute_strategy</span>(</span></span>
    strategy_name</span>: &</span>str</span>,</span></span>
    strategies</span>: &</span>Vec</span><</span>PixelMapper</span>></span>,</span></span>
    source</span>: &</span>RgbaImage</span>,</span></span>
    dest</span>: &</span>RgbaImage</span>,</span></span>
)</span> -></span> Option</span><</span>Vec</span><</span>MappedPixel</span>>></span> {</span></span>
    return match</span> strategies</span>.</span>iter</span>()</span>.</span>find</span>(</span>|</span>x</span>|</span> x</span>.</span>name </span>==</span> strategy_name</span>) {</span></span>
        Some</span>(</span>x</span>)</span> =></span> Some</span>((</span>x</span>.</span>map_strategy</span>)(</span>source</span>,</span> dest</span>)),</span></span>
        None</span> =></span> None</span>,</span></span>
    };</span></span>
}</span></span></code></pre>Finally, use it</h2>
With all of these pieces in place, the main function is relatively small. The first half is just parsing the arguments and loading the images. We then just take the images and arguments and pass them off to the execution function.</p>
    match</span> execute_strategy</span>(</span>strategy_name</span>,</span> &</span>strategies</span>,</span> &</span>source_img</span>,</span> &</span>dest_img</span>) {</span></span>
        Some</span>(</span>mut</span> x</span>)</span> =></span> MappedPixel</span>::</span>save</span>(</span></span>
            &</span>dest_img</span>.</span>width</span>(),</span></span>
            &</span>dest_img</span>.</span>height</span>(),</span></span>
            &</span>mut</span> x</span>,</span></span>
            format!</span>(</span>"output/</span>{</span>0</span>}</span>.png"</span>,</span> strategy_name</span>),</span></span>
        ),</span></span>
        None</span> =></span> {</span></span>
            let</span> names</span>:</span> Vec</span><</span>String</span>></span> =</span> strategies</span>.</span>iter</span>()</span>.</span>map</span>(</span>|</span>x</span>|</span> x</span>.</span>name</span>.</span>clone</span>())</span>.</span>collect</span>();</span></span>
            println!</span>(</span>"Strategy options are: </span>{</span>:?</span>}</span>"</span>,</span> names</span>.</span>join</span>(</span>", "</span>));</span></span>
            return</span>;</span></span>
        }</span></span>
    }</span></span></code></pre>
As a very useful side effect of having the strategies collected into one vector, we can provide the user with an error message telling what the available strategies are.</p>
❯ cargo run images/starrynight.png images/monalisa.png outside</span></span>
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s</span></span>
     Running `target/debug/pixel_swap images/starrynight.png images/monalisa.png outside`</span></span>
Strategy options are: "default, random, center, green, shuffle"</span></span></code></pre>

Ox's Blog - Rust

Learning Rust - Strategy Pattern

Disclaimer</h2> I am not a Rust developer. I am probably doing several things either poorly or not idiomatically. Don’t use this to learn Rust, but it’s probably a reasonable use of the strategy pattern in general.</p> All code referenced in this post available at this repo</a></p>

The Default Strategy</h2> Let’s see where the lowest-effort strategy gets us. Start at the upper left pixel, iterate over each pixel in order, find the closest pixel in our source palette, place the pixel and remove it from the source palette.</p> </p> Not great. We can do better.</p>

Center-Out Strategy</h2> The middle of the image is probably the most important to get right. Instead of starting in the upper left, just start in the middle and work outward.</p> </p> Better, but what else can we try?</p>

Single Shuffle Strategy</h2> Don’t prioritize any specific part of the picture. Just shuffle the pixels and fill in the best match from the palette and hope that it works out.</p> </p> Different, probably better for this particular set of inputs at least.</p>

Using the strategies</h1> Which should we use, then?</p> All of them! Or, implement them all and pick out which to use at runtime rather than compile time. It’s a user problem if they pick the wrong tool for the job.</p>

Disclaimer</h2>
I am not a Rust developer. I am probably doing several things either poorly or not idiomatically. Don’t use this to learn Rust, but it’s probably a reasonable use of the strategy pattern in general.</p>
All code referenced in this post available at this repo</a></p>

The Default Strategy</h2>
Let’s see where the lowest-effort strategy gets us. Start at the upper left pixel, iterate over each pixel in order, find the closest pixel in our source palette, place the pixel and remove it from the source palette.</p>
</p>
Not great. We can do better.</p>

Center-Out Strategy</h2>
The middle of the image is probably the most important to get right. Instead of starting in the upper left, just start in the middle and work outward.</p>
</p>
Better, but what else can we try?</p>

Single Shuffle Strategy</h2>
Don’t prioritize any specific part of the picture. Just shuffle the pixels and fill in the best match from the palette and hope that it works out.</p>
</p>
Different, probably better for this particular set of inputs at least.</p>

Using the strategies</h1>
Which should we use, then?</p>
All of them! Or, implement them all and pick out which to use at runtime rather than compile time. It’s a user problem if they pick the wrong tool for the job.</p>