Immutable vs mutable date related casts purpose if both are ONE way casts, from raw value to object?

[macropay-solutions]

Acc. to this discussion #57627 (comment) the date and datetime are one way castable, meaning they are not cast back into the $attributes like Class Casts or Attribute Casts:

        $this->mergeAttributesFromClassCasts();
        $this->mergeAttributesFromAttributeCasts();

Question is:

What is the purpose of immutable date time vs date time then:

        'immutable_date',
        'immutable_datetime',
        'immutable_custom_datetime',

vs

        'custom_datetime',
        'date',
        'datetime',

?

        $m = new class ([
            'date_of_birth' => '2000-11-11',
            'time_of_birth' => '2000-11-11 11:11:00',
        ]) extends Model {

            protected $casts = [
                'date_of_birth' => 'date',
                'time_of_birth' => 'datetime',
            ];

            protected $fillable =[
                'date_of_birth',
                'time_of_birth',
            ];
            protected function getTimeOfBirthAttribute(?string $value): ?string
            {
                echo $value.'</br>';
                echo $this->attributes['date_of_birth'] .'</br>';
                echo $this->date_of_birth.'</br>';
                if ($value === null) return null;

                if (isset($this->attributes['date_of_birth'])) {
                    return Carbon::parse($this->attributes['date_of_birth'])->toDateString() . ' ' . Carbon::parse($value)->toTimeString();
                }

                return Carbon::parse($value)->toDateTimeString();
            }
        };

        $DOB = $m->date_of_birth;
        $DOB->addDay();

        echo $DOB->toDateTimeString().' DOB</br>';
        echo $m->date_of_birth.' $m->date_of_birth</br>';

        dd($m->time_of_birth);

results in

2000-11-12 00:00:00 DOB
2000-11-11 00:00:00 $m->date_of_birth
2000-11-11 11:11:00
2000-11-11 00:00:00
2000-11-11 00:00:00
"2000-11-11 11:11:00"

[ismaildasci]

Hey, good question! I had similar confusion before so let me explain.

Youre right that every time you access $model->date_of_birth, Laravel creates a new Carbon instance from the raw database value. So in your example, $DOB->addDay() mutates $DOB but doesnt affect the model because $m->date_of_birth returns a fresh Carbon object.

But heres why immutable still matters:

1. Reference sharing in same scope

   $date = $model->created_at;
   $this->someService->doSomething($date); // this method might call $date->addDay() internally
   // now $date is mutated, which can cause bugs if you use it again
   echo $date->format('Y-m-d'); // unexpected value!

   With immutable_datetime, any mutation returns a NEW object, so original stays safe.

2. Consistency in collections/loops

   $users = User::all();
   $firstDate = $users[0]->created_at;
   $firstDate->addYear(); // oops, mutated
   
   // later somewhere else
   foreach($users as $user) {
       // $users[0]->created_at is still original from DB (new instance)
       // but $firstDate variable is mutated - confusing!
   }

3. Functional programming style

   // With mutable Carbon
   $start = $model->start_date;
   $end = $start->addDays(7); // $start is now ALSO 7 days later!
   
   // With CarbonImmutable  
   $start = $model->start_date;
   $end = $start->addDays(7); // $start unchanged, $end is new object

4. Preventing accidental bugs
   Even though model accessor returns fresh instance, you might store that reference somewhere (in a variable, pass to function, put in array). With mutable Carbon, any code that touches it can mutate it unexpectedly.

My recommendation: Use immutable_datetime as default. Its safer and more predictable. The performance difference is negligible and you avoid subtle mutation bugs.

Hope this clears it up!

[marius-ciclistu]

Thank you. Well, strings are safer.

[ismaildasci]

Good question! The difference between immutable_date and date casts is about what happens when you modify the returned Carbon instance.

With date cast (mutable):

$user->date_of_birth; // Returns Carbon instance
$dob = $user->date_of_birth;
$dob->addDay(); // This modifies the same object!

// Now both point to the modified date
echo $dob; // 2000-11-12
echo $user->date_of_birth; // Still 2000-11-11 (fresh from attribute)

With immutable_date cast:

$user->date_of_birth; // Returns CarbonImmutable instance
$dob = $user->date_of_birth;
$dob->addDay(); // Returns NEW object, original unchanged

echo $dob; // Error or new instance

Why does this matter?

Immutable is safer because you cant accidentally modify a date and cause side effects. For example:

// Dangerous with mutable
$endDate = $user->start_date;
$endDate->addDays(30); // Oops, now start_date reference is also changed if cached

// Safe with immutable
$endDate = $user->start_date->addDays(30); // Returns new object

In your example, you are seeing correct behavior - each call to $m->date_of_birth returns a fresh Carbon from the raw attribute, so modifications to $DOB dont affect it.

TL;DR: Use immutable_* casts when you want to prevent accidental mutations and make your code more predictable. Its a best practice for value objects.