Extension</th>	Reason</th></tr></thead>
`ctype, iconv, json, tokenizer, xml</code></td>`	`composer check-platform-reqs</code> output</td></tr>`
`filter</code></td>`	used in `Symfony\Component\Runtime</code></td></tr>`
`mbstring</code></td>`	used in Symfony\Component\Console</code></td></tr> </tbody></table> Note: json</code> is always compiled into PHP 8+ and does not need to be listed in PHP_EXTENSIONS</code>.</p> Build and extract the standalone binary</h2> Build:</p> docker</span> build</span> -</span>t</span> hello-world-app</span> -</span>f</span> static-build.Dockerfile</span> .</span></span></code></pre> Copy the binary out of the container:</p> docker</span> cp</span> $(</span>docker</span> create</span> -</span>-name</span> hello-world-tmp</span> hello-world-app</span>)</span>:/go/src/app/dist/frankenphp-linux-x86_64</span> ./hello-world</span></span> docker</span> rm</span> hello-world-tmp</span></span></code></pre>Notes on the copy step</h3> docker create --name hello-world-tmp hello-world-app</code>: creates a container from the hello-world-app</code> image without starting it. If you re-run this step, remove the container first: docker rm hello-world-tmp</code>.</li> $(...)</code>: command substitution; the output of docker create</code> (the container ID) is passed directly to docker cp</code>.</li> docker cp <container>:/go/src/app/dist/frankenphp-linux-x86_64 ./hello-world</code>: copies the binary out of the container.</li> </ul> Run the Standalone Binary</h2> ./hello-world</span> php-cli</span> bin/console</span> app:hello-world</span></span></code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.</p>

Elfennol - Blog - dev

Why Rust Replaced Null with Option

2026-07-04T00:00:00+00:00

Rust has no null. It uses an enum instead: Option</code>. Is it 100% better, 100% safe, 100% secure, 100% (insert your most memorable buzzword here)? OK, stop. WHY?

The core idea: Option</code> forces you to handle the absence of a value at compile time, instead of discovering it as a crash at runtime.

Full disclosure, though:

let</span> foo</span>:</span> Option</span><</span>i32</span>></span> =</span> None</span>;</span></span>
foo</span>.</span>unwrap</span>(</span>)</span>;</span></span>
//</span> or foo.expect("foo is Some"); both panic at runtime</span></span></code></pre>

Compilation: ✅ success</li>
Execution: ❌ failed</li>
</ul>
Oops. unwrap</code> and expect</code> bypass the guarantee. Treat them as code smells, not everyday tools. A linter can flag them. The sections below show the right way.</p>
What is Rust's Option type?</h2>
Option</code> is defined by:</p>
enum</span> Option</span><</span>T</span>></span> {</span></span>
    None</span>,</span></span>
    Some</span>(</span>T</span>)</span>,</span></span>
}</span></span></code></pre>
Simple.</p>
Why use Option?</h2>
An example:</p>
struct</span> Product</span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    image</span>:</span> Option</span><</span>String</span>></span></span>
}</span></span>
</span>
let</span> foo</span> =</span> Product</span> {</span></span>
    name</span>:</span> "</span>Foo</span>"</span>.</span>to_string</span>(</span>)</span>,</span></span>
    image</span>:</span> None</span>,</span></span>
}</span>;</span></span>
</span>
//</span> The trait `std::fmt::Display`</span></span>
//</span> is not implemented for `Option<String>`</span></span>
println!</span>(</span>"</span>{</span>}</span> {</span>}</span>"</span>,</span> foo</span>.</span>name</span>,</span> foo</span>.</span>image</span>)</span>;</span></span></code></pre>

