Perl/서브루틴

1. perlsub document 요약

1.1. 개요

1.2. 설명

1.2.1. my()를 통한 프라이빗 변수 ( Private Variables via my() )

1.2.2. 영구 private 변수 ( Persistent Private Variables )

1.2.2.1. state()를 통한 영구 변수 ( Persistent variables via state() )

1.2.2.2. closure를 통한 영구 변수 ( Persistent variables with closures )

1.2.3. local()을 통한 임시값 ( Temporary Values via local() )

1.2.3.1. local()의 문법에 관하여 ( Grammatical note on local() )

1.2.3.2. 특수 변수들의 지역화 ( Localization of special variables )

1.2.3.3. glob 지역화 ( Localization of globs )

1.2.3.4. 구조형 변수의 원소 지역화 ( Localization of elements of composite types )

1.2.3.5. 구조형 변수의 원소를 지역화 후 삭제 ( Localized deletion of elements of composite types )

1.2.4. L밸류 서브루틴 ( Lvalue subroutines )

1.2.5. 심볼테이블 엔트리 넘겨주기 (typeglobs) ( Passing Symbol Table Entries (typeglobs) )

1.2.6. 여전히 local()을 사용해야 하는 경우들 ( When to Still Use local() )

1.2.7. 참조에 의한 전달 ( Pass by Reference )

1.2.8. 프로토타입 ( Prototypes )

1.2.9. 상수 함수 ( Constant Functions )

1.2.10. 내장 함수 오버라이드 ( Overriding Built-in Functions )

1.2.11. 자동 로드 ( Autoloading )

1.2.12. 서브루틴 속성 ( Subroutine Attributes )

1.3. 참고

2. 다른 문서들에서

2.1. 선언 순서

2.2. Context

2.3. Prototype

2.4. 인자로 레퍼런스 넘겨주기

2.5. 인자로 파일핸들 넘겨주기

2.6. Named parameter

2.7. 서브루틴의 레퍼런스

2.8. Closure

2.9. 서브루틴을 반환하는 서브루틴

2.10. closure variable를 static local variable로 쓰기

2.11. 서브루틴을 인자로 넘기기

3. 기타

4. Comments

1. perlsub document 요약

• perlsub 5.12.1 기준

1.1. 개요

    sub NAME;                     #  정의하기 전에 미리 선언하기 ("forward" declaration)
    sub NAME(PROTO);              #  마찬가지인데, 프로토타입 제시
    sub NAME : ATTRS;             #  속성 제시
    sub NAME(PROTO) : ATTRS;      #  프로토타입, 속성 제시

    sub NAME BLOCK                #  선언과 정의를 함께
    sub NAME(PROTO) BLOCK         #  마찬가지인데, 프로토타입 제시
    sub NAME : ATTRS BLOCK        #  속성 제시
    sub NAME(PROTO) : ATTRS BLOCK #  프로토타입, 속성 제시

    $subref = sub BLOCK;                 # 
    $subref = sub (PROTO) BLOCK;         # 프로토타입 제시
    $subref = sub : ATTRS BLOCK;         # 속성 제시
    $subref = sub (PROTO) : ATTRS BLOCK; # 프로토타입과 속성 제시

    use MODULE qw(NAME1 NAME2 NAME3);

    NAME(LIST);    # 괄호를 사용하면 앞에 &는 생략 가능
    NAME LIST;     # 미리 선언되어 있거나 임포트한 경우는 괄호 생략가능
    &NAME(LIST);   # 프로토타입 무시하기
    &NAME;         # 현재 @_ 변수를 호출된 서브루틴에서 사용할 수 있게 함

• 인수는 @_ 로 전달됨

1.2. 설명

• 메인 프로그램 내 아무 곳에나 있을 수 있다
• do, require, use 를 사용하여 다른 파일에서 로드할 수 있다
• eval 또는 익명 서브루틴을 사용하여 실행 시간에 생성할 수 있다
• 서브루틴의 이름 또는 CODE 레퍼런스를 담고 있는 변수를 사용하여 간접적으로 호출할 수도 있다

• 함수에 넘겨지는 인자는 스칼라들의 리스트 하나로 구성되어 넘겨진다.
• 함수가 호출자에게 리턴하는 것도 스칼라들의 리스트 하나이다
• 호출과 리턴 때 배열과 해쉬들은 하나로 합쳐지면서 각각의 속성을 잃게 된다. 참조에 의한 호출을 하여 이 점을 방지할 수 있다.
• (함수function 중에 명시적인 return 구문이 없는 것을 서브루틴subroutine이라고 하는 경우도 있는데1, Perl에서는 함수와 서브루틴엔 아무런 차이가 없다)

• 예: 인자가 두 개였다면 각각은 $_[0], $_[1]에 담긴다
• @_ 배열 자체는 지역 변수이지만, 이 배열의 원소들은 실제 스칼라 실인자들의 별칭(alias)으로 되어 있다. $_[0] 원소를 변경하면, 대응되는 실인자도 변경된다 (만일 실인자가 변경 불가능한 것이라면 에러가 난다).
• 인자가 배열 또는 해쉬의 원소인데 함수가 호출하는 시점에 존재하지 않는 원소였다면, 함수 내에서 그 원소의 값을 변경하거나 그 원소의 레퍼런스를 취하는 경우에(또한, 그런 경우에만) 생성된다.
  • 오래된 Perl 버전의 경우는 무조건 생성된다.
• @_ 배열 전체에 새로운 값을 할당하면 별칭이 제거되며, 인자들은 변경되지 않는다.

• 서브루틴을 종료하고 빠져나올 때 사용된다.
• 추가로 리턴값을 명시해 줄 수 있다.
  • 이 리턴값은 서브루틴을 호출한 문맥(리스트, 스칼라, 보이드)에 따라 적절한 문맥으로 평가된다.
• 리턴값을 명시하지 않은 경우
  • 리스트 문맥에서는 빈 리스트 반환
  • 스칼라 문맥에서는 undefined 값
  • 보이드 문맥에서는 아무것도 반환하지 않음
• 하나 이상의 집합적 자료들(배열과 해쉬)을 리턴할 경우, 이 자료들은 하나의 리스트로 평탄화(flatten)되어 반환된다
• return 구문이 없고, 마지막 구문이 표현식인 경우 그 식의 값이 반환된다.
  • 마지막 구문이 foreach, while 같은 루프 제어 구조인 경우는 반환값이 명세되어 있지 않다
• 빈 서브루틴은 빈 리스트를 반환한다.

• 보통은 my() 리스트에 할당해서 사용한다.
• private으로 선언되지 않은 변수들은 전역 변수들이다.
• private 변수를 만드는 자세한 내용은 아래 섹션들 참조
• 개별적인 패키지 내의 함수들에서 사용되는 protected 환경을 만드는 법은 perlmod 의 Packages 섹션을 참조

    sub max {
        my $max = shift(@_);
        foreach $foo (@_) {
            $max = $foo if $max < $foo;
        }
        return $max;
    }
    $bestday = max($mon,$tue,$wed,$thu,$fri);

    # 공백으로 시작하는 줄은 앞 줄에 이어지는 줄로 취급하여 한 줄을 구성

    sub get_line {
        $thisline = $lookahead;  # 전역 변수!
        LINE: while (defined($lookahead = <STDIN>)) {
            if ($lookahead =~ /^[ \t]/) {
                $thisline .= $lookahead;
            }
            else {
                last LINE;
            }
        }
        return $thisline;
    }

    $lookahead = <STDIN>;       # 첫번째 라인을 읽음
    while (defined($line = get_line())) {
        ...
    }

    sub maybeset {
        my($key, $value) = @_;
        $Foo{$key} = $value unless $Foo{$key};
    }

    upcase_in($v1, $v2);  # $v1과 $v2의 값이 바뀐다
    sub upcase_in {
        for (@_) { tr/a-z/A-Z/ }
    }

    upcase_in("frederick");

    ($v3, $v4) = upcase($v1, $v2);  # 여기서는 $v1과 $v2의 값이 바뀌지 않는다
    sub upcase {
        return unless defined wantarray;  # void context, do nothing
        my @parms = @_;
        for (@parms) { tr/a-z/A-Z/ }
        return wantarray ? @parms : $parms[0];
    }

    @newlist   = upcase(@list1, @list2);
    @newlist   = upcase( split /:/, $var );

    (@a, @b)   = upcase(@list1, @list2);

