I wouldn't call that "the vast majority".

The bits that are the same:

 
 void      $scalar            @array        %hash
 scalar    @array             @array[0, 2]                 
 list      %hash                               
           &sub
                    
                    number, string, reference,       undef

 \     references      
 $@%&  dereference     
 []    anon. arrayref  
 {}    anon. hashref   
 \()   list of refs
                         
                         =          =        perl.plover.com
                         +                   search.cpan.org
 ++ --                   == !=      eq ne         cpan.org
 **                      < > <= >=  lt gt le ge   pm.org
 !   \ u+ u-             <=>        cmp           tpj.com
    !~                                            perldoc.com
 * / % x                 
 + - .                   for    (LIST) { }, 
                         while  ( ) { }, until ( ) { }
 named uops              if     ( ) { } elsif ( ) { } else { }
 < > <= >= lt gt le ge   unless ( ) { } elsif ( ) { } else { }
 == != <=> eq ne cmp     
  
                  
 &&               ^     string begin      
 ||                                      
 ..               +     one or more     
                  *     zero or more   
 = += -= *= etc.  ?     zero or one    
 ,                                  
 list ops         ()    capture          
 not                                                  
 and                                     \s == [\x20\f\t\r\n]
 or xor           |     alternation      \w == [A-Za-z0-9_]
                  \b    word boundary    \d == [0-9] 
                                         \S, \W and \D negate

 use strict;        
 use warnings;      "$foo"           perl.com       
 my $var;           $$variable_name  perlmonks.org  
 open() or die $!;  `$userinput`     use.perl.org   
 use Modules;       /$userinput/     perl.apache.org
                                     parrotcode.org 

 stat      localtime    caller         
  0 dev    0 second     0 package      $_    default variable
  1 ino    1 minute     1 filename     
  2 mode   2 hour       2 line         
  3 nlink  3 day        3 subroutine   
  4 uid    4 month-1    4 hasargs      
  5 gid    5 year-1900  5 wantarray    
  6 rdev   6 weekday    6 evaltext     
  7 size   7 yearday    7 is_require   
  8 atime  8 is_dst     8 hints        
  9 mtime               9 bitmask      @ARGV command line args
 10 ctime  just use                    @INC  include paths
 11 blksz  POSIX::      3..9 only      @_    subroutine args
 12 blcks  strftime!    with EXPR      %ENV  environment
[download]

The bits that differ:

 
                       
                                            @hash{'a', 'b'}
                              $array[0]     $hash{'a'}
                           
           *glob     
                                               glob       

                       $$foo[1]       aka $foo->[1]
     * dereference     $$foo{bar}     aka $foo->{bar}
                       ${$$foo[1]}[2] aka $foo->[1]->[2]
                       ${$$foo[1]}[2] aka $foo->[1][2]
                     
                         
     
 ->                                 .
 

   ~ 
 =~ 
                         
           
 << >>    
         
 
                         for equals foreach (ALWAYS)
 &
 | ^              
                                             /i case insens.
                  $     str. end (before \n) /m line based ^$
    ...                                      /s . includes \n
 ?:                                          /x ign. wh.space
                                             /g global
   =>             {3,7} repeat in range
                                         
                  (?:)  no capture       .  == [^\n]
                  []    character clas 
                 
                  
                  \z    string end 

                    
                                                    
                                                    
                                                     
                                                     
                                                          
 
                                       
                                       
                                       $0    program name
                                       $/    input separator
                                       $\    output separator
                                       $|    autoflush
                                       $!    sys/libcall error
                                       $@    eval error
                                       $$    process ID
                                       $.    line number
[download]

So 153 of the 194 Perl features listed in the cheatsheet (congratulations on packing that much in, by the way!) are the same for Perl 6. That's 79% unchanged. I would call that a "vast majority".

And, yes, I'm counting the for, if, while, etc. syntaxes as being the same. Sure, the parens are optional but that just means you can go on using them exactly as you do now (i.e. no change required).