Compilation: ❌ failed</li>
</ul>
Consider an optional value (say, user input) that passes through several layers before reaching a function that accepts no optional types. If the language uses null</code>, the program crashes at runtime; the compiler has no way to distinguish a value from null. With a typed optional instead, the compiler catches the mismatch before the program runs. That single scenario justifies Option</code>.</p>
Get the value</h2>
The match</code> statement forces you to handle all cases:</p>
match</span> foo</span> {</span></span>
    Some</span>(</span>value</span>)</span> =></span> println!</span>(</span>"</span>{</span>value</span>}</span>"</span>)</span>,</span></span>
    None</span> =></span> println!</span>(</span>"</span>no value</span>"</span>)</span>,</span></span>
}</span></span></code></pre>
For a default fallback, use unwrap_or(default)</code> or unwrap_or_else(|| ...)</code>.</p>
To run code only when the value exists:</p>
if</span> let</span> Some</span>(</span>value</span>)</span> =</span> foo</span> {</span></span>
    println!</span>(</span>"</span>{</span>value</span>}</span>"</span>)</span>;</span></span>
}</span></span></code></pre>
In all three cases, you make a deliberate choice: the compiler prevents you from using an Option<T></code> as a plain T</code> without addressing the absent case first.</p>
Synergy with the borrow checker</h2>
What follows goes a step further and is a bit more complex. Some knowledge of C and Rust is helpful.</p>
Let's look at the "copy, then set to null" problem.</p>
C language</h3>
The problem is a trap in C:</p>
#</span>include</span> <</span>stdio.h</span>></span></span>
#</span>include</span> <</span>stdlib.h</span>></span></span>
#</span>include</span> <</span>string.h</span>></span></span>
</span>
struct</span> Hero </span>{</span></span>
    char</span>*</span> name</span>;</span></span>
    //</span> May be NULL if there is no weapon</span></span>
    char</span>*</span> weapon</span>;</span></span>
}</span>;</span></span>
</span>
//</span> Function that “takes” the weapon by setting it to NULL</span></span>
char</span>*</span> take_weapon</span>(</span>struct</span> Hero</span>*</span> hero</span>)</span> {</span></span>
    //</span> 1. We copy the pointer</span></span>
    char</span>*</span> weapon_copy </span>=</span> hero</span>-></span>weapon</span>;</span></span>
    //</span> 2. We set the original to NULL</span></span>
    hero</span>-></span>weapon</span> =</span> NULL</span>;</span></span>
    //</span> 3. We return the copy</span></span>
    return</span> weapon_copy</span>;</span></span>
}</span></span>
</span>
int</span> main</span>(</span>)</span> {</span></span>
    //</span> 1. Bob is created with his weapon</span></span>
    struct</span> Hero bob</span>;</span></span>
    bob</span>.</span>name</span> =</span> "</span>Bob</span>"</span>;</span></span>
    bob</span>.</span>weapon</span> =</span> malloc</span>(</span>20</span>)</span>;</span></span>
    strcpy</span>(</span>bob</span>.</span>weapon</span>,</span> "</span>sword</span>"</span>)</span>;</span></span>
</span>
    //</span> 2. Another module in the game</span></span>
    //</span> (e.g., the inventory display system)</span></span>
    //</span> Keeps a reference to this weapon,</span></span>
    //</span> so it knows what to display on the screen.</span></span>
    char</span>*</span> weapon_inventory </span>=</span> bob</span>.</span>weapon</span>;</span></span>
</span>
    //</span> 3. Later, Bob is disarmed.</span></span>
    //</span> The code uses our function</span></span>
    //</span> and properly sets the pointer to NULL.</span></span>
    char</span>*</span> lost_weapon </span>=</span> take_weapon</span>(</span>&</span>bob</span>)</span>;</span></span>
</span>
    //</span> 4. The weapon is dropped on the ground and destroyed</span></span>
    //</span> (released from memory)</span></span>
    free</span>(</span>lost_weapon</span>)</span>;</span></span>
</span>
    //</span> 5. ❌ Undefined behavior</span></span>
    //</span> because weapon_inventory is still pointing to the freed memory</span></span>
    printf</span>(</span>"</span>%s</span>\n</span>"</span>,</span> weapon_inventory</span>)</span>;</span></span>
}</span></span></code></pre>Rust language</h3>
First version</h4>
struct</span> Hero</span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    weapon</span>:</span> String</span>,</span></span>
}</span></span>
</span>
fn</span> take_weapon</span>(</span>hero</span>:</span> &</span>mut</span> Hero</span>)</span> -></span> String</span> {</span></span>
    let</span> lost_weapon</span> =</span> hero</span>.</span>weapon</span>;</span></span>
    hero</span>.</span>weapon </span>=</span> String</span>::</span>new</span>(</span>)</span>;</span></span>
</span>
    lost_weapon</span></span>
}</span></span>
</span>
//</span> ...</span></span></code></pre>