• 최신 Perl에서는 &는 생략가능하다
• 서브루틴이 미리 선언된 경우는 괄호도 생략가능하다
• &가 필수적인 경우:
  • defined()나 undef()의 인자로 넣는 경우처럼, 서브루틴의 이름 자체를 지칭할 경우
  • &$subref() 또는 &{$subref}() 구조를 사용하여 이름이나 레퍼런스를 통한 간접 호출을 하는 경우. 이 것은 $subref->() 표기법을 사용하여 피할 수 있다.
• 자세한 것은 perlref 참조

• &를 붙인 형태로 호출할 경우, 인자 리스트를 생략할 수 있으며, 생략하면 호출하는 시점의 @_ 배열이 서브루틴에 보이게 된다. 이것은 효율적이지만3 초심자는 피하고 싶을 수 있다:

    &foo(1,2,3);        # 인자 세 개를 전달
    foo(1,2,3);         # 위와 동

    foo();              # 빈 리스트를 전달
    &foo();             # 위와 동

    &foo;               # foo()는 현재 인자목록을 그대로 취한다, foo(@_)와 동일하다 !!
    foo;                # 서브루틴이 미리 선언된 경우에는(또한 그 경우에만) foo()와 동일하다
                        # 미리 선언되지 않았다면 bareword "foo"이다.

• 부분적으로는 역사적인 이유로, 부분적으로는 편리하게 꼼수를 쓸 수 있게 하기 위함
• 자세한 건 "Prototypes" 섹션 참조

• 관례적(엄격하진 않음)으로, 이벤트 발생시 Perl 런타임 시스템에 의해 간접적으로 호출되는 서브루틴임을 의미한다.
• 예: AUTOLOAD, CLONE, DESTROY, perltie PerlIO::via 에 언급되는 함수들.

• 서브루틴이라기보다는, 이름이 있는 특수한 코드 블록이라 볼 수 있다.
• 한 패키지 안에 이런 블록들을 둘 수 있고, 명시적으로 호출할 수는 없다.
• 자세한 것은 perlmod 의 "BEGIN, UNITCHECK, CHECK, INIT and END" 섹션 참조

1.2.1. my()를 통한 프라이빗 변수 ( Private Variables via my() )

    my $foo;            # $foo를 렉시컬 지역 변수로 선언
    my (@wid, %get);    # 변수들의 리스트를 지역 변수로 선언
    my $foo = "flurp";  # $foo를 렉시컬로 선언하고 초기화
    my @oof = @bar;     # @oof를 렉시컬로 선언하고 초기화
    my $x : Foo = $y;   # 속성이 명시됨

• 나열된 변수들을 다음과 같은 스코프 안에서만 사용가능하게 한정한다:
  • 자신을 둘러싼 블록
  • 조건문 (if/unless/elsif/else)
  • 루프 (for/foreach/while/untile/continue)
  • 서브루틴
  • eval
  • do/require/use 의 대상 파일
  • 둘 이상의 변수를 나열할 때는 괄호로 둘러싸야 함
  • 나열된 각 원소는 모두 적법한 lvalue여야 함
  • 문자와 숫자로 조합된 식별자만이 렉시컬 스코프로 지정될 수 있다
    • $/ 등과 같은 빌트인 변수들은 local 키워드를 사용하여 지역화되어야 한다.

• 이것은 설령 서브루틴이 자기 자신을 호출한 경우에도 마찬가지이다 - 각각의 호출은 각각 자신만의 사본을 사용한다.

• 다음 코드에서 bumpx() 함수는 렉시컬 $x 변수에 접근할 수 있다. my와 sub 가 동일한 스코프에 나타나기 때문이다:

    my $x = 10;
    sub bumpx { $x++ }

• 변수를 선언할 때 초기화 값이 주어지지 않는 경우는 undefined 값을 가지고 생성된다.
• 서브루틴의 입력 파라메터에 이름을 부여할 때 사용:

    $arg = "fred";        # "전역" 변수
    $n = cube_root(27);
    print "$arg thinks the root is $n\n";
    sub cube_root {
        my $arg = shift;  # 변수이름은 아무래도 상관없다
        $arg **= 1/3;
        return $arg;
    }

fred thinks the root is 3

• 아래 두 코드는 둘 다 우변에 리스트 문맥을 전달한다

    my ($foo) = <STDIN>;                # WRONG?
    my @FOO = <STDIN>;

• 반면 아래 코드는 스칼라 문맥을 전달한다.

    my $foo = <STDIN>;

• 다음 경우는 한 변수만 선언한다

    my $foo, $bar = 1;                  # 잘못

• 이는 아래 코드와 동일한 효과를 낸다:

    my $foo;
    $bar = 1;

• 새로운 $x 를 기존의 $x 의 값으로 초기화한다:

    my $x = $x;

• 아래 식은 기존의 $x의 값이 우연히 123일 경우를 제외하고는 거짓이 된다:

    my $x = 123 and $x == 123

• 다음 반복문에서 $line의 스코프는 선언한 부분부터 continue 절까지 포함한 루프 전체:

    while (my $line = <>) {
        $line = lc $line;
    } continue {
        print $line;
    }

• 다음 조건문에서 $answer의 스코프는 선언한 부분부터 elsif와 else를 전부 포함한 조건문 전체:

    if ((my $answer = <STDIN>) =~ /^yes$/i) {
        user_agrees();
    } elsif ($answer =~ /^no$/i) {
        user_disagrees();
    } else {
        chomp $answer;
        die "'$answer' is neither 'yes' nor 'no'";
    }

• 변경자가 붙은 구문 내에서 변수의 스코프에 관한 것은 perlsyn의 "Simple statements" 섹션 참조

• 기본적으로는 인덱스 변수를 local을 사용한 것처럼 스코프를 동적으로 조정한다4
• 인덱스 변수가 my로 선언되거나, 이미 그 이름의 렉시컬 변수가 존재할 경우는, 새로운 렉시컬 변수를 생성하여 사용한다.
• 다음 루프에서, $i의 스코프는 루프가 끝나는 지점까지이며, some_function() 안에서는$i에 접근할 수 없다

    for my $i (1, 2, 3) {
        some_function();
    }

• 패키지 변수(언제나 전역인)를 묵시적으로 사용하는 걸 감지하기 위하여 다음과 같이 하면:

    use strict 'vars';

• 이 지점부터 둘러싼 블록이 끝날 때까지 사용되는 변수들은 렉시컬 변수이거나 our 또는 use vars를 사용하여 미리 선언되었거나, 이름에 패키지 이름까지 포함한 형태로5 적어주어야 한다.
• 안쪽 블록에서 no strict 'vars'를 하여 이 제한을 다시 없앨 수 있다.

