First of all I would suggest that you use Config to find the fallback:

use strict;
use Config;
use vars qw(%Config);
print "My default pager is $Config{pager}\n";
[download]

In the same vein I suggest having the editor be not just hard-coded but specifiable with an environment variable and possibly also with a command-line option. I usually use Getopt::Std for the latter. I would do the same with the color.

Speaking of the color, it is good that you handle the case where you cannot load colors, but I would suggest a brief message. Also I am wondering at your attempt to dictate valid colors. Why not just throw the color and then trap errors? Like this:

sub colorize {
  # Autoload here
  eval {require Term::ANSIColor};
  if ($@ =~ /locate Term::ANSIColor/) {
    print "Cannot locate Term::ANSIColor.\n",
      "Color support disabled\n";
    return;
  }
  elsif ($@) {
    die $@;
  }
  my $color = shift;
  my $escape_code = eval {color($color)};
  if ($@) {
    print "Invalid color '$color'\n";
    return color('reset');
  }
  else {
    return $escape_code;
  }
}
[download]

Another detail. Should the sandbox be a directory with spaces in the path name, your glob is going to run into problems with shell semantics. I would suggest going with opendir and readdir - less danger of breakage.

Now a bigger change. Your main loop is very simple in concept. However you now have a manual syncronization job between printing your menu and writing your loop. This is going to be a problem. Instead I would suggest that you take a page off of Code that writes code and write the stuff currently in the body of your loop as structured text. Extract that into the real loop, then eval it. I would strongly recommend that if you go this way you test your eval for $@, and if there are errors dump the full text of the code you created.

Alternately you can write the information for the menu and the handlers in two hashes, then run an automatic check at load that the two data structures are in sync. Then you could, say, dispatch to anonymous subroutines like this:

  my ($case, $data) =(split /\s/, $input, 2;
  $case = lc($case);
  if (exists $handler{$case}) {
    $handler{$case}->($data);
  }
  else {
    do_default($input);
  }
[download]

@cases = [
  # etc
  {
    case => 'l',
    desc => 'co_or to change the menu item color',
    func => sub {
      print "change menu item color to: ";
      my $newcolor=<>;
      chomp $newcolor;
      $color=colorize($newcolor);  
    },
  },
  # etc
};
[download]

Any way you cut it, a long-term maintainance problem is going to be keeping the description in the menu in sync with what the loop does. If your program will (and you know it will) remain small, then solving that is unneeded work. But if there is a good chance it will grow or change over time, restructuring so that the information that belongs together will stay together is worthwhile.

Also a point that is too often forgotten is that while the work may not have been needed, being agressive about doing this kind of thing on small projects stretches you so that you have the skills when you need it later...

Here is what I came up with after a quick run through at your request:

#!/usr/bin/perl -w
=head Changes
Be more consistant with your spacing.
I don't see the use for which() since you are just duplicating code th
+at
    the kernel will do but less portably (under Win32, you need to spl
+it
    on ';', not on ':').
Used a more "standard" method for picking an editor.
Since you only have one enclosing loop, you don't need the STUDY: labe
+l,
    but I don't mind you keeping it since it makes it easy to find tha
+t loop.
On non-Unix systems, $ENV{HOME} may not be set.
Declaring subs in the middle of code just makes them hard to find.
Added a default for $ENV{SANDBOX}
s/[A-Za-z]/0/g more efficient as tr/A-Za-z/0/
Allow easy highlight with a color other than 'GREEN'
Replace repeated highlighting code with a subroutine
Treat $hide_help and $clear as Booleans instead of integers
Your first "next" doesn't do anything (I just commented it out)
Your first "redo" doesn't do anything (commented out)
Don't have a [my] variable with the same name as a global, STUDYPATH
close SCRIPT when you are done with it
=cut

use strict;

use Term::ANSIColor 'color';

my $EDITOR    = $ENV{VISUAL} || $ENV{EDITOR} || $ENV{EDIT}
                    or  $^O =~ /^MSWin/ ? 'notepad' : 'vi';
my $index     = @ARGV ? shift(@ARGV) :0;
my $clear     = 1;
my $hide_help = 0;
my $highlight = $ENV{STUDYCOLOR} || 'GREEN';

my $homedir   = $ENV{HOME} || '.';
my $sandbox   = $ENV{SANDBOX} || 'sandbox';
my $STUDYPATH = "$homedir/$sandbox";

sub change_snippet_dir{
    my $sandbox= shift;
    my $path= "$homedir/$sandbox";
    if(  -d $path  ) {
        $STUDYPATH= $path;
    }
}

sub highlight {
    return color($highlight), @_, color('reset');
}

STUDY:
while (1) {
    my @files= glob "$STUDYPATH/*";
    if( $clear ) {
        system ('clear');
    } else {
        $clear++;
    }
    $index =~ tr/A-Za-z/0/;
    $index= 0   if  $index < (0-$#files)-1  ||  $index > $#files;
    printf( "%50s <- (%5s)\n", $files[$index], $index );
    print "
    ",highlight("[C]"),"HANGE editor. Currently $EDITOR
    ",highlight("[E]"),"DIT to open the snippet in an editor
    ",highlight("[G]"),"oTo to select file index: -", ($#files+1)," to
+ $#files
    ",highlight("[H]"),"ELP to (un)hide this menu
    ",highlight("[N]"),"EXT to skip this snippet
    ",highlight("[R]"),"EDO to revisit the previous snippet
    ",highlight("[Q]"),"UIT to exit
    e",highlight("[X]"),"ecute
    Any other key +",highlight(" [ENTER] "),"to print out the snippet
->      "
    unless $hide_help;

    my $input = <>;

    if ($input =~ /^N/i){
        ++$index;
        # next; This doesn't do anything

    }elsif($input =~ /^G/i){
        print "enter a number from -",$#files+1," to $#files
        ->   ";
        $index = <>;
        chomp $index;

    }elsif($input =~ /^H/i){
        $hide_help= ! $hide_help;

    }elsif($input =~ /^C/i){
        $EDITOR = <>;
        chomp $EDITOR;
        # redo STUDY;

    }elsif($input =~ /^R/i){
        --$index;

    }elsif($input =~ /^(SANDBOX)/i){
        print "$homedir/"; 
        my $sandbox=<>;
        chomp $sandbox;
        change_snippet_dir($sandbox);

    }elsif($input =~ /^E/i){
        system( $EDITOR, $files[$index] );

    }elsif($input =~ /^X/i){
        do $files[$index];
        print "\n";
        $clear= 0;

    }elsif($input =~ /^Q/i){
        last;

    }else{
        $clear= 0;
        open (SCRIPT,"< $files[$index]") 
                                or warn "can't open file: $!";
        print while <SCRIPT>;
        close SCRIPT;
    }
}
[download]

This is just terrific stuff, tye. Like tilly's criticisms, I understand what you wrote, and I can agree with everything you said. I'm grateful that you both took so much time to make detailed comments. I'll try to make good use of your advice, not just in improving this simple program but in thinking more carefully about portability, maintainability, and choosing the appropriate data structures.

Hopefully the light will come up, little by little, and you'll see some smarter programs from me over time!
mkmcconn