3/17    In Perl, how do I make variables have static types and type check
        for valid parameter/actuals? I realize that variables are untyped
        in Perl ($var can be 0.001 or "hello") but I'd like to have more
        strict checking so that errors would be caught ahead of run-time,
        Thanks,                                                 -java guy
        \_ use java.  Seriously.  You don't use perl if you want strong
           typing.  If you want to clean user input, use regexps.  But
           the closest thing perl has to typing is its data structures.
           The content of those structures can be... anything. --scotsman
           \_ Oh yes, as opposed to those lists of Objects Java has, where you
              have to use instanceof and casting to get what you want.  Java is
              bad.  Naturally any language in the ML family will work, as will
              Lisp strangely enough.  Yes, Lisp actually has a fairly powerful
              type system that most people never use (using 'declare' and so
              on).  -- ilyas
              \_ I only said "use java" because he signed as "java guy"
                   --scotsman
                 \_ You know, Ben, just because someone signs as
                    'heroin addict', doesn't mean you should give him bad
                    advice. -- ilyas
                    \_ You're always coming down on heroin, Ilya. -geordan
                       \_ That's "coming down off heroin," geordan.  Get yer
                          drug lingo right.
              \_ you don't use java much, do you. it's not great, but it's not
                 that bad either. i very rarely use instanceof, and 1.5 has
                 parameterized containers.
                 \_ You are right, I no longer use Java much, I am proud to
                    report.  While I am happy you almost never use instanceof
                    and casting to get things out of lists in Java, it turned
                    out to be a common enough problem that made them add
                    templates.  I mean my example is precisely the one given
                    on Sun's site to explain why templates are useful.  There
                    are other problems with Java's types, for instance you can
                    google for 'type spoofing.'  I won't even get to other
                    things wrong with Java.  I think Paul Twohey has a long
                    rant stored somewhere on this subject, on everything from
                    primitive type handling to floating point. -- ilyas
                    \_ Java Generics are not templates...
                       Java Generics are not templates...
                       \_ Yup, weaker than C++ templates.  Though you know,
                          the word 'template' is pretty ... generic.  It's not
                          like it applies exclusively to C++ stuff. -- ilyas
        \_ One way to find mistakes in perl is to 'use strict;' and to run
           with #!/usr/bin/perl -wT. At least this way you can find the
           obvious mistakes with input validation. Once you fix those, the
           only other thing you can do is to perform input validation in all
           of your subroutines.
           The biggest problem I find with perl is the lack of prototypes,
           which forces you to manually check @_ in every subroutine to make
           sure that the correct number of args were specified. There are
           extensions to perl that add this, but they aren't available on
           every system which makes it hard to write portable perl code using
           them.
           \_ You make this sound so difficult.  "warn if (@_ != n)"
                \_ That doesn't do type checking for you. If you need the
                   first two entries in @_ to be ints, the next two to be
                   string, &c. its not do-able without manually checking
                   each entry in @_. Prototypes (ansi-c style) provide that
                   level of support for you.
                   \_ Irrelevant.  This is perl.  use something else if you
                      want typing.
           BTW, for the java-types, sometimes you don't have a choice. Ex. if
           you need to write a cli program java is a terrible choice due to
           the jvm startup penalty, the resource requirements (jvm needs ~
           10mb of ram compared with 700k or less for perl), and its lack
           of integration with libc (using Runtime.exec() in order to change
           file ownership, create symlinks, remove files, &c. is not workable).
           \_ So write in in C and stop bitching about it. -williamc
                \_ I used to write everything in C, but having to roll
                   binaries for every odd-ball os/hw type just became
                   a pita. Perl was a compromise, it is portable and
                   has just enough system support for the things that
                   I need to do.
           \_ Um, prototypes are built into perl and have been for a while:
              sub foo($$@) { ... }
              foo takes two scalars and a list
                \_ WHAT? What is the name of the variable then? It's a lot
                   more clear if you use "sub foo($a, $b) { ... }"
                   \_ The variable is, as always, @_.