• 컴파일 타임 - 컴파일러가 체크함
  • use strict 'vars'를 사용할 때 에러가 나지 않게 함
  • 클로져를 만들 때 필수. perlref 참조. 6
• 런타임 - 실제 초기화는 런타임에 적절한 시기에 이뤄진다

• 패키지 변수를 렉시컬로 선언하는 것도 허용되지 않는다:

    my $pack::var;      # 에러! 허용되지 않는 문법

• 동일한 이름의 렉시컬 변수가 있더라도 동적 변수(패키지 변수 또는 전역 변수라고 알려진)는 ::를 사용한 fully qualified 표기법을 써서 접근할 수 있다:

    package main;
    local $x = 10;
    my    $x = 20;
    print "$x and $::x\n";  # "20 and 10" 출력

• C에서 파일 레벨에 선언된 static 변수와 유사
• 블록 바깥쪽에서 호출할 수 없는 private 서브루틴을 만들고 싶다면, 익명 서브루틴 레퍼런스를 담는 렉시컬 변수를 선언:
  • 이 레퍼런스가 모듈 내 어떤 함수에서 리턴되지 않는 이상은 모듈 외부에서는 이 서브루틴을 볼 수 없다. 이 서브루틴의 이름이 패키지의 심볼 테이블에 들어있지 않기 때문이다. 렉시컬 변수는 $some_pack::secret_version과 같은 식으로 접근할 수 없다는 걸 상기하라.

    my $secret_version = '1.001-beta';
    my $secret_sub = sub { print $secret_version };
    &$secret_sub();

• 오브젝트 메쏘드의 경우에는 이런 식으로 할 수 없다. 모든 오브젝트 메쏘드는 어떤 패키지의 심볼 테이블 안에 존재해야 나중에 찾을 수 있기 때문이다. 이 문제를 우회하기 위한 내용은 perlref의 "Function Templates" 섹션을 참조

1.2.2. 영구 private 변수 ( Persistent Private Variables )

• Perl 5.10부터는 state 사용
• 5.10 이전 버전과 호환성을 유지하기 위해서는 closure 이용

1.2.2.1. state()를 통한 영구 변수 ( Persistent variables via state() )

• perl 5.9.4 부터
• 먼저 feature 프라그마를 쓰거나, 원-라이너로 실행할 때는 -E를 사용하라8. feature 참조.
• 다음 코드는 gimme_another()가 호출될 때마다 1씩 증가하는 카운터를 관리한다:

    use feature 'state';
    sub gimme_another { state $x; return ++$x }

• $x도 렉시컬 변수이고, 이 서브루틴 밖에서는 접근할 수 없다.
• 변수를 선언하면서 동시에 스칼라값을 할당하는 경우(state $x=42와 같이) 이 할당은 처음 한 번만 실행된다. 이후에는 무시된다. 스칼라가 아닌 변수의 경우에 어떻게 동작하는지는 정의되지 않았다.9

1.2.2.2. closure를 통한 영구 변수 ( Persistent variables with closures )

• 가비지 컬렉션이 적용된다.
• Perl의 렉시컬 변수는 스코프를 빠져나갔다고 반드시 회수되는 건 아니다. 더 오래 유지되는 다른 무엇인가가 그 렉시컬 변수의 존재를 인지하고 있는 상태라면, 그 변수도 회수되지 않고 남아 있게 된다.
• C 언어에서는 오토 변수의 포인터를 리턴하는 건 심각한 실수인 반면, Perl에서는 렉시컬 변수의 레퍼런스를 되돌려주거나 저장해 둘 수 있다.

• 렉시컬 스코핑과 정적 라이프타임을 동시에 갖게 됨
• 전체 함수를 외부에서 블록으로 감싸고, 정적 변수로 쓸 변수를 함수보다는 바깥쪽이고 블록보다는 안쪽인 영역에서 선언

    {
        my $secret_val = 0;
        sub gimme_another {
            return ++$secret_val;
        }
    }
    # $secret_val은 블록 바깥쪽에서는 접근할 수 없다
    # 그러나 gimme_another의 매 호출 사이에도 값이 계속 유지된다

• 이 함수가 require나 use를 통해 불릴 때는 상관이 없는데, 메인 프로그램 내에 있을 경우는 이 함수를 호출하기 전에 my 선언이 먼저 실행되도록 배치해야 한다. 이 블록 전체를 메인 프로그램 앞부분에 두거나, BEGIN 블록을 사용한다, perlmod의 "BEGIN, UNITCHECK, CHECK, INIT and END" 섹션 참조

    BEGIN {
        my $secret_val = 0;
        sub gimme_another {
            return ++$secret_val;
        }
    }

• 그 파일 내의 모든 함수에서 사용 가능
• 파일 외부에서는 접근할 수 없음
• 모듈 내에서 공용으로 사용하는 private 변수를 만들 때 사용 가능

1.2.3. local()을 통한 임시값 ( Temporary Values via local() )

• 불가피한 경우는 전역 특수 변수나 전역 파일핸들, 심볼 테이블을 직접 접근할 때 등이다
• 호출되는 서브루틴 쪽에서도 변수값을 볼 수 있어야 할 때 local이 많이 사용됨

    # 값의 지역화

    local $foo;                 # $foo를 동적으로 지역화
    local (@wid, %get);         # 변수의 리스트를 지역화
    local $foo = "flurp";       # $foo를 지역화하고 초기화
    local @oof = @bar;          # @oof를 지역화하고 초기화

    local $hash{key} = "val";   # 특정 해쉬 엔트리에 지역화된 값을 설정
    delete local $hash{key};    # 현재 블록에서만 이 엔트리를 삭제
    local ($cond ? $v1 : $v2);  # 다양한 형태의 L밸류가 지역화를 지원한다

    # 심볼의 지역화

    local *FH;                  # $FH, @FH, %FH, &FH  ... 를 지역화
    local *merlyn = *randal;    # 이제 $merlyn 은 실제로는 $randal 
                                #      @merlyn 은 실제로는 @randal, 등등
    local *merlyn = 'randal';   # 위와 동일: 'randal' 은 *randal 로 승격됨
    local *merlyn = \$randal;   # $merlyn 만 별칭으로 만들고, @merlyn 등 나머지는 아니다

• 전역 변수(즉 패키지 변수)에 일시적인 임시값을 할당
• 지역 변수를 생성하는게 아니다
• 동적 스코핑(dynamic scoping)이라 불림
  • 반면에 렉시컬 스코핑은 my를 사용하여 하며, C의 auto 선언과 유사하게 동작한다.

• 해쉬와 배열의 엘리먼트, 슬라이스
• 조건식 (결과가 지역화될 수 있는 형태인 경우)
• 심볼릭 레퍼런스
• 이 경우 단순 변수와 마찬가지로, 동적 스코프를 적용받는 새로운 값을 생성한다.

• 괄호 안의 인자 리스트에 있는 변수들의 현재 값을 숨겨진 스택에 저장해 두고, 블록이나 서브루틴, eval 등을 빠져나갈 때 그 값을 복원한다.
• 스코프 내에서 다른 서브루틴을 호출할 경우 그 서브루틴에서도 지역화된 값을 참조할 수 있게 된다. 반대로 원래의 전역 변수의 값에는 접근할 수 없다
• 인자 리스트에 할당을 함으로써 초기화를 할 수 있다. (초기화하지 않을 경우 undef 값이 들어있는 상태로 생성됨)