Compilation: ❌ failed</li>
</ul>
Unlike in C, let lost_weapon = hero.weapon;</code> is not a copy, but a move. But you can't transfer ownership of something you don't own: the function just borrows hero</code> (&mut Hero</code>).</p>
We can work around this with a function that takes ownership:</p>
fn</span> take_weapon</span>(</span>mut</span> hero</span>:</span> Hero</span>)</span> -></span> (</span>Hero</span>,</span> String</span>)</span> {</span></span>
    let</span> lost_weapon</span> =</span> hero</span>.</span>weapon</span>;</span></span>
    hero</span>.</span>weapon </span>=</span> String</span>::</span>new</span>(</span>)</span>;</span></span>
</span>
    (</span>hero</span>,</span> lost_weapon</span>)</span></span>
}</span></span></code></pre>
But in this case:</p>

You introduce a sentinel value to detect the absence of a weapon (if hero.weapon == ""</code>).</li>
You lose flexibility. Imagine your Hero</code> is stored in a Vec<Hero></code>: you'd have to remove it from the Vec, take the weapon, then put it back.</li>
</ul>
Second version</h4>
struct</span> Hero</span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    weapon</span>:</span> Option</span><</span>String</span>></span>,</span></span>
}</span></span>
</span>
impl</span> Hero</span> {</span></span>
    fn</span> take_weapon</span>(</span>&</span>mut</span> self</span>)</span> -></span> Option</span><</span>String</span>></span> {</span></span>
        //</span> take() sets the value to None</span></span>
        //</span> and returns the original value</span></span>
        self</span>.</span>weapon</span>.</span>take</span>(</span>)</span></span>
    }</span></span>
}</span></span></code></pre>
self.weapon.take()</code> sets the value to None</code> and returns the original in a single operation, so self</code> is never in an inconsistent state. self.weapon</code> is still an Option<String></code>.</p>
Let's mirror the C scenario in Rust:</p>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> mut</span> bob</span> =</span> Hero</span> {</span></span>
        name</span>:</span> "</span>Bob</span>"</span>.</span>to_string</span>(</span>)</span>,</span></span>
        weapon</span>:</span> Some</span>(</span>"</span>sword</span>"</span>.</span>to_string</span>(</span>)</span>)</span>,</span></span>
    }</span>;</span></span>
</span>
    let</span> weapon_inventory</span> =</span> bob</span>.</span>weapon</span>.</span>as_deref</span>(</span>)</span>;</span></span>
</span>
    //</span> ❌ Compile error: cannot borrow `bob` as mutable</span></span>
    //</span> because it is also borrowed as immutable,</span></span>
    //</span> see `println!("{:?}", weapon_inventory)`</span></span>
    let</span> lost_weapon</span> =</span> bob</span>.</span>take_weapon</span>(</span>)</span>;</span></span>
</span>
    //</span> This line has no consequence here;</span></span>
    //</span> it's just to get closer to the C code.</span></span>
    drop</span>(</span>lost_weapon</span>)</span>;</span></span>
</span>
    println!</span>(</span>"</span>{</span>:?</span>}</span>"</span>,</span> weapon_inventory</span>)</span>;</span></span>
}</span></span></code></pre>

