my $boundary_aggregation_first = (
        min => {
            x => 0,
            y => 0,
        },
        max => {
            x => 639,
            y => 479,
        },
    );
    my $boundary_dimension_first = (
        x => {
            min => 0,
            max => 639,
        },
        y => {
            min => 0,
            max => 479,
        },
    );

##</code><code>##

    package Boundary;
    use strictures 2;
    use namespace::clean;
    use Data::Dumper;
    use Moo;
    use MooX::Types::MooseLike::Base qw/ HashRef Int Maybe /;
    with q{MooX::Singleton};

    has q{limit} => (
        is => q{rw},
        isa => HashRef [ HashRef [ Maybe [Int] ] ],
        traits => [ q{Hash}, ],
        default => sub { {} },
    );

##</code><code>##

    before q{limit} => sub {
        my $self = shift;
        if ( scalar @_ ) { 
            my $val = shift;
            if ( ref $val eq q{HASH} ) {
                foreach my $k ( keys %{$val} ) {
                    if ( defined $val->{$k}->{$l} ) {
                        $self->limit->{$k}{$l} = $val->{$k}->{$l};
                    }
                    else {
                        my $result = $self->limit->{$k}{$l};
                        return $result;
                    }
                }
            }
        }
    };
    __PACKAGE__->meta->make_immutable;
    1;

    package main;

    my $wall = Boundary->instance();
    $wall->limit( { min => { x => 0, y => 0, }, 
                    max => { x => 639, y => 478, }, }, );
    # ...
    say $wall->limit( { min => { x => undef, }, }, );
    # Expected: 0
    # Actual: HASH(0x801a440b8)
    say $wall->limit( { max => { x => undef, }, }, );
    # Expected: 639
    # Actual: HASH(0x801a44160)

##</code><code>##

use strict;
use warnings;

use 5.014;

use Moo;
use strictures 2;
use namespace::clean;

package Boundary;

use Data::Dumper;
use Moo;
use MooX::Types::MooseLike::Base qw/ HashRef Int Maybe /;
with q{MooX::Singleton};

has 'limit' => (
    is      => q{rw},
    isa     => HashRef [ HashRef [ Maybe [Int] ] ],
    traits  => [ q{Hash}, ],
    default => sub { {} },
);

before q{limit} => sub {
    my $self = shift;

    if ( scalar @_ == 1 ) {
        my $val = shift;
        if ( ref $val eq q{HASH} ) {
            foreach my $k ( keys %{$val} ) {
                foreach my $l ( keys %{ $val->{$k} } ) {
                    if ( defined $val->{$k}->{$l} ) {
                        $self->limit->{$k}{$l} =
                          $val->{$k}->{$l};
                    }
                    else {
                        my $result = $self->limit->{$k}{$l};
                        return $result;
                    }
                }
            }
        }
    }
};

__PACKAGE__->meta->make_immutable;

1;

package main;

# use Boundary;

my $wall = Boundary->instance();
$wall->limit(
    {
        min => { x => 0,   y => 0, },
        max => { x => 320, y => 240, },
    },
);
say $wall->limit->{min}{x};
say $wall->limit->{min}{y};
say $wall->limit->{max}{x};
say $wall->limit->{max}{y};

# $wall->limit->{max}{x} = 325;
# $wall->limit->{max}{y} = 245;
say __LINE__ . q{: },
  $wall->limit( { max => { x => 325, y => 245, }, }, );
say __LINE__ . q{: },
  $wall->limit( { max => { q{x} => undef, }, }, );
say __LINE__ . q{: },
  $wall->limit( { max => { q{y} => undef, }, }, );

# $wall->limit->{max}{x} = 320;
# $wall->limit->{max}{y} = 240;
$wall->limit( { max => { x => 320, y => 240, }, }, );

__END__