1.2.3.1. local()의 문법에 관하여 ( Grammatical note on local() )

• 다음 두 구문은 우변에 리스트 문맥을 적용한다:

    local($foo) = <STDIN>;
    local @FOO = <STDIN>;

• 다음 구문은 우변에 스칼라 문맥을 적용한다:

    local $foo = <STDIN>;

1.2.3.2. 특수 변수들의 지역화 ( Localization of special variables )

• 이 특성 때문에 다음과 같은 것이 가능하다:

    # FILE의 전체 내용을 $slurp에 저장
    { local $/ = undef; $slurp = <FILE>; }

• perl 5.9.0 이후 코드에서는 다음 구문을 실행하면 Modification of a read-only value attempted 에러를 내며 죽는다. $1 변수는 특수 변수이며 읽기 전용이기 때문이다:

    local $1 = 2;

• 다음 코드도 유사한데 좀 더 원인을 찾기 어렵다:

    sub f { local $_ = "foo"; print }
    for ($1) {
        # 이 지점에서 $_ 는 $1의 별칭이고, $1은 특수 변수이며 읽기전용이다
        f();
    }

• 이 상황의 대안은 다음 섹션 참조

1.2.3.3. glob 지역화 ( Localization of globs )

local *name;

• 이 glob 슬롯에 들어있는 모든 변수($name, @name, %name, &name, name파일핸들)가 동적으로 리셋된다
• 이 변수들에 의해 수행되는 모든 특수기능(magic)들이 사라지게된다.
  • 예를 들어 local */는 "입력 레코드 구분자"11의 내부 값에 영향을 미치지 않는다.
• 특히, 디폴트 스칼라 변수인 $_에 완전히 새로운 값을 할당하면서, 위 섹션에서 언급했듯이 $_가 특수한 값을 담고 있는 경우 발생할 수 있는 문제점을 피하려면, local $_ 대신에 local */를 사용해야 한다.
  • perl 5.9.1 부터는 $_의 렉시컬 형태(my $_로 선언한다)를 써서 이 문제를 완전히 피할 수 있다.

1.2.3.4. 구조형 변수의 원소 지역화 ( Localization of elements of composite types )

• 그 원소의 이름을 가지고 지역화 대상으로 삼는다
  • local()이 적용되는 스코프가 끝났을 때, local()에서 명명했던 이름을 키값으로 하는 해쉬원소의 기존 값이 복원된다. 배열의 경우는 명명됐던 인덱스에 해당하는 원소의 값이 복원된다.
• local()이 적용된 상태에서 원소가 제거되었을 경우(해쉬에서 delete()를 쓰거나 배열에shift를 하는 경우처럼), 복원될 때 배열이 확장될 수 있고 이 때 중간에 끼인 원소들은 undef 값을 갖게 된다.
  • 다음 코드를 실행하면:

    %hash = ( 'This' => 'is', 'a' => 'test' );
    @ary  = ( 0..5 );
    {
         local($ary[5]) = 6;
         local($hash{'a'}) = 'drill';
         while (my $e = pop(@ary)) {
             print "$e . . .\n";
             last unless $e > 3;
         }
         if (@ary) {
             $hash{'only a'} = 'test';
             delete $hash{'a'};
         }
    }
    print join(' ', map { "$_ $hash{$_}" } sort keys %hash),".\n";
    print "The array has ",scalar(@ary)," elements: ",
          join(', ', map { defined $_ ? $_ : 'undef' } @ary),"\n";

• 다음과 같이 출력된다.12

    6 . . .
    4 . . .
    3 . . .
    This is a test only a test.
    The array has 6 elements: 0, 1, 2, undef, undef, 5

1.2.3.5. 구조형 변수의 원소를 지역화 후 삭제 ( Localized deletion of elements of composite types )

주인장 주: perl 5.12 부터 지원하는 기능으로, 5.10에서는 마지막 예제 코드를 실행하면 설명과 다른 결과가 나옴

• 이 구문들은 지역화하기 전에 담겨 있던 값을 반환한다.
• 다음 코드와 동등하다. 단 다음 코드들에서 local의 스코프가 do 블록으로 한정된다는 것이 다르다13:

# 배열의 경우
    do {
        my $val = $array[$idx];
        local  $array[$idx];
        delete $array[$idx];
        $val
    }

# 해쉬의 경우
    do {
        my $val = $hash{key};
        local  $hash{key};
        delete $hash{key};
        $val
    }

• 슬라이스에도 사용할 수 있다:

    my %hash = (
     a => [ 7, 8, 9 ],
     b => 1,
    );

    {
     my $a = delete local $hash{a};
     # $a 는 [ 7, 8, 9 ]
     # %hash 는 (b => 1)

     {
      my @nums = delete local @$a[0, 2];
      # @nums 은 (7, 9)
      # $a 는 [ undef, 8 ] ($a[2]는 완전히 사라졌고 $a[0]은 undef으로 채워졌다)

      $a[0] = 999; # 이 값은 스코프가 끝나면서 제거될 것이다
     }
     # $a 는 [ 7, 8, 9 ]

    }
    # %hash is back to its original state

1.2.4. L밸류 서브루틴 ( Lvalue subroutines )

• 서브루틴을 선언할 때 L밸류를 반환한다고 선언:

    my $val;
    sub canmod : lvalue {
        # return $val; 이건 동작하지 않는다. "return"을 쓰지 말 것
        $val;
    }
    sub nomod {
        $val;
    }

    canmod() = 5;   # $val에 할당된다
    nomod()  = 5;   # 에러

• 다음의 좌우 두 서브루틴은 스칼라 문맥에서 호출된다:

    data(2,3) = get_data(3,4);

• 다음 경우는 모든 서브루틴이 리스트 문맥에서 호출된다:

    (data(2,3)) = get_data(3,4);
    (data(2),data(3)) = get_data(3,4);

• 편해보이지만, 여러 가지 이유로 인해 사용에 주의를 기울여야 한다
• return 키워드를 사용할 수 없고, 서브루틴 스코프의 밖으로 나가기 전에 값을 전달해야 한다. 이것 자체가 문제는 아닌데, 다중으로 중첩된 루프 내에서 명시적으로 리턴하는 것이 불가능해진다.
• 캡슐화를 어기게 된다. 보통 뮤테이터14는 자신이 보호하는 속성값을 설정하기 전에 이 값이 올바른지 체크를 하는데, L밸류 서브루틴은 그럴 수 없다:

    my $some_array_ref = [];    # 뮤테이터가 보호해 줄까??

    sub set_arr {               # 보통의 뮤테이터
        my $val = shift;
        die("expected array, you supplied ", ref $val)
           unless ref $val eq 'ARRAY';
        $some_array_ref = $val;
    }
    sub set_arr_lv : lvalue {   # L밸류 뮤테이터
        $some_array_ref;
    }

    # set_arr_lv는 다음과 같은 코드를 방지할 수 없다!
    set_arr_lv() = { a => 1 };

1.2.5. 심볼테이블 엔트리 넘겨주기 (typeglobs) ( Passing Symbol Table Entries (typeglobs) )

• *foo처럼, 이름 앞에 별표를 붙여서 그 이름에 해당되는 모든 오브젝트를 참조할 수 있다.
• 이것을 "typeglob"라고 부른다

    sub doubleary {
        local(*someary) = @_;
        foreach $elem (@someary) {
            $elem *= 2;
        }
    }
    doubleary(*foo);
    doubleary(*bar);

1.2.6. 여전히 local()을 사용해야 하는 경우들 ( When to Still Use local() )