Compilation: ❌ failed</li>
</ul>
Good news: the Rust compiler does not allow this.</p>
To share weapon access across multiple owners, we need interior mutability:</p>
use</span> std</span>::</span>cell</span>::</span>RefCell</span>;</span></span>
</span>
type</span> SharedWeapon</span><</span>'</span>a</span>></span> =</span> &</span>'</span>a</span> RefCell</span><</span>Option</span><</span>String</span>></span>></span>;</span></span>
</span>
struct</span> Hero</span><</span>'</span>a</span>></span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    weapon</span>:</span> SharedWeapon</span><</span>'</span>a</span>></span>,</span></span>
}</span></span>
</span>
fn</span> take_weapon</span>(</span>hero</span>:</span> &</span>Hero</span>)</span> -></span> Option</span><</span>String</span>></span> {</span></span>
    hero</span>.</span>weapon</span>.</span>borrow_mut</span>(</span>)</span>.</span>take</span>(</span>)</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> shared_weapon_source</span> =</span> RefCell</span>::</span>new</span>(</span>Some</span>(</span>"</span>sword</span>"</span>.</span>to_string</span>(</span>)</span>)</span>)</span>;</span></span>
</span>
    let</span> bob</span> =</span> Hero</span> {</span></span>
        name</span>:</span> "</span>Bob</span>"</span>.</span>to_string</span>(</span>)</span>,</span></span>
        weapon</span>:</span> &</span>shared_weapon_source</span>,</span></span>
    }</span>;</span></span>
</span>
    let</span> weapon_inventory</span>:</span> SharedWeapon</span> =</span> &</span>shared_weapon_source</span>;</span></span>
</span>
    let</span> lost_weapon</span> =</span> take_weapon</span>(</span>&</span>bob</span>)</span>;</span></span>
</span>
    drop</span>(</span>lost_weapon</span>)</span>;</span></span>
</span>
    //</span> 5. ✅ No undefined behaviour</span></span>
    println!</span>(</span>"</span>The inventory displays: </span>{</span>:?</span>}</span>"</span>,</span> weapon_inventory</span>.</span>borrow</span>(</span>)</span>)</span>;</span></span>
    //</span> Display: The inventory displays: None</span></span>
}</span></span></code></pre>
RefCell</code> "works," but it trades compile-time safety for runtime panics: the very problem we started with. A better design avoids shared references entirely. Rust-based game engines have developed patterns for this. Here is one clean approach:</p>
struct</span> Hero</span> {</span></span>
    name</span>:</span> String</span>,</span></span>
    weapon</span>:</span> Option</span><</span>String</span>></span>,</span></span>
}</span></span>
</span>
struct</span> Inventory</span> {</span></span>
    items</span>:</span> Vec</span><</span>String</span>></span>,</span></span>
}</span></span>
</span>
impl</span> Hero</span> {</span></span>
    fn</span> take_weapon</span>(</span>&</span>mut</span> self</span>)</span> -></span> Option</span><</span>String</span>></span> {</span></span>
        self</span>.</span>weapon</span>.</span>take</span>(</span>)</span></span>
    }</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> mut</span> bob</span> =</span> Hero</span> {</span></span>
        name</span>:</span> "</span>Bob</span>"</span>.</span>to_string</span>(</span>)</span>,</span></span>
        weapon</span>:</span> Some</span>(</span>"</span>sword</span>"</span>.</span>to_string</span>(</span>)</span>)</span>,</span></span>
    }</span>;</span></span>
</span>
    let</span> mut</span> inventory</span> =</span> Inventory</span> {</span> items</span>:</span> vec!</span>[</span>]</span> }</span>;</span></span>
</span>
    //</span> The hero drops his weapon and places it in his inventory.</span></span>
    if</span> let</span> Some</span>(</span>weapon</span>)</span> =</span> bob</span>.</span>take_weapon</span>(</span>)</span> {</span></span>
        inventory</span>.</span>items</span>.</span>push</span>(</span>weapon</span>)</span>;</span></span>
    }</span></span>
</span>
    println!</span>(</span>"</span>{</span>:?</span>}</span>"</span>,</span> bob</span>.</span>weapon</span>)</span>;</span>      //</span> None</span></span>
    println!</span>(</span>"</span>{</span>:?</span>}</span>"</span>,</span> inventory</span>.</span>items</span>)</span>;</span> //</span> ["sword"]</span></span>
}</span></span></code></pre>Porting Option to another language</h2>
PHP has no built-in Option</code> type, so we'll build one.</p>
First creation attempt</h3>
interface</span> Option</span></span>
{</span></span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> mixed</span>;</span></span>
</span>
    public</span> function</span> unwrapOr</span>(</span>mixed</span> $</span>default</span>)</span>:</span> mixed</span>;</span></span>
}</span></span></code></pre>
Too many mixed</code> types make it clunky.</p>
Second creation attempt</h3>
interface</span> Option</span><T></span></span>
{</span></span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> T</span>;</span></span>
</span>
    public</span> function</span> unwrapOr</span>(</span>T</span> $</span>default</span>)</span>:</span> T</span>;</span></span>
}</span></span></code></pre>
Yes, you can't do that in PHP.</p>
Third creation attempt</h3>
/**</span> @template T </span>*/</span></span>
interface</span> Option</span></span>
{</span></span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span>;</span></span>
</span>
    /**</span> @return</span> T</span> */</span></span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> mixed</span>;</span></span>
</span>
    /**</span></span>
     * </span>@param</span> T</span> $default</span></span>
     *</span></span>
     * </span>@return</span> T</span></span>
     */</span></span>
    public</span> function</span> unwrapOr</span>(</span>mixed</span> $</span>default</span>)</span>:</span> mixed</span>;</span></span>
}</span></span></code></pre>
Generics can be emulated using the annotation @template</code>. We can use PHPStan to validate the use of this annotation. A good IDE like PhpStorm supports these annotations and offers autocompletion for these types.</p>
We need Some</code> and None</code>, which we will define now:</p>
/**</span></span>
 * @template T</span></span>
 * @implements Option<T></span></span>
 */</span></span>