• @ARGV나 특수문자변수들은 local()을 사용하여 지역화하여야 한다.
• 아래 코드는 /etc/motd 파일을 읽고, 등호로 이루어진 라인들을 구분자로 삼아서 여러 덩어리로 분리한 후 @Fields 배열에 담는다:

    {
        local @ARGV = ("/etc/motd");
        local $/ = undef;
        local $_ = <>;
        @Fields = split /^\s*=+\s*$/;
    }

• 특히, $_에 값을 할당하는 루틴 안에서는 $_를 지역화하는 것이 중요하다. while 조건문 안에서는 묵시적으로 할당하는 곳을 살펴보라16

• 자신만의 파일핸들이 필요한 함수는 완전한 타입글로브를 대상으로 local()을 사용하여야 한다. 이것은 새로운 심볼 테이블 엔트리를 생성할 때 사용할 수 있다:

    sub ioqueue {
        local  (*READER, *WRITER);    # my가 아니다!
        pipe    (READER,  WRITER) or die "pipe: $!";
        return (*READER, *WRITER);
    }
    ($head, $tail) = ioqueue();

• 익명 심볼 테이블 엔트리를 생성하는 방법은 Symbol 참조
• 타입글로브에 레퍼런스를 할당하면 별칭(alias)가 생성되며, 이것은 지역화된 함수(또는 정확히는 지역화된 별칭)을 생성하는 데 사용된다:

    {
        local *grow = \&shrink; # 이 블록이 끝날 때까지만
        grow();                 # 실제로는 shrink()를 호출한다
        move();                 # 만일 move() 안에서 grow()를 호출한다면 그때도 shrink()가 호출된다
    }
    grow();                     # 진짜 grow()를 호출

• 함수의 이름을 가지고 함수를 조작하는 것에 대해 더 자세한 내용은 perlref의 "Function Templates" 섹션 참조

• 집합적 데이타의 원소 하나만 지역화할 수 있다.
• 보통은 동적 데이타를 대상으로17 사용:

    {
        local $SIG{INT} = 'IGNORE';
        funct();                            # 인터럽트 불가능한 상태로 수행
    }
    # 여기서 인터럽트 가능여부가 자동으로 복원된다

• 렉시컬 데이타에도 사용가능
• Perl 5.5 이전 버전에서는 예상대로 동작하지 않을 수 있음

1.2.7. 참조에 의한 전달 ( Pass by Reference )

• 레퍼런스에 대한 자세한 내용은 perlref 참조

• 여러 개의 배열을 함수에 전달하고 각 배열에 pop을 수행한 후 그렇게 뽑아낸 원소들의 리스트를 반환:

    @tailings = popmany ( \@a, \@b, \@c, \@d );

    sub popmany {
        my $aref;
        my @retlist = ();
        foreach $aref ( @_ ) {
            push @retlist, pop @$aref;
        }
        return @retlist;
    }

• 해쉬들을 함수에 전달하여 모든 해쉬에 공통으로 들어있는 키들의 리스트를 반환:

    @common = inter( \%foo, \%bar, \%joe );
    sub inter {
        my ($k, $href, %seen); # locals
        foreach $href (@_) {
            while ( $k = each %$href ) {
                $seen{$k}++;
            }
        }
        return grep { $seen{$_} == @_ } keys %seen;
    }

    (@a, @b) = func(@c, @d);
또는
    (%a, %b) = func(%c, %d);

• 위 코드는 @a와 %a에 모든 리턴값이 들어가고 @b와 %b는 깨끗이 비게 된다. 또한 함수는 두 개의 분리된 배열이나 해쉬를 전달받을 수 없고, 항상 하나의 긴 리스트 @_를 받는다.

• 두 개의 배열 레퍼런스를 인자로 받고, 두 개의 배열 레퍼런스를 반환하는데 이 때 원소의 갯수가 큰 순으로 반환하는 함수:

    ($aref, $bref) = func(\@c, \@d);
    print "@$aref has more than @$bref\n";
    sub func {
        my ($cref, $dref) = @_;
        if (@$cref > @$dref) {
            return ($cref, $dref);
        } else {
            return ($dref, $cref);
        }
    }

• 이렇게도 할 수 있다:

    (*a, *b) = func(\@c, \@d);
    print "@a has more than @b\n";
    sub func {
        local (*c, *d) = @_;
        if (@c > @d) {
            return (\@c, \@d);
        } else {
            return (\@d, \@c);
        }
    }

• 여기서는 타입글로브를 써서 심볼 테이블의 별칭을 만들었다. 그러나 이런 방식은 좀 미묘한 구석이 있고, my 변수들을 사용하고 있다면 제대로 동작하지 않는다. 심볼 테이블에는 전역 변수(local로 지역화한 경우라도)만 들어있기 때문이다.

    splutter(\*STDOUT);
    sub splutter {
        my $fh = shift;
        print $fh "her um well a hmmm\n";
    }

    $rec = get_rec(\*STDIN);
    sub get_rec {
        my $fh = shift;
        return scalar <$fh>;
    }

    sub openit {
        my $path = shift;
        local *FH;
        return open (FH, $path) ? *FH : undef;
    }

주인장 코멘트:

openit()을 호출하는 쪽에서는 *IN = openit()와 같이 파일핸들 타입글로브를 쓸 수도 있는데, 이 경우 openit()이 undef을 반환할 경우 경고가 뜬다.

최신 Perl에서는 파일핸들을 스칼라변수에 담아 쓸 수 있으므로, my $in = openit()와 같이 사용하는 것이 낫지 싶다.

1.2.8. 프로토타입 ( Prototypes )

• 다음과 같이 선언할 경우, mypush는 push()와 똑같은 형태의 인자를 받는다:

    sub mypush (\@@)

• 함수 선언은 컴파일 타임에 보여야 한다18
• 프로토타입은 신식 스타일, 즉 &를 함수명 앞에 쓰지 않는 스타일로 함수를 호출할 때만 영향을 끼친다.
• \&foo와 같은 서브루틴 레퍼런스나 &{$subref}또는 $subref->()와 같은 간접 호출에는 적용되지 않는다.
• 메쏘드 호출19도 프로토타입의 영향을 받지 않는다. 실제로 호출될 함수가 무엇인지는 상속 관계에 따라 달라지므로 컴파일 시간에 결정할 수 없기 때문이다.

• 대응되는 내장함수와 거의 정확히 동일하게 구문이 해석되는 함수들의 프로토타입 예제:

    아래와 같이 선언하고       아래와 같이 호출함

    sub mylink ($$)          mylink $old, $new
    sub myvec ($$$)          myvec $var, $offset, 1
    sub myindex ($$;$)       myindex &getstring, "substr"
    sub mysyswrite ($$$;$)   mysyswrite $buf, 0, length($buf) - $off, $off
    sub myreverse (@)        myreverse $a, $b, $c
    sub myjoin ($@)          myjoin ":", $a, $b, $c
    sub mypop (\@)           mypop @array
    sub mysplice (\@$$@)     mysplice @array, 0, 2, @pushme
    sub mykeys (\%)          mykeys %{$hashref}
    sub myopen (*;$)         myopen HANDLE, $name
    sub mypipe (**)          mypipe READHANDLE, WRITEHANDLE
    sub mygrep (&@)          mygrep { /foo/ } $a, $b, $c
    sub myrand (;$)          myrand 42
    sub mytime ()            mytime

• \[] 표기를 사용하여 여러 인자 타입에 동시에 백슬래쉬를 적용할 수 있다:

    sub myref (\[$@%&*])

• 위와 같이 선언된 함수는 아래와 같이 호출할 수 있다:

    myref $var
    myref @array
    myref %hash
    myref &sub
    myref *glob

• 실제로 myref()로 넘어가는 첫번째 인자는 스칼라,배열,해쉬,코드,글로브의 레퍼런스가 된다.

• @와 %는 남아있는 인자 전부를 모아서 사용하고, 리스트 문맥을 강제한다
• $는 스칼라 문맥을 강제한다.
• &는 익명 서브루틴을 요구한다. 이 익명 서브루틴이 첫번째 인자일 경우는 sub키워드나, 뒤에 오는 컴마를 생략할 수 있다20
• *는 서브루틴이 bareword, 상수, 스칼라 식, 타입글로브, 타입글로브의 레퍼런스 등을 받아들일 수 있음을 의미한다.
  • 서브루틴 쪽에서는 넘어온 인자를 단순한 스칼라 값 또는 (타입글로브 또는 타입글로브의 레퍼런스를 전달한 경우) 타입글로브의 레퍼런스로 받는다.
  • 이 인자들을 언제나 타입글로브 레퍼런스로 변환하려면 Symbol::qualify_to_ref()를 사용하라:

    use Symbol 'qualify_to_ref';

    sub foo (*) {
        my $fh = qualify_to_ref(shift, caller);
        ...
    }

• 나머지 인자를 전부 취하게 되는 @나 % 앞에는 쓸 필요가 없다.21

• 만일 호출할 때 인자가 없다면 $_가 대신 쓰이게 된다.

• mygrep()은 순수하게 리스트 연산자로만 해석된다.
• myrand()는 rand()와 같은 단항 우선순위를 갖는 단항연산자로만 해석된다
• mytime()은 time()처럼 순수하게 인자가 없는 연산자로 해석된다
  • 따라서 다음 코드는 mytime() + 2를 얻게 된다. 프로토타입이 없었다면 mytime(2)로 해석되었을 것이다:

    mytime +2;

• 이 코드는 "unphooey"를 출력한다.

    sub try (&@) {
        my($try,$catch) = @_;
        eval { &$try };
        if ($@) {
            local $_ = $@;
            &$catch;
        }
    }
    sub catch (&) { $_[0] }

    try {
        die "phooey";
    } catch {
        /phooey/ and print "unphooey\n";
    };

    sub mygrep (&@) {
        my $code = shift;
        my @result;
        foreach $_ (@_) {
            push(@result, $_) if &$code;
        }
        @result;
    }

• 이런 문자숫자 조합은 차후에 이름이 부여된 형식인자(named,formal parameter)가 펄에 추가될 때를 위해 남겨져 있다.
• 현재의 방식의 주 목표는 모듈을 작성하는 사람이 모듈 사용자에게 더 좋은 사용법을 제공할 수 있게 하려는 것이다.
• 현재는 프로토타입 자리에 이런 알파벳과 숫자를 사용할 경우 "Illegal character in prototype"이라는 경고가 뜬다.
  • 오래된 버전의 Perl에서는 접두어가 올바른 프로토타입일 경우 이렇게 알파벳과 숫자가 들어간 프로토타입을 쓸 수 있었다. 당시 그런 프로토타입을 썼던 코드들의 대부분이 수정되고 나면 향후 Perl 버전에서는 경고 대신 치명적 에러가 나도록 고쳐질 것이다.22

• 프로토타입을 적용함으로써 리스트 문맥과 스칼라 문맥의 구분을 사용자가 모르는 새 강제하게 될 수 있기 때문이다
• 예:
  • 함수가 오직 하나의 인자만 받아야 한다고 결정했다고 하자:

    sub func ($) {
        my $n = shift;
        print "you gave me $n\n";
    }

• 만일 누군가 기존에 이 함수를 배열이나, 리스트를 반환하는 식을 인자로 주어 호출했었다면:

    func(@foo);
    func( split /:/ );

• 프로토타입을 사용한 이후엔 위 코드의 인자 앞에 자동으로 scalar가 붙게 된다.
  • 원소가 하나인 @foo가 전달되지 않고, @foo의 원소의 갯수인 1이 전달된다.
  • split이 스칼라 문맥에서 호출되게 되어, @_ 인자리스트를 엉망으로 만들 것이다

1.2.9. 상수 함수 ( Constant Functions )

• 함수를 최적화 및 상수폴딩23한 후의 결과가 상수값이거나, 다른 레퍼런스가 없고 렉시컬 스코프를 갖는 스칼라인 경우, &를 붙이지 않은 형태의 함수호출 자리에 치환되어 사용된다.
• &를 붙인 형태의 호출은 인라인이 되지 않는다
• 상수를 선언하는 쉬운 방법은 constant 참조

    sub pi ()           { 3.14159 }             # 정확한 값은 아니고 근사치.
    sub PI ()           { 4 * atan2 1, 1 }      # 최대한 정확하며, 인라인함수가 된다!

    sub ST_DEV ()       { 0 }
    sub ST_INO ()       { 1 }

    sub FLAG_FOO ()     { 1 << 8 }
    sub FLAG_BAR ()     { 1 << 9 }
    sub FLAG_MASK ()    { FLAG_FOO | FLAG_BAR }

    sub OPT_BAZ ()      { not (0x1B58 & FLAG_MASK) }

    sub N () { int(OPT_BAZ) / 3 }

    sub FOO_SET () { 1 if FLAG_MASK & FLAG_FOO }

    sub foo_set () { if (FLAG_MASK & FLAG_FOO) { 1 } }

    sub baz_val () {
        if (OPT_BAZ) {
            return 23;
        }
        else {
            return 42;
        }
    }

• 미리 컴파일된 함수호출이, 함수가 재정의되기 전에 가지고 있었던 값을 얻게될 우려가 있기 때문.
• 서브루틴을 재정의해야 하는 경우, 서브루틴이 인라인이 되지 않는 것을 확실히 해 두라
  • () 프로토타입을 없애던가 (이 경우 호출 인터페이스가 달라지니 주의)
  • 인라인이 되지 못하도록 방해함:

    sub not_inlined () {
        23 if $];
    }

1.2.10. 내장 함수 오버라이드 ( Overriding Built-in Functions )

• 그러나 타당한 이유가 있을 때에만 하고, 자주 하는 것도 지양할 것
• 보통은 어떤 패키지에서 Unix 계열이 아닌 시스템에서 제대로 동작하지 않는 내장 함수의 기능을 모방하는데 사용함

• use subs 프라그마를 쓰면 import 문법을 사용하여 서브루틴을 미리 선언하고 내장 함수를 오버라이드할 수 있다:

    use subs 'chdir', 'chroot', 'chmod', 'chown';
    chdir $somewhere;
    sub chdir { ... }

• 예: 현재 패키지에 어디선가 불러온 &open()서브루틴이 있더라도, CORE::open()은 언제나 내장 함수 open()을 가리킨다.
• 이 형태는 정규적인 함수 호출처럼 보이지만 실제로는 그렇지 않다, \&CORE::open과 같은 식으로 레퍼런스를 얻을 수 없다.

• 다른 사용자의 네임스페이스에서 예상하지 못한 의미의 변경을 초래할 수 있기 때문이다.
• 대신 @EXPORT_OK 목록에 넣어서 사용자가 그 이름을 명시적으로 임포트하여 쓸 수 있게 한다.
  • 다음과 같이 선언하여 명시적으로 open을 불러와서 오버라이드할 수 있다:

    use Module 'open';