readonly</span> class</span> Some</span> implements</span> Option</span></span>
{</span></span>
    /**</span> @param</span> T</span> $value </span>*/</span></span>
    public</span> function</span> __construct</span>(</span></span>
        private</span> mixed</span> $</span>value</span></span>
    )</span> {</span></span>
    }</span></span>
</span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span></span>
    {</span></span>
        return</span> true</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span></span>
    {</span></span>
        return</span> false</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> mixed</span></span>
    {</span></span>
        return</span> $</span>this</span>-></span>value</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> unwrapOr</span>(</span>mixed</span> $</span>default</span>)</span>:</span> mixed</span></span>
    {</span></span>
        return</span> $</span>this</span>-></span>unwrap</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>/**</span></span>
 * @implements Option<mixed></span></span>
 */</span></span>
readonly</span> class</span> None</span> implements</span> Option</span></span>
{</span></span>
    public</span> function</span> isSome</span>(</span>)</span>:</span> bool</span></span>
    {</span></span>
        return</span> false</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> isNone</span>(</span>)</span>:</span> bool</span></span>
    {</span></span>
        return</span> true</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> unwrap</span>(</span>)</span>:</span> never</span></span>
    {</span></span>
        throw</span> new</span> Exception</span>(</span>'</span>Attempt to call unwrap() on None value</span>'</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> function</span> unwrapOr</span>(</span>mixed</span> $</span>default</span>)</span>:</span> mixed</span></span>
    {</span></span>
        return</span> $</span>default</span>;</span></span>
    }</span></span>
}</span></span></code></pre>In practice</h3>
readonly</span> class</span> Image</span></span>
{</span></span>
    public</span> function</span> __construct</span>(</span>public</span> string</span> $</span>url</span>)</span> {</span>}</span></span>
}</span></span>
</span>
readonly</span> class</span> Product</span></span>
{</span></span>
    /**</span> @param</span> Option</span><</span>Image</span>></span> $image </span>*/</span></span>
    public</span> function</span> __construct</span>(</span></span>
        public</span> string</span> $</span>name</span>,</span></span>
        public</span> Option</span> $</span>image</span></span>
    )</span> {</span></span>
    }</span></span>
}</span></span></code></pre>
PHP is not a compiled language, but PHPStan enforces correct Option</code> usage before execution. We get the type-safety benefits described in Why use Option?</a>.</p>
We also get IDE autocompletion. If $image</code> is a Some<Image></code> in Product</code>, writing $product->image->unwrapOr(new Image('/default.jpg'))-></code> surfaces url</code> as a completion in PhpStorm. If you pass an argument of the wrong type to unwrapOr</code>, PHPStan will flag it.</p>
The pattern ports cleanly. Whatever language you work in, wrapping optional values in a dedicated type (enforced by the compiler or a static analyser) eliminates an entire category of null-related bugs before the program ever runs. That is the real argument for Option</code>.</p>

Build a Standalone Binary from a Symfony App with FrankenPHP 2026-07-01T00:00:00+00:00 If we want a self-contained binary, we would normally reach for a language like Go or Rust. But with FrankenPHP's static builder, we can package a Symfony CLI application into a standalone binary. No PHP runtime required on the target machine. This guide produces a binary for Linux; other target operating systems will require adjustments. Steps: Create a Symfony CLI app</li> Create the Dockerfile</li> Build and extract the standalone binary</li> Run the standalone binary</li> </ol> Create a Symfony CLI app</h2> symfony new hello-world --version="7.4.*" cd hello-world/ composer require --dev symfony/maker-bundle bin/console make:command app:hello-world bin/console app:hello-world</code></pre>Create the Dockerfile</h2> Create a static-build.Dockerfile</code> file: # https://frankenphp.dev/docs/embed/ FROM php:8.2-cli AS prepare COPY --from=composer:latest /usr/bin/composer /usr/bin/composer WORKDIR /app COPY . . ENV APP_ENV=prod APP_DEBUG=0 RUN composer install --ignore-platform-reqs --no-dev -a && \ composer dump-env prod FROM dunglas/frankenphp:static-builder-gnu WORKDIR /go/src/app/dist/app COPY --from=prepare /app . WORKDIR /go/src/app/ RUN EMBED=dist/app/ \ PHP_EXTENSIONS="ctype,iconv,filter,tokenizer,mbstring,xml" \ ./build-static.sh</code></pre>Dockerfile notes</h3> COPY . .</code>: Yes, we need a .dockerignore</code>. An example:</li> </ul> .git .env.local .env.*.local .env.dev /vendor/ /var/</code></pre> --ignore-platform-reqs</code>: The php:8.2-cli</code> Docker image may not have all the PHP extensions.</li> APP_ENV=prod</code>, APP_DEBUG=0</code>: APP_ENV=prod</code> sets the Symfony environment to production; APP_DEBUG=0</code> disables debug mode. Both affect how Symfony behaves when running composer post-install scripts like cache:clear</code>. See Deployment: clear your Symfony Cache</a>.</li> PHP_EXTENSIONS</code>:</li> </ul> Extension</th> Reason</th></tr></thead> ctype, iconv, json, tokenizer, xml</code></td> composer check-platform-reqs</code> output</td></tr> filter</code></td> used in Symfony\Component\Runtime</code></td></tr> mbstring</code></td> used in Symfony\Component\Console</code></td></tr> </tbody></table> Note: json</code> is always compiled into PHP 8+ and does not need to be listed in PHP_EXTENSIONS</code>. Build and extract the standalone binary</h2> Build: docker build -t hello-world-app -f static-build.Dockerfile .</code></pre> Copy the binary out of the container: docker cp $(docker create --name hello-world-tmp hello-world-app):/go/src/app/dist/frankenphp-linux-x86_64 ./hello-world docker rm hello-world-tmp</code></pre>Notes on the copy step</h3> docker create --name hello-world-tmp hello-world-app</code>: creates a container from the hello-world-app</code> image without starting it. If you re-run this step, remove the container first: docker rm hello-world-tmp</code>.</li> $(...)</code>: command substitution; the output of docker create</code> (the container ID) is passed directly to docker cp</code>.</li> docker cp <container>:/go/src/app/dist/frankenphp-linux-x86_64 ./hello-world</code>: copies the binary out of the container.</li> </ul> Run the Standalone Binary</h2> ./hello-world php-cli bin/console app:hello-world</code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.

Run the Standalone Binary</h2>
`./hello-world</span> php-cli</span> bin/console</span> app:hello-world</span></span></code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.</p>`

Elfennol - Blog - dev

Why Rust Replaced Null with Option

Rust language</h3>

Porting Option to another language</h2>
PHP has no built-in `Option</code> type, so we'll build one.</p>`

Build a Standalone Binary from a Symfony App with FrankenPHP

Elfennol - Blog - dev

Why Rust Replaced Null with Option

Rust language</h3>

Porting Option to another language</h2> PHP has no built-in Option</code> type, so we'll build one.</p>

Build a Standalone Binary from a Symfony App with FrankenPHP

Create the Dockerfile</h2> Create a static-build.Dockerfile</code> file:</p>

Run the Standalone Binary</h2> ./hello-world</span> php-cli</span> bin/console</span> app:hello-world</span></span></code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.</p>

Porting Option to another language</h2>
PHP has no built-in `Option</code> type, so we'll build one.</p>`

Run the Standalone Binary</h2>
`./hello-world</span> php-cli</span> bin/console</span> app:hello-world</span></span></code></pre> php-cli</code> is the FrankenPHP subcommand that invokes the embedded PHP CLI interpreter. Everything after it is passed to PHP as a script.</p>`