• 다음과 같이 하면 오버라이드하는 함수들을 제외하고 디폴트 목록만 임포트한다:

    use Module;

• glob 연산자를 오버라이드하여 정규표현식을 인식할 수 있도록 한 예:

    package REGlob;
    require Exporter;
    @ISA = 'Exporter';
    @EXPORT_OK = 'glob';

    sub import {
        my $pkg = shift;
        return unless @_;
        my $sym = shift;
        my $where = ($sym =~ s/^GLOBAL_// ? 'CORE::GLOBAL' : caller(0));
        $pkg->export($where, $sym, @_);
    }

    sub glob {
        my $pat = shift;
        my @got;
        if (opendir my $d, '.') {
            @got = grep /$pat/, readdir $d;
            closedir $d;
        }
        return @got;
    }
    1;

• 위 코드를 사용하는 예:

    #use REGlob 'GLOBAL_glob';      # 모든 네임스페이스에서 glob()을 오버라이드하는 경우
    package Foo;
    use REGlob 'glob';              # Foo:: 안에서만 glob()을 오버라이드
    print for <^[a-z_]+\.pm\$>;     # 이름이 소문자로만 된 프라그마 모듈들을 출력

• 위 예의 첫번째 라인에서처럼 glob을 전역적으로 오버라이드할 경우 모든 네임스페이스에서 glob의 동작이 변경되게 되며, 그 네임스페이스를 담당하는 모듈 쪽에서 그 사실을 인지하지 못 할 수 있다. 따라서 이런 오버라이드는 꼭 필요한 경우에만 극도로 주의를 기울여서 행하라.
• 위 예의 REGlob은 perl의 glob을 오버라이드하기 위해 필요한 모든 기능을 제공하고 있지는 않다. 내장 glob은 스칼라 또는 리스트 문맥에서 호출되었을 때 서로 다르게 동작한다. 사실 많은 perl 내장 함수들이 이렇게 문맥에 따라 다르게 동작하며, 오버라이드할 경우 이런 동작을 지원해주어야 한다. glob을 오버라이드하며 모든 기능을 지원하는 예는 표준 라이브러리에 있는 File::DosGlob을 살펴보라.

• 적절한 프로토타입을 사용
• 내장 함수의 프로토타입을 알아보기 위해서는 prototype 함수에 "CORE::내장함수이름" 인자를 넣으면 된다. (perlfunc의 "prototype" 참조)

1.2.11. 자동 로드 ( Autoloading )

• 그러나 AUTOLOAD 서브루틴이 그 패키지 또는 원래 서브루틴을 검색하는 데 사용되는 패키지 중에 정의되어 있을 경우, 이 서브루틴이 호출되며 원래의 서브루틴에 넘어갈 인자가 이 서브루틴으로 넘어간다.
• 원래 서브루틴의 fully qualified된 이름은 AUTOLOAD 루틴이 있는 패키지에 속한 $AUTOLOAD 전역 변수에 담긴다.
• 예외적으로 존재하지 않는 import 또는 unimport메쏘드를 호출하는 것은 그냥 무시된다.

• 정의되지 않은 함수는 system을 호출하여 실행하도록 하는 예:

    sub AUTOLOAD {
        my $program = $AUTOLOAD;
        $program =~ s/.*:://;
        system($program, @_);
    }
    date();
    who('am', 'i');
    ls('-l');

• 각 함수를 저렇게 호출할 것을 미리 선언하면 괄호까지 생략가능하다:

    use subs qw(date who ls);
    date;
    who "am", "i";
    ls '-l';

1.2.12. 서브루틴 속성 ( Subroutine Attributes )

이 섹션의 내용은 주인장도 잘 모르는 부분이라, 번역에 오류가 있을 가능성이 높습니다

• 이런 속성 목록이 존재할 경우, use attributes 프라그마를 사용한 것처럼 목록을 콜론 또는 공백을 구분자로 해서 각각을 나눈 후에 처리된다.
• 현재 지원되는 속성들에 대해서는 attributes 참조
• 구식 방법은 use attrs와는 달리, sub : 속성리스트 형태의 문법은 꼭 서브루틴 정의 안에 있어야 되는 게 아니라 미리 선언하는 곳에 있어도 된다.

    sub fnord (&\%) : switch(10,foo(7,3))  :  expensive;
    sub plugh () : Ugly('\(") :Bad;
    sub xyzzy : _5x5 { ... }

    sub fnord : switch(10,foo();  # 괄호의 좌우 쌍이 맞지 않음
    sub snoid : Ugly('(');        # 괄호의 좌우 쌍이 맞지 않음
    sub xyzzy : 5x5;              # "5x5"는 올바른 식별자가 아님
    sub plugh : Y2::north;        # "Y2::north"는 간단한 식별자가 아님
    sub snurt : foo + bar;        # "+"는 콜론도 공백도 아님

    use attributes __PACKAGE__, \&plugh, q[Ugly('\(")], 'Bad';

1.3. 참고

• 레퍼런스와 클로저에 관해서는 perlref의 "Function Templates" 참조
• Perl에서 C 서브루틴을 호출하는 것은 perlxs 참조
• C에서 Perl 서브루틴을 호출하는 것은 perlembed 참조
• 함수들을 여러 분리된 파일로 포장하는 것은 perlmod 참조
• 자신의 시스템에 표준으로 제공되는 라이브러리 모듈들은 perlmodlib 참조
• OOP에서 객체 메쏘드 호출을 하는 법은 perltoot 참조

2. 다른 문서들에서

2.1. 선언 순서

• setup();처럼 괄호를 붙여주면 나중에 정의할 수 있다.
  • &setup;처럼 쓸 수도 있다 - Perl 4에서의 형태
• setup; 과 같은 bareword 형태로 호출하기 위해서는 그 전에 서브루틴 정의가 있어야 한다.
• forward definition(pre-declaring)

sub setup;         # 이름만 선언
# 또는
use subs qw(setup get_input 등등);

setup;             # 사용
sub setup { ... }  # 실제 정의

2.2. Context

• 리스트 문맥에서 수행 중이라면 true
• 스칼라 문맥이었다면 false
• void 문맥이었다면 undef

sub foo {
    my $wa = wantarray;

    if ( not defined $wa ) {        # 정의되지 않는다면 void 문맥
        print "void context\n";
    }
    elsif ( $wa ) {                 # 값이 참이면 list 문맥
        print "list context\n";
    }
    else {                          # 정의되었으나 거짓이면 scalar 문맥
        print "scalar context\n";
    }

    return 3;       # 어쨌거나 리턴값은 3
}

my $scalar;
my @array;

foo();                          # void

( foo() );                      # void

()          = foo();            # list

$scalar     = foo();            # scalar
print "scalar = [$scalar]\n";   # 3

( $scalar ) = foo();            # list
print "scalar = [$scalar]\n";   # 3

$scalar     = ( foo() );        # scalar !!
print "scalar = [$scalar]\n";   # 3

$scalar     = ( () = foo() );   # list
print "scalar = [$scalar]\n";   # 1 !!

@array      = foo();            # list
print "array  = ", join(":", @array), "\n"; # ( 3 )

$array[foo()] = 10;             # scalar
print "array  = ", join(":", @array), "\n"; # ( 3, undef, undef, 10 )

@array[foo()] = 20;             # list
print "array  = ", join(":", @array), "\n"; # ( 3, undef, undef, 20 )

2.3. Prototype

• 서브루틴을 호출하기 전에 프로토타입을 볼 수 있어야 하므로, 정의를 먼저 해 주던가 forward definition이 필요하다. 이 경우 실제 정의하는 부분과 프로토타입이 일치해야 함

sub sum_of_two_squares ($$);

print sum_of_two_squares($first, $second),"\n";

# print sum_of_two_squares($first, $second, 0),"\n";  <- 이건 에러

sub sum_of_two_squares ($$) {
   my ($a,$b) = (shift, shift);
   return $a**2+$b**2;
}

2.4. 인자로 레퍼런스 넘겨주기

my $a = 5;
increment(\$a);

sub increment(\$);
my $a = 5;
increment($a);
sub increment(\$) {
   my $reference = shift;
   $$reference++;
}

2.5. 인자로 파일핸들 넘겨주기

2.6. Named parameter

• 인자의 순서를 신경쓸 필요가 없음.
• 인자의 갯수가 많고, optional한 경우에 매우 유용하다.

logon(username => $name, password => $pass, host => $hostname);

sub logon {
   die "Parameters to logon should be even" if @_ % 2;
   my %args = @_; # 넘어온 인자로 해쉬 구성
   print "Logging on to host $args{hostname}\n";
   ...
}

2.7. 서브루틴의 레퍼런스

sub something { print "Wibble!\n" }
my $ref = \&something;

# 익명 서브루틴
my $ref = sub { print "Wibble!\n" };

&{$ref};
&{$ref}(@parameters);
&$ref(@parameters);

# 아래의 형태를 권장
$ref->();
$ref->(@parameters);

2.8. Closure

• /Closure 참조

use File::Find;

# 현재 디렉토리 이하의 파일들 모두의 크기의 합을 구함
my $total_size = 0;
# File::Find 모듈은 $total_size에 접근할 수 없지만,
# 그 모듈이 콜백 함수로 호출하는 익명 서브루틴은 $total_size에 접근할 수 있다.
find(sub { $total_size += -s if -f }, '.');
print $total_size, "\n";

use File::Find;

my $callback;
{
  my $count = 0;
  $callback = sub { print ++$count, ": $File::Find::name\n" };
}
# 이 시점에서 $count는 스코프를 벗어나지만, (따라서 접근할 수는 없지만)
# $callback이 레퍼런스 하는 익명 서브루틴에 의해 참조되므로 레퍼런스 카운트가 0이 아니고,
# 저 익명 서브루틴의 레퍼런스가 존재하는 한 메모리에 여전히 존재한다.
find($callback, '.');

2.9. 서브루틴을 반환하는 서브루틴

use File::Find;

sub create_find_callback_that_counts {
  my $count = 0;
  return sub { print ++$count, ": $File::Find::name\n" };
}

my $callback = create_find_callback_that_counts(  );
# bin/ 아래의 파일들은 1번부터 번호가 부여되고
print "my bin:\n";
find($callback, 'bin');
# lib/ 아래의 파일들은 bin/ 파일의 마지막 번호 다음부터 번호가 부여된다.
# 동일한 $count를 사용하기 때문
print "my lib:\n";
find($callback, 'lib');

# 아래의 경우는, 서로 다른 $count 인스턴스를 사용하기 때문에 각각 번호가 1부터 부여된다.
my $callback1 = create_find_callback_that_counts(  );
my $callback2 = create_find_callback_that_counts(  );
print "my bin:\n";
find($callback1, 'bin');
print "my lib:\n";
find($callback2, 'lib');

use File::Find;

sub create_find_callbacks_that_sum_the_size {
  my $total_size = 0;
  # 두 개의 익명 서브루틴이 $total_size를 공유
  return(sub { $total_size += -s if -f }, sub { return $total_size });
}

## set up the subroutines
my %subs;
foreach my $dir (qw(bin lib man)) {
  my ($callback, $getter) = create_find_callbacks_that_sum_the_size(  );
# bin, lib, man 세 디렉토리에 대하여 각각 별개의 콜백 서브루틴과 getter가 생성된다.
  $subs{$dir}{CALLBACK}   = $callback;
  $subs{$dir}{GETTER}     = $getter;
}

## gather the data
for (keys %subs) {
  find($subs{$_}{CALLBACK}, $_);
}

## show the data
for (sort keys %subs) {
  my $sum = $subs{$_}{GETTER}->(  );
  print "$_ has $sum bytes\n";
}

2.10. closure variable를 static local variable로 쓰기

{ # naked block 안에서
  my $count;
  sub count_one { ++$count }
  sub count_so_far { return $count }
}
# 이 시점에서 $count는 스코프를 벗어났기 때문에 직접 접근할 수는 없지만
# count_one과 count_so_far는 closure이고 블록 밖에서도 유지가 되므로
# 그 안에서는 계속 $count를 사용 가능하다

count_one(  );
count_one(  );
count_one(  );
print 'we have seen ', count_so_far(  ), " coconuts!\n";  # 3 coconuts

{
# 이 블록은 count_down()을 호출하는 시점보다 먼저 나와야 한다.
# countdown의 초기값을 먼저 10으로 만들어주어야 하기 때문
  my $countdown = 10;
  sub count_down { $countdown-- }
  sub count_remaining { $countdown }
}

count_down(  );
count_down(  );
count_down(  );
print 'we're down to ', count_remaining(  ), " coconuts!\n";

BEGIN {
  my $countdown = 10;
  sub count_down { $countdown-- }
  sub count_remaining { $countdown }
}

2.11. 서브루틴을 인자로 넘기기

• 서브루틴 프로토타입을 반드시 써주어야 함. ("&"을 사용)
• 예: (아래 코드의 주석은 주인장이 책의 내용을 참고하여 추가한 것이라서 틀렸을 수 있음)

use List::Util;
# reduce 라는 서브루틴은 인자로 서브루틴과 리스트를 받아서, 서브루틴을 사용하여 리스트의 원소들로부터 스칼라 하나를 생성한다.
my $sum = reduce { $a + $b } @list;   # 모든 원소의 합을 구하는 경우


# reduce 의 구현
package List::Util;

sub reduce (&@) {
    my $code = shift;
    no strict 'refs';

    return shift unless @_ > 1;

    use vars qw($a $b);

    my $caller = caller;

    # reduce 를 호출한 쪽에서 바라보는 $a와 $b는 호출한 쪽 패키지의 패키지 변수이다.
    # reduce 안에서 사용하는 $a와 $b는 렉시컬 변수이다.
    # 따라서 이 둘을 서로 alias 해주어야 함

    # local()을 해 주지 않으면 호출한 쪽의 패키지 변수 $a, $b 가 계속 여기에 alias되어 있어서 곤란하다.
    local(*{$caller."::a"}) = \my $a;
    local(*{$caller."::b"}) = \my $b;

    $a = shift;
    foreach (@_) {
        $b = $_;
        $a = &{$code}();
        print "now a = $a, b = $b\n";
    }

    $a;
}

• 주인장 생각으로는 $a와 $b를 my 변수로 선언하고 있기 때문에, use vars 구문은 사실 없어도 상관없어 보인다. 실제로 없애고 테스트해도 잘 동작하고...

3. 기타

• /컨텍스트
• /익명서브루틴의재귀호출
• [Understand why you probably don’t need prototypes | The Effective Perler] - 프로토타입에 관한 얘기
• [Make grep-like syntax | The Effective Perler]
• [Return error objects instead of throwing exceptions | The Effective Perler]
• [Perl 서브루틴의 가변 길이 파라메터 -- Perl Maven]

4. Comments