Str — 내장 문자열 타입

문자열을 위한 내장 클래스예요. Str 타입의 객체는 불변(immutable) 이에요. 한 번 만들어진 문자열은 바뀌지 않고, 변경 작업은 항상 새 문자열을 만들어 반환하죠.

출처: Raku Documentation — Str

본문

routine chop

multi method chop(Str:D:)
multi method chop(Str:D: Int() $n)

끝에서 $n개의 문자를 제거한 문자열을 반환해요. 원본 문자열은 변하지 않아요. 위치 인자 $n은 미리 Int로 변환돼요.

say "Whateverable".chop(3.6);  # OUTPUT: «Whatevera␤»
my $string= "Whateverable";
say $string.chop("3");         # OUTPUT: «Whatevera␤»

인자 없이 호출하면 딱 한 문자만 제거해요. 문자열에 제거할 문자 수보다 적은 문자가 있으면 결과는 빈 문자열이 돼요.

routine chomp

multi        chomp(Str:D  --> Str:D)
multi method chomp(Str:D: --> Str:D)

끝에서 논리적 새 줄(NEWLINE 속성을 가진 코드포인트)을 제거한 문자열을 반환해요.

예시:

say chomp("abc\n");       # OUTPUT: «abc␤»
say "def\r\n".chomp;      # OUTPUT: «def␤» NOTE: \r\n is a single grapheme!
say "foo\r".chomp;        # OUTPUT: «foo␤»

method contains

multi method contains(Str:D: Str:D $needle --> Bool)
multi method contains(Str:D: Str:D $needle, Int:D $pos --> Bool)
multi method contains(Str:D: Str:D $needle, :m(:$ignoremark)! --> Bool)
multi method contains(Str:D: Str:D $needle, :i(:$ignorecase)!, :m(:$ignoremark) --> Bool)
multi method contains(Str:D: Str:D $needle, Int:D $pos, :m(:$ignoremark)! --> Bool)
multi method contains(Str:D: Str:D $needle, Int:D $pos, :i(:$ignorecase)!, :m(:$ignoremark) --> Bool)
multi method contains(Str:D: Regex:D $needle --> Bool)
multi method contains(Str:D: Regex:D $needle, Int:D $pos --> Bool)

Str 호출자(여기선 haystack)와 첫 번째 인자(여기선 $needle)를 받아, 문자열의 처음부터 $needle을 찾고, 찾으면 True를 반환해요. 선택 인자 $pos를 주면 haystack을 문자열에서 $pos 문자 위치부터 검색해요.

say "Hello, World".contains('Hello');      # OUTPUT: «True␤»
say "Hello, World".contains('hello');      # OUTPUT: «False␤»
say "Hello, World".contains('Hello', 1);   # OUTPUT: «False␤»
say "Hello, World".contains(',');          # OUTPUT: «True␤»
say "Hello, World".contains(',', 3);       # OUTPUT: «True␤»
say "Hello, World".contains(',', 10);      # OUTPUT: «False␤»

첫 번째 경우, contains가 호출자 문자열의 맨 처음부터 'Hello'를 찾아 True를 반환해요. 세 번째 경우, 'Hello, World'의 두 번째 위치(인덱스 1)부터 찾기 시작했기 때문에 'Hello'를 찾지 못해요.

$needle은 Cool 타입일 수도 있고, 그러면 Str로 강제 변환돼요. 마찬가지로 $pos도 Cool일 수 있고, Int로 변환돼요. (기술적으로 이 경우들은 Cool.contains를 거쳐 변환 후 Str.contains를 호출해요.)

say "Hello, 12345".contains(5, "10.0");    # OUTPUT: «True␤»

Rakudo 2020.02 릴리스부터 $needle이 Regex일 수도 있어요. 이 경우 contains는 문자열이 그 정규식을 한 번이라도 매치하는지만 빠르게 반환해요. Match 객체는 만들어지지 않아서 비교적 빨라요.

say 'Hello, World'.contains(/\w <?before ','>/);    # OUTPUT: «True␤»
say 'Hello, World'.contains(/\w <?before ','>/, 5); # OUTPUT: «False␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignorecase(또는 :i)를 주면 $needle 검색 시 대문자·소문자·타이틀케이스 구분을 무시해요.

say "Hello, World".contains("world");              # OUTPUT: «False␤»
say "Hello, World".contains("world", :ignorecase); # OUTPUT: «True␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignoremark(또는 :m)를 주면 $needle 검색이 기본 문자만 고려하고 결합 악센트 같은 추가 부가 기호는 무시해요.

say "abc".contains("ä");               # OUTPUT: «False␤»
say "abc".contains("ä", :ignoremark);  # OUTPUT: «True␤»

List나 Array가 Str로 coerce되는 방식 때문에 결과가 때로 놀라울 수 있다는 점에 주의하세요.

say <Hello, World>.contains('Hello');    # OUTPUT: «True␤»
say <Hello, World>.contains('Hello', 0); # OUTPUT: «True␤»
say <Hello, World>.contains('Hello', 1); # OUTPUT: «False␤»

traps 문서를 참고하세요.

routine lc

multi        lc(Str:D  --> Str:D)
multi method lc(Str:D: --> Str:D)

문자열의 소문자 버전을 반환해요.

예시:

lc("A"); # OUTPUT: «"a"»
"A".lc;  # OUTPUT: «"a"»

routine uc

multi        uc(Str:D  --> Str:D)
multi method uc(Str:D: --> Str:D)

문자열의 대문자 버전을 반환해요.

routine fc

multi        fc(Str:D  --> Str:D)
multi method fc(Str:D: --> Str:D)

대소문자 구분 없는 문자열 비교에 적합한 Unicode "fold case" 연산을 수행해요. (일반적으로 반환된 문자열은 비교 목적 외에는 별로 쓸모가 없어요.)

routine tc

multi        tc(Str:D  --> Str:D)
multi method tc(Str:D: --> Str:D)

Unicode "titlecase" 연산을 수행해요. 문자열의 첫 문자를 titlecase로 바꾸고, 그 문자가 titlecase 매핑이 없으면 대문자로 바꿔요.

routine tclc

multi        tclc(Str:D  --> Str:D)
multi method tclc(Str:D: --> Str:D)

첫 문자는 titlecase로, 나머지 문자는 모두 소문자로 바꿔요.

routine wordcase

multi        wordcase(Cool $x  --> Str)
multi        wordcase(Str:D $x --> Str)
multi method wordcase(Str:D: :&filter = &tclc, Mu :$where = True --> Str)

$where와 일치하는 모든 단어에 &filter를 적용한 문자열을 반환해요. 기본적으로는 모든 단어의 첫 글자를 대문자로, 나머지 글자들을 소문자로 바꿔요.

method unival

multi method unival(Str:D: --> Numeric)

호출자의 첫 번째 코드포인트가 나타내는 숫자 값 을 반환하거나, 숫자가 아니면 NaN을 반환해요.

say '4'.unival;     # OUTPUT: «4␤»
say '¾'.unival;     # OUTPUT: «0.75␤»
say 'a'.unival;     # OUTPUT: «NaN␤»

method univals

multi method univals(Str:D: --> List)

호출자 문자열의 각 코드포인트가 나타내는 숫자 값들의 목록을 반환하고, 숫자가 아닌 문자에는 NaN을 반환해요.

say "4a¾".univals;  # OUTPUT: «(4 NaN 0.75)␤»

routine chars

multi        chars(Cool  $x --> Int:D)
multi        chars(Str:D $x --> Int:D)
multi        chars(str   $x --> int)
multi method chars(Str:D:   --> Int:D)

문자열의 문자(grapheme) 수를 반환해요. JVM에서는 현재 오류적으로 코드포인트 수를 반환해요.

method encode

multi method encode(Str:D $encoding = 'utf8', :$replacement, Bool() :$translate-nl = False, :$strict)

원본 문자열을 주어진 인코딩과 정규형으로 나타내는 Blob을 반환해요. 실제 반환 타입은 가능한 한 구체적이라서, $str.encode('UTF-8')는 utf8 객체를, $str.encode('ISO-8859-1')는 buf8을 반환해요. :translate-nl이 True면 새 줄을 \n에서 \r\n으로 변환하는데, Windows에서만 그렇게 해요. $replacement는 문자를 현재 인코딩에서 표현할 수 없을 때 그 문자를 어떻게 대체할지 나타내고, $strict는 매핑되지 않은 코드포인트를 여전히 디코딩할지 나타내요(예: windows-1252에 존재하지 않는 코드포인트 129).

my $str = "Þor is mighty";
say $str.encode("ascii", :replacement( 'Th') ).decode("ascii");
# OUTPUT: «Thor is mighty␤»

이 경우, 알 수 없는 문자는 Th로 대체돼요. 우리는 ascii 인코딩에서 알 수 없는 문자가 Þ임을 알고 있으므로, 그 라틴 동등물인 Th로 대체하는 거예요. 대체 문자 집합이 없으면 :replacement는 Bool로 이해돼요.

say $str.encode("ascii", :replacement).decode("ascii"); # OUTPUT: «?or is mighty␤»

:replacement가 설정되지 않거나 값이 지정되지 않으면 Error encoding ASCII string: could not encode codepoint 222 오류가 발행돼요 (이 경우 þ가 코드포인트 222이기 때문).

encode가 반환한 Blob은 정규형의 원본 문자열이고, Blob의 각 요소는 바이트이므로, 그 Blob의 크기를 반환하는 메서드를 호출하면 문자열의 바이트 길이를 얻을 수 있어요.

say "þor".encode.bytes; # OUTPUT: «4␤»
say "þor".encode.elems; # OUTPUT: «4␤»

method index

multi method index(Str:D: Cool:D $needle, :i(:$ignorecase), :m(:$ignoremark) --> Int:D)
multi method index(Str:D: Str:D $needle, :i(:$ignorecase), :m(:$ignoremark) --> Int:D)
multi method index(Str:D: Cool:D $needle, Cool:D $pos, :i(:$ignorecase), :m(:$ignoremark) --> Int:D)
multi method index(Str:D: Str:D $needle, Int:D $pos, :i(:$ignorecase), :m(:$ignoremark) --> Int:D)
multi method index(Str:D: @needles --> Int:D)
multi method index(Str:D: @needles, :m(:$ignoremark)! --> Int:D)
multi method index(Str:D: @needles, :i(:$ignorecase)!, :m(:$ignoremark) --> Int:D)

(제공된다면) $pos부터 시작해 문자열에서 $needle을 검색해요. $needle을 찾은 오프셋을 반환하고, 찾지 못하면 Nil을 반환해요.

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignorecase(또는 :i)를 주면 $needle 검색 시 대문자·소문자·타이틀케이스 구분을 무시해요. 또한 선택 명명 인자 :ignoremark(또는 :m)를 주면 $needle 검색이 기본 문자만 고려하고 결합 악센트 같은 부가 기호는 무시해요.

Rakudo 2020.05 릴리스부터 index는 검색할 needle들의 목록을 받아서, 찾은 가장 낮은 인덱스나 Nil을 반환해요.

예시:

say "Camelia is a butterfly".index("a");         # OUTPUT: «1␤»
say "Camelia is a butterfly".index("a", 2);      # OUTPUT: «6␤»
say "Camelia is a butterfly".index("er");        # OUTPUT: «17␤»
say "Camelia is a butterfly".index("Camel");     # OUTPUT: «0␤»
say "Camelia is a butterfly".index("Onion");     # OUTPUT: «Nil␤»
say "Camelia is a butterfly".index(<a e i u>);   # OUTPUT: «1␤»
say "Camelia is a butterfly".index(<a c>, :i);   # OUTPUT: «0␤»
say "Camelia is a butterfly".index(('w', 'x'));  # OUTPUT: «Nil␤»

say "Hello, World".index("world");               # OUTPUT: «Nil␤»
say "Hello, World".index("world", :ignorecase);  # OUTPUT: «7␤»

say "abc".index("ä");                            # OUTPUT: «Nil␤»
say "abc".index("ä", :ignoremark);               # OUTPUT: «0␤»
say "abc".index("x").defined ?? 'OK' !! 'NOT';   # OUTPUT: «NOT␤»

sub 포함한 index의 다른 형태는 Cool에서 상속돼요.

routine rindex

multi method rindex(Str:D: Str:D $needle --> Int:D)
multi method rindex(Str:D: Str:D $needle, Int:D $pos --> Int:D)
multi method rindex(Str:D: @needles --> Int:D)

$pos를 넘지 않는 문자열 내 $needle의 마지막 위치를 반환해요. $needle을 찾지 못하면 Nil을 반환해요.

Rakudo 2020.05 릴리스부터 rindex는 needle들의 목록을 받아서, 찾은 가장 높은 인덱스나 Nil을 반환해요.

예시:

say "aardvark".rindex: "a";       # OUTPUT: «5␤»
say "aardvark".rindex: "a", 0;    # OUTPUT: «0␤
say "aardvark".rindex: "t";       # OUTPUT: «Nil␤»
say "aardvark".rindex: <d v k>;   # OUTPUT: «7␤»

sub 포함한 rindex의 다른 형태는 Cool에서 상속돼요.

method indices

multi method indices(Str:D: Str:D $needle, :i(:$ignorecase), :m(:$ignoremark), :$overlap --> List:D)
multi method indices(Str:D: Str:D $needle, Int:D $start, :i(:$ignorecase), :m(:$ignoremark), :$overlap --> List:D)

$start(지정하지 않으면 0)부터 시작해 문자열에서 $needle의 모든 출현을 검색하고, $needle을 찾은 모든 오프셋의 List를 반환하거나, 찾지 못하면 빈 리스트를 반환해요.

선택 인자 :overlap을 지정하면 검색이 이전 매치 바로 다음 인덱스에서 계속되고, 그렇지 않으면 이전 매치 이후에서 계속돼요.

say "banana".indices("a");              # OUTPUT: «(1 3 5)␤»
say "banana".indices("ana");            # OUTPUT: «(1)␤»
say "banana".indices("ana", :overlap);  # OUTPUT: «(1 3)␤»
say "banana".indices("ana", 2);         # OUTPUT: «(3)␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignorecase(또는 :i)를 주면 $needle 검색 시 대문자·소문자·타이틀케이스 구분을 무시해요.

say "banAna".indices("a");              # OUTPUT:«(1 5)␤»
say "banAna".indices("a", :ignorecase); # OUTPUT:«(1 3 5)␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignoremark(또는 :m)를 주면 $needle 검색이 기본 문자만 고려하고 결합 악센트 같은 부가 기호는 무시해요.

say "tête-à-tête".indices("te");              # OUTPUT:«(2 9)␤»
say "tête-à-tête".indices("te", :ignoremark); # OUTPUT:«(0 2 7 9)␤»

method match

method match($pat, :continue(:$c), :pos(:$p), :global(:$g), :overlap(:$ov), :exhaustive(:$ex), :st(:$nd), :rd(:$th), :$nth, :$x --> Match)

문자열을 $pat에 대해 매치하고, 성공하면 Match 객체를 반환하며, 아니면 Nil을 반환해요. 매치는 기본 매치 변수 $/에 저장돼요. $pat이 Regex 객체가 아니면, match는 인자를 Str로 변환한 뒤 $pat에 대해 리터럴 매치를 수행해요.

매치 방식을 바꾸는 선택 명명 인자들을 여럿 지정할 수 있어요.

:continue

:continue 부사는 정규식이 검색을 시작할 위치를 인자로 받아요. :c에 위치가 지정되지 않으면 $/이 설정되지 않은 경우 0으로, 설정된 경우에는 $/.to로 기본 설정돼요.

:pos

위치를 인자로 받아요. :continue와 달리 그 위치에서 정규식이 매치되지 않으면 실패해요.

:global

매치 하나만 찾아 Match 객체를 반환하는 대신, 겹치지 않는 모든 매치를 찾아 List로 반환해요.

:overlap

겹치는 매치를 포함해 모든 매치를 찾되, 각 시작 위치에서 매치 하나만 반환해요.

:exhaustive

겹치는 매치와 같은 위치에서 시작하는 매치를 포함해 정규식의 가능한 모든 매치를 찾아요.

:st, :nd, :rd, :nth

문자열에서 n번째 매치를 반환해요. 인자는 Numeric이거나 단조 증가하는 숫자를 만드는 Iterable일 수 있어요. Iterable은 lazy하게 reified되고, 단조 증가하지 않는 시퀀스를 만나면 예외가 던져져요.

Iterable 인자를 주면 반환 값과 $/ 변수는 (아마 빈) Match 객체들의 List로 설정돼요.

반환할 매치 수를 인자로 받고, 지정된 매치 수에 도달하면 멈춰요. 값은 Numeric이나 Range여야 하며, 다른 값은 X::Str::Match::x 예외를 담은 Failure를 반환하게 해요.

예시:

say "properly".match('perl');                     # OUTPUT: «｢perl｣␤»
say "properly".match(/p.../);                     # OUTPUT: «｢prop｣␤»
say "1 2 3".match([1,2,3]);                       # OUTPUT: «｢1 2 3｣␤»
say "a1xa2".match(/a./, :continue(2));            # OUTPUT: «｢a2｣␤»
say "abracadabra".match(/ a .* a /, :exhaustive);
# OUTPUT: «(｢abracadabra｣ ｢abracada｣ ｢abraca｣ ｢abra｣ ｢acadabra｣ ｢acada｣ ｢aca｣ ｢adabra｣ ｢ada｣ ｢abra｣)␤»
say 'several words here'.match(/\w+/,:global);    # OUTPUT: «(｢several｣ ｢words｣ ｢here｣)␤»
say 'abcdef'.match(/.*/, :pos(2));                # OUTPUT: «｢cdef｣␤»
say "foo[bar][baz]".match(/../, :1st);            # OUTPUT: «｢fo｣␤»
say "foo[bar][baz]".match(/../, :2nd);            # OUTPUT: «｢o[｣␤»
say "foo[bar][baz]".match(/../, :3rd);            # OUTPUT: «｢ba｣␤»
say "foo[bar][baz]".match(/../, :4th);            # OUTPUT: «｢r]｣␤»
say "foo[bar][baz]bada".match('ba', :x(2));       # OUTPUT: «(｢ba｣ ｢ba｣)␤»

method Numeric

method Numeric(Str:D: --> Numeric:D)

val 루틴과 동등한 의미로 문자열을 Numeric으로 강제 변환해요. 숫자로의 변환이 불가능하면 X::Str::Numeric으로 fails해요.

속성 Nd를 가진 Unicode 문자와 앞뒤 공백만 허용되며, 빈 문자열은 0으로 강제 변환되는 특별한 경우예요. 합성 코드포인트(예: "7\x[308]")는 금지돼요.

Nl과 No 문자는 언어에서 숫자 리터럴로 쓸 수 있지만, Str.Numeric을 통한 변환은 의도적으로 실패해요. 합성 숫자(숫자와 분음 부호로 구성된 것)도 마찬가지예요. 그런 문자를 Numeric으로 변환해야 한다면 unival을 참고하세요. +, -, Unicode MINUS SIGN −는 모두 허용돼요.


" −33".Numeric;       # OUTPUT: «-33␤»

method Num

method Num(Str:D: --> Num:D)

Str.Numeric과 같은 규칙으로 문자열을 Num으로 강제 변환하며, 음의 영(-0e0)과 양의 영(0e0)을 처리해요.

my Str $s = "-0/5";
say (.self, .^name) given $s.Numeric;  # OUTPUT: «(0 Rat)␤»
say (.self, .^name) given $s.Num;      # OUTPUT: «(-0 Num)␤»

method Int

method Int(Str:D: --> Int:D)

Str.Numeric과 같은 규칙으로 문자열을 Int로 강제 변환해요.

method Rat

method Rat(Str:D: --> Rational:D)

Str.Numeric과 같은 규칙으로 문자열을 Rat 객체로 강제 변환해요. 분모가 64비트보다 커도 유지되며 Num으로의 열화는 발생하지 않아요.

method Bool

method Bool(Str:D: --> Bool:D)

문자열이 비어 있으면 False를, 아니면 True를 반환해요.

routine parse-base

multi        parse-base(Str:D $num, Int:D $radix --> Numeric)
multi method parse-base(Str:D $num: Int:D $radix --> Numeric)

base의 반대 연산을 수행해요. $radix 진법의 숫자를 담은 문자열을 그 Numeric 동등물로 변환해요. radix가 2..36 범위를 벗어나면, 또는 파싱하는 문자열이 지정된 진법에 유효하지 않은 문자를 포함하면 fail해요.

1337.base(32).parse-base(32).say; # OUTPUT: «1337␤»
'Raku'.parse-base(36).say;        # OUTPUT: «1273422␤»
'FF.DD'.parse-base(16).say;       # OUTPUT: «255.863281␤»

참고: 숫자 리터럴 문법

routine parse-names

sub    parse-names(Str:D $names  --> Str:D)
method parse-names(Str:D $names: --> Str:D)

폐기됨(DEPRECATED). 대신 uniparse를 쓰세요. Rakudo 구현에서 이름이 바뀌기 전 존재 가능성 증명용으로 존재했으며, 6.e 언어가 릴리스되면 제거될 거예요.

routine uniparse

sub    uniparse(Str:D $names  --> Str:D)
method uniparse(Str:D $names: --> Str:D)

쉼표로 구분된 Unicode 문자 이름 문자열을 받아 그 문자들로 구성된 문자열을 반환해요. 문자의 이름이 비어 있거나 인식되지 않으면 fail해요. 문자 이름 주변의 공백은 무시돼요.

say "I {uniparse 'TWO HEARTS'} Raku"; # OUTPUT: «I 💕 Raku␤»
'TWO HEARTS, BUTTERFLY'.uniparse.say; # OUTPUT: «💕🦋␤»

반대 방향(단일 코드포인트 및 다중 코드포인트)으로 동작하는 루틴은 uniname과 uninames를 참고하세요.

문자열 보간의 \c[...] 구성과 달리, uniparse는 십진 숫자 값을 받지 않는다는 점을 주의하세요. 그런 값은 chr 루틴으로 변환해요.

say "\c[1337]"; # OUTPUT: «Թ␤»
say '1337'.chr; # OUTPUT: «Թ␤»

참고: 2017.12에서 표준화되기 전에는 이 루틴이 작업명 parse-names로 알려져 있었어요. 이 명칭은 6.e 버전에서 제거될 거예요.

method samecase

multi method samecase(Str:D: Str:D $pattern --> Str:D)

각 문자의 대소문자 정보가 $pattern에 따라 바뀐 호출자의 복사본을 반환해요.

참고: 패턴 문자열은 대문자, 소문자, 대소문자 없음(caseless) 세 종류의 문자를 포함할 수 있어요. $pattern에서의 특정 문자의 대소문자 정보가 결과에서 대응하는 문자의 대소문자를 결정해요.

호출자가 $pattern보다 길면, $pattern의 마지막 문자의 대소문자 정보가 호출자의 나머지 문자들에 적용돼요.

say "raKu".samecase("A_a_"); # OUTPUT: «Raku␤»
say "rAKU".samecase("Ab");   # OUTPUT: «Raku␤»

routine split

multi        split(  Str:D $delimiter, Str:D $input, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)

multi        split(Regex:D $delimiter, Str:D $input, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)

multi        split(List:D $delimiters, Str:D $input, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)

multi method split(Str:D:   Str:D $delimiter, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)

multi method split(Str:D: Regex:D $delimiter, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)

multi method split(Str:D: List:D $delimiters, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)

문자열에서 찾은 구분자에 기반해 문자열을 조각들로 분할해요.

$delimiter가 문자열이면 문자 그대로 사용돼요. 빈 문자열은 효과적으로 문자열의 모든 문자를 (앞과 뒤의 빈 문자열과 함께) 별도로 반환해요.

$delimiter는 Regex로도 넘길 수 있어요.

리스트를 쓰면 각 요소가 위에서 언급한 타입에 따라 구분자로 간주돼요.

선택 $limit은 문자열을 가능하면 몇 개의 세그먼트로 나눠야 하는지를 나타내요. 기본값은 Inf(혹은 *, 보기 나름이지만)로, "가능한 한 많이"를 뜻해요. 음수 한계를 지정하면 의미 있는 결과가 나오지 않는다는 점에 주의하세요.

결과를 바꾸는 선택 명명 인자들을 여럿 지정할 수 있어요. :v, :k, :kv, :p 명명 인자는 발견된 구분자에 대해 특별한 동작을 수행해요.

:skip-empty

지정하면 구분자 앞뒤의 빈 문자열을 반환하지 않아요.

구분자도 함께 반환해요. 구분자가 정규식이었다면 이는 관련 Match 객체가 돼요. 이 객체는 발견된 구분자 문자열로 문자열화되므로, 그 특정 매치에 대한 추가 정보가 필요 없다면 항상 구분자 문자열이라고 간주해도 돼요.

구분자의 인덱스도 함께 반환해요. 구분자 목록이 지정된 경우에만 의미가 있어요. 그 외의 모든 경우에는 0이 돼요.

구분자의 인덱스와 구분자 둘 다 반환해요.

구분자의 인덱스와 구분자를 Pair로 반환해요.

예시:

say split(";", "a;b;c").raku;           # OUTPUT: «("a", "b", "c").Seq␤»
say split(";", "a;b;c", :v).raku;       # OUTPUT: «("a", ";", "b", ";", "c").Seq␤»
say split(";", "a;b;c", 2).raku;        # OUTPUT: «("a", "b;c").Seq␤»
say split(";", "a;b;c", 2, :v).raku;    # OUTPUT: «("a", ";", "b;c").Seq␤»
say split(";", "a;b;c,d").raku;         # OUTPUT: «("a", "b", "c,d").Seq␤»
say split(/\;/, "a;b;c,d").raku;        # OUTPUT: «("a", "b", "c,d").Seq␤»
say split(<; ,>, "a;b;c,d").raku;       # OUTPUT: «("a", "b", "c", "d").Seq␤»
say split(/<[;,]>/, "a;b;c,d").raku;    # OUTPUT: «("a", "b", "c", "d").Seq␤»
say split(<; ,>, "a;b;c,d", :k).raku;   # OUTPUT: «("a", 0, "b", 0, "c", 1, "d").Seq␤»
say split(<; ,>, "a;b;c,d", :kv).raku;  # OUTPUT: «("a", 0, ";", "b", 0, ";", "c", 1, ",", "d").Seq␤»

say "".split("x").raku;                 # OUTPUT: «("",).Seq␤»
say "".split("x", :skip-empty).raku;    # OUTPUT: «().Seq␤»

say "abcde".split("").raku;             # OUTPUT: «("", "a", "b", "c", "d", "e", "").Seq␤»
say "abcde".split("",:skip-empty).raku; # OUTPUT: «("a", "b", "c", "d", "e").Seq␤»

routine comb

multi        comb(Str:D   $matcher, Str:D $input, $limit = Inf)
multi        comb(Regex:D $matcher, Str:D $input, $limit = Inf, Bool :$match)
multi        comb(Int:D $size, Str:D $input, $limit = Inf)
multi method comb(Str:D $input:)
multi method comb(Str:D $input: Str:D   $matcher, $limit = Inf)
multi method comb(Str:D $input: Regex:D $matcher, $limit = Inf, Bool :$match)
multi method comb(Str:D $input: Int:D $size, $limit = Inf)

$input에서 $matcher를 검색하고, 최대 $limit 개의 겹치지 않는 매치들로 제한된 Seq를 반환해요.

$matcher가 Regex이면 (Rakudo 2020.01 릴리스부터 사용 가능한) $match가 설정되지 않는 한 각 Match 객체는 Str로 변환돼요.

매처를 제공하지 않으면 매처가 rx/./인 것처럼 문자열의 문자들로 이루어진 Seq를 반환해요.

예시:

say "abc".comb.raku;                 # OUTPUT: «("a", "b", "c").Seq␤»
say "abc".comb(:match).raku;         # OUTPUT: «(｢a｣ ｢b｣ ｢c｣)␤»
say 'abcdefghijk'.comb(3).raku;      # OUTPUT: «("abc", "def", "ghi", "jk").Seq␤»
say 'abcdefghijk'.comb(3, 2).raku;   # OUTPUT: «("abc", "def").Seq␤»
say comb(/\w/, "a;b;c").raku;        # OUTPUT: «("a", "b", "c").Seq␤»
say comb(/\N/, "a;b;c").raku;        # OUTPUT: «("a", ";", "b", ";", "c").Seq␤»
say comb(/\w/, "a;b;c", 2).raku;     # OUTPUT: «("a", "b").Seq␤»
say comb(/\w\;\w/, "a;b;c", 2).raku; # OUTPUT: «("a;b",).Seq␤»
say comb(/.<(.)>/, "<>[]()").raku;   # OUTPUT: «(">", "]", ")").Seq␤»

매처가 정수 값이면 comb은 매처가 rx/ . ** {1..$matcher} /인 것처럼 동작하되, 훨씬 빠르게 최적화돼요.

Regex 매처는 최상위 캡처를 명시적으로 설정하는 기능을 써서 매치된 텍스트에서 어느 부분이 반환될지 제어할 수 있다는 점을 주의하세요.

multi        comb(Pair:D $rotor, Str:D $input, $limit = Inf, Bool :$partial)
multi method comb(Str:D $input: Pair:D $rotor, $limit = Inf, Bool :$partial)

6.e 언어 버전에서 사용 가능해요 (조기 구현은 Rakudo 2022.12+ 컴파일러에 존재). rotor 쌍(pair)은 가져올 문자의 개수를 키(그 "크기")로, 이후 앞으로 나아갈 "단계"의 수를 값으로 나타내요. 주요 용도는 문자열에서 N-gram을 효율적으로 만드는 방법을 제공하는 거예요. 기본적으로 지정된 크기의 문자열만 생성돼요. :partial 명명 인자를 참값으로 지정하면 이 동작을 덮어쓸 수 있어요.

예시:

say "abcde".comb(3 => -2);             # OUTPUT: «(abc bcd cde)␤»
say "abcde".comb(3 => -2, :partial);   # OUTPUT: «(abc bcd cde de e)␤»
say "abcdefg".comb(3 => -2, 2);        # OUTPUT: «(abc bcd)␤»
say comb(3 => -2, "abcde");            # OUTPUT: «(abc bcd cde)␤»
say comb(5 => -2, "abcde", :partial);  # OUTPUT: «(abc bcd cde de e)␤»
say comb(5 => -2, "abcdefg", 2);       # OUTPUT: «(abc bcd)␤»

routine lines

multi method lines(Str:D: $limit, :$chomp = True)
multi method lines(Str:D: :$chomp = True)

줄들의 Seq를 반환해요. 기본적으로는 $input.comb( / ^^ \N* /, $limit ) 호출과 동일하게 줄 끝을 chomp해요. 줄 끝을 유지하려면 선택 명명 인자 $chomp을 False로 설정하세요.

예시:

say lines("a\nb").raku;    # OUTPUT: «("a", "b").Seq␤»
say lines("a\nb").elems;   # OUTPUT: «2␤»
say "a\nb".lines.elems;    # OUTPUT: «2␤»
say "a\n".lines.elems;     # OUTPUT: «1␤»

# Keep line endings
say lines(:!chomp, "a\nb").raku;  # OUTPUT: «("a\n", "b").Seq␤»
say "a\n".lines(:!chomp).elems;   # OUTPUT: «1␤»

$limit 변수를 0이 아니고 Infinity가 아닌 값으로 설정하면 반환되는 줄 수를 제한할 수 있어요.

say <not there yet>.join("\n").lines( 2 ); # OUTPUT: «(not there)␤»

6.d 언어부터 폐기됨(DEPRECATED), :count 인자는 총 줄 수를 반환하는 데 쓰였어요.

say <not there yet>.join("\n").lines( :count ); # OUTPUT: «3␤»

대신 반환된 Seq에 elems을 호출하세요.

say <not there yet>.join("\n").lines.elems; # OUTPUT: «3␤»

routine words

multi method words(Str:D: $limit)
multi method words(Str:D:)

공백이 아닌 조각들의 Seq를 반환해요. 즉 $input.comb( / \S+ /, $limit ) 호출과 동일해요.

예시:

say "a\nb\n".words.raku;       # OUTPUT: «("a", "b").Seq␤»
say "hello world".words.raku;  # OUTPUT: «("hello", "world").Seq␤»
say "foo:bar".words.raku;      # OUTPUT: «("foo:bar",).Seq␤»
say "foo:bar\tbaz".words.raku; # OUTPUT: «("foo:bar", "baz").Seq␤»

서브루틴으로도 쓸 수 있고, 그 경우 첫 번째 인자가 호출자가 돼요. $limit은 선택이지만, 제공되고(Inf가 아니면) 처음 $limit 개의 단어만 반환해요.

say words("I will be very brief here", 2); # OUTPUT: «(I will)␤»

routine flip

multi        flip(Str:D  --> Str:D)
multi method flip(Str:D: --> Str:D)

문자열을 문자 단위로 뒤집은 문자열을 반환해요.

예시:

"Raku".flip;  # OUTPUT: «ukaR»
"ABBA".flip;  # OUTPUT: «ABBA»

method starts-with

multi method starts-with(Str:D: Str(Cool) $needle, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)

호출자가 $needle와 동일하거나 $needle으로 시작하면 True를 반환해요.

say "Hello, World".starts-with("Hello");     # OUTPUT: «True␤»
say "https://raku.org/".starts-with('ftp');  # OUTPUT: «False␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignorecase(또는 :i)를 주면 호출자와 $needle의 비교가 대문자·소문자·타이틀케이스 구분을 무시해요.

say "Hello, World".starts-with("hello");              # OUTPUT: «False␤»
say "Hello, World".starts-with("hello", :ignorecase); # OUTPUT: «True␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignoremark(또는 :m)를 주면 비교가 기본 문자만 고려하고 결합 악센트 같은 부가 기호는 무시해요.

say "abc".starts-with("ä");              # OUTPUT: «False␤»
say "abc".starts-with("ä", :ignoremark); # OUTPUT: «True␤»

method ends-with

multi method ends-with(Str:D: Str(Cool) $needle, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)

호출자가 $needle와 동일하거나 $needle으로 끝나면 True를 반환해요.

say "Hello, World".ends-with('Hello');      # OUTPUT: «False␤»
say "Hello, World".ends-with('ld');         # OUTPUT: «True␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignorecase(또는 :i)를 주면 호출자와 $needle의 비교가 대문자·소문자·타이틀케이스 구분을 무시해요.

say "Hello, World".ends-with("world");              # OUTPUT: «False␤»
say "Hello, World".ends-with("world", :ignorecase); # OUTPUT: «True␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignoremark(또는 :m)를 주면 비교가 기본 문자만 고려하고 결합 악센트 같은 부가 기호는 무시해요.

say "abc".ends-with("ç");              # OUTPUT: «False␤»
say "abc".ends-with("ç", :ignoremark); # OUTPUT: «True␤»

method subst

multi method subst(Str:D: $matcher, $replacement = "", *%options)

$matcher를 $replacement로 (매치가 없으면 원본 문자열을) 바꾼 호출자 문자열을 반환해요. $replacement가 제공되지 않으면 빈 문자열이 사용돼요(즉, 매치된 문자열들이 제거돼요).

s/matcher/replacement/로 적고 s 뒤나 매처 안쪽에 부사를 붙이는, subst의 제자리 문법 변형이 있어요.

$matcher는 Regex이거나 리터럴 Str일 수 있어요. Str이 아닌 Cool 타입의 매처 인자는 리터럴 매치를 위해 Str로 강제 변환돼요. Regex $matcher를 쓰면, $/ 특별 변수가 (매치가 없으면) Nil, Match 객체, 또는 (:g 같은 다중 매치 옵션을 쓰면) Match 객체들의 List로 설정돼요.

리터럴 대체 subst

my $some-string = "Some foo";
my $another-string = $some-string.subst(/foo/, "string"); # gives 'Some string'
$some-string.=subst(/foo/, "string"); # in-place substitution. $some-string is now 'Some string'

say "multi-hyphenate".subst("-"); # OUTPUT: «multihyphenate␤»

Callable

대체는 Callable일 수 있으며, 이때 현재 Match 객체가 $/ 변수와 $_ 주제 변수에 모두 들어가요. Callable을 대체로 쓰는 것은 정규식에서 만든 어떤 캡처든 참조할 수 있는 방법이에요.

# Using capture from $/ variable (the $0 is the first positional capture)
say 'abc123defg'.subst(/(\d+)/, { " before $0 after " });
# OUTPUT: «abc before 123 after defg␤»

# Using capture from $/ variable (the $<foo> is a named capture)
say 'abc123defg'.subst(/$<foo>=\d+/, { " before $<foo> after " });
# OUTPUT: «abc before 123 after defg␤»

# Using WhateverCode to operate on the Match given in $_:
say 'abc123defg'.subst(/(\d+)/, "[ " ~ *.flip ~ " ]");
# OUTPUT: «abc[ 321 ]defg␤»

# Using a Callable to generate substitution without involving current Match:
my $i = 41;
my $str = "The answer is secret.";
say $str.subst(/secret/, {++$i});    # OUTPUT: «The answer is 42.␤»

Adverbs

다음 부사들이 지원돼요.

short	long	meaning
:g	:global	가능한 한 자주 매치하려 함
:nth(Int\|Callable\|Whatever)		n번째 매치만 치환함; 별칭: :st, :nd, :rd, :th
:ss	:samespace	치환 시 공백 보존
:ii	:samecase	치환 시 대소문자 보존
:mm	:samemark	문자 부가 기호 보존 (예: 'ü'를 'o'로 바꾸면 'ö'가 됨)
:x(Int\|Range\|Whatever)		정확히 $x 개의 매치를 치환함

오직 s/// 형태에서만 :ii가 :i를, :ss가 :s를 암시한다는 점을 주의하세요. 메서드 형태에서는 :s와 :i 수정자를 subst 메서드 호출이 아니라 정규식에 추가해야 해요.

더 많은 예시

다음은 사용 예시들이에요.

my $str = "Hey foo foo foo";

say $str.subst(/foo/, "bar", :g);           # OUTPUT: «Hey bar bar bar␤»
say $str.subst(/\s+/, :g);                  # OUTPUT: «Heyfoofoofoo␤»

say $str.subst(/foo/, "bar", :x(0));        # OUTPUT: «Hey foo foo foo␤»
say $str.subst(/foo/, "bar", :x(1));        # OUTPUT: «Hey bar foo foo␤»
# Can not match 4 times, so no substitutions made
say $str.subst(/foo/, "bar", :x(4));        # OUTPUT: «Hey foo foo foo␤»
say $str.subst(/foo/, "bar", :x(2..4));     # OUTPUT: «Hey bar bar bar␤»
# Replace all of them, identical to :g
say $str.subst(/foo/, "bar", :x(*));        # OUTPUT: «Hey bar bar bar␤»

say $str.subst(/foo/, "bar", :nth(3));      # OUTPUT: «Hey foo foo bar␤»
# Replace last match
say $str.subst(/foo/, "bar", :nth(*));      # OUTPUT: «Hey foo foo bar␤»
# Replace next-to-last last match
say $str.subst(/foo/, "bar", :nth(*-1));    # OUTPUT: «Hey foo bar foo␤»

:nth 부사에는 읽기 좋은 영어 모양의 변형들이 있어요.

say 'ooooo'.subst: 'o', 'x', :1st; # OUTPUT: «xoooo␤»
say 'ooooo'.subst: 'o', 'x', :2nd; # OUTPUT: «oxooo␤»
say 'ooooo'.subst: 'o', 'x', :3rd; # OUTPUT: «ooxoo␤»
say 'ooooo'.subst: 'o', 'x', :4th; # OUTPUT: «oooxo␤»

method subst-mutate

참고: .subst-mutate는 6.d 버전에서 폐기되었고, 앞으로의 버전에서 제거될 거예요. subst를 .= 메서드 호출 할당 연산자나 s/// 치환 연산자와 함께 쓰면 돼요.

subst가 수정된 문자열을 반환하고 원본을 그대로 두는 데 반해, subst-mutate를 쓰면 원본 문자열을 변경할 수 있어요. 매치가 성공하면 성공한 매치를 나타내는 Match 객체를 반환하고, 아니면 Nil을 반환해요. Iterable 값을 가진 :nth(또는 그 별칭), :g, :global, :x 인자를 쓰면 Match 객체들의 List를, 매치가 없으면 빈 List를 반환해요.

my $some-string = "Some foo";
my $match = $some-string.subst-mutate(/foo/, "string");
say $some-string;  # OUTPUT: «Some string␤»
say $match;        # OUTPUT: «｢foo｣␤»
$some-string.subst-mutate(/<[oe]>/, '', :g); # remove every o and e, notice the :g named argument from .subst

Regex $matcher를 쓰면, $/ 특별 변수가 (매치가 없으면) Nil, Match 객체, 또는 (:g 같은 다중 매치 옵션을 쓰면) Match 객체들의 List로 설정돼요.

routine substr

multi        substr(Str:D $s, $from, $chars?  --> Str:D)
multi        substr(Str:D $s, Range  $from-to --> Str:D)
multi method substr(Str:D $s: $from, $chars?  --> Str:D)
multi method substr(Str:D $s: Range $from-to  --> Str:D)

$from-to의 끝점(Int로 변환)이 지정하는 인덱스 사이, 또는 인덱스 $from부터 길이 $chars만큼의 원본 문자열의 부분 문자열을 반환해요.

$from과 $chars 모두 Callable로 지정할 수 있고, 그 반환 값이 인자 값으로 사용돼요. $from은 원본 문자열의 길이로, $chars는 $from 이후 남은 문자 수로 호출돼요. $from이나 $chars가 Callable이 아니면 Int로 강제 변환돼요.

$chars가 생략되거나 사용 가능한 문자보다 크면 $from부터 문자열 끝까지의 부분이 반환돼요. $from-to의 시작 인덱스나 $from이 0보다 작으면 X::OutOfRange 예외가 던져져요. $from-to의 끝 인덱스는 문자열 끝을 넘어서도 허용되며, 그 경우 마지막 문자의 인덱스와 동등해요.

say substr("Long string", 3..6);     # OUTPUT: «g st␤»
say substr("Long string", 6, 3);     # OUTPUT: «tri␤»
say substr("Long string", 6);        # OUTPUT: «tring␤»
say substr("Long string", 6, *-1);   # OUTPUT: «trin␤»
say substr("Long string", *-3, *-1); # OUTPUT: «in␤»

method substr-eq

multi method substr-eq(Str:D:  Str(Cool) $test-string, Int(Cool) $from, :i(:$ignorecase), :m(:$ignoremark) --> Bool)
multi method substr-eq(Cool:D: Str(Cool) $test-string, Int(Cool) $from, :i(:$ignorecase), :m(:$ignoremark) --> Bool)

주어진 시작 인덱스 $from부터 $test-string이 문자열 객체와 정확히 일치하면 True를 반환해요. 예를 들어 "foobar" 문자열에서 부분 문자열 "bar"는 인덱스 3부터 매치돼요.

my $string = "foobar";
say $string.substr-eq("bar", 3);    # OUTPUT: «True␤»

그러나 인덱스 3부터 시작하는 부분 문자열 "barz"는, 처음 세 글자가 일치하더라도 매치되지 않아요.

my $string = "foobar";
say $string.substr-eq("barz", 3);   # OUTPUT: «False␤»

자연스럽게, 전체 문자열을 매치하려면 인덱스 0부터 매치하면 돼요.

my $string = "foobar";
say $string.substr-eq("foobar", 0); # OUTPUT: «True␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignorecase(또는 :i)를 주면 호출자와 $test-string의 비교가 대문자·소문자·타이틀케이스 구분을 무시해요.

say "foobar".substr-eq("Bar", 3);              # OUTPUT: «False␤»
say "foobar".substr-eq("Bar", 3, :ignorecase); # OUTPUT: «True␤»

Rakudo 2020.02 릴리스부터 선택 명명 인자 :ignoremark(또는 :m)를 주면 비교가 기본 문자만 고려하고 결합 악센트 같은 부가 기호는 무시해요.

say "cliché".substr-eq("che", 3);              # OUTPUT: «False␤»
say "cliché".substr-eq("che", 3, :ignoremark); # OUTPUT: «True␤»

이 메서드는 Cool 타입에서 상속되므로 정수에도 동작해요. 따라서 정수 42는 인덱스 1부터 값 342를 매치해요.

my $integer = 342;
say $integer.substr-eq(42, 1);      # OUTPUT: «True␤»

예상대로, 인덱스 0부터 시작하면 전체 값을 매치할 수 있어요.

my $integer = 342;
say $integer.substr-eq(342, 0);     # OUTPUT: «True␤»

다른 값을 쓰거나 잘못된 시작 인덱스를 쓰면 매치되지 않아요.

my $integer = 342;
say $integer.substr-eq(42, 3);      # OUTPUT: «False␤»
say $integer.substr-eq(7342, 0);    # OUTPUT: «False␤»

method substr-rw

method substr-rw($from, $length = *)

문자열 변수의 일부에 대한 쓰기 가능한 참조처럼 동작하는 Proxy를 반환하는 substr 버전이에요. 첫 번째 인자 $from은 치환이 일어나야 할 문자열 내 인덱스를, 마지막 인자 $length는 교체할 문자 수를 지정해요. 지정하지 않으면 $length는 문자열의 길이로 기본 설정돼요.

예를 들어 메서드 형태에서 "abc" 문자열을 가져와 두 번째 문자(인덱스 1)를 "z"로 바꾸고 싶다면 이렇게 해요.

my $string = "abc";
$string.substr-rw(1, 1) = "z";
$string.say;                         # OUTPUT: «azc␤»

새 문자를 삽입할 수도 있다는 점에 주의하세요.

my $string = 'azc';
$string.substr-rw(2, 0) = "-Zorro-"; # insert new characters BEFORE the character at index 2
$string.say;                         # OUTPUT: «az-Zorro-c␤»

substr-rw에는 함수 형태도 있어서, 위 예시들은 이렇게도 쓸 수 있어요.

my $string = "abc";
substr-rw($string, 1, 1) = "z";
$string.say;                          # OUTPUT: «azc␤»
substr-rw($string, 2, 0) = "-Zorro-";
$string.say;                          # OUTPUT: «az-Zorro-c␤»

substr-rw가 반환하는 쓰기 가능한 참조에 별명을 붙여 반복 연산에 쓸 수도 있어요.

my $string = "A character in the 'Flintstones' is: barney";
$string ~~ /(barney)/;
my $ref := substr-rw($string, $0.from, $0.to-$0.from);
$string.say;
# OUTPUT: «A character in the 'Flintstones' is: barney␤»
$ref = "fred";
$string.say;
# OUTPUT: «A character in the 'Flintstones' is: fred␤»
$ref = "wilma";
$string.say;
# OUTPUT: «A character in the 'Flintstones' is: wilma␤»

routine samemark

multi  samemark(Str:D $string, Str:D $pattern --> Str:D)
method samemark(Str:D: Str:D $pattern --> Str:D)

각 문자의 부가 기호/악센트 정보가 $pattern의 대응 문자의 부가 기호/악센트와 일치하도록 바뀐 $string의 복사본을 반환해요. $string이 $pattern보다 길면, $string의 나머지 문자들은 $pattern의 마지막 문자와 같은 부가 기호/악센트를 받아요. $pattern이 비어 있으면 아무 변경도 없어요.

예시:

say 'åäö'.samemark('aäo');                        # OUTPUT: «aäo␤»
say 'åäö'.samemark('a');                          # OUTPUT: «aao␤»

say samemark('Räku', 'a');                        # OUTPUT: «Raku␤»
say samemark('aöä', '');                          # OUTPUT: «aöä␤»

method succ

method succ(Str:D: --> Str:D)

1만큼 증가된 문자열을 반환해요.

문자열 증가는 "마법" 같아요. 점으로 앞서지 않은 마지막 영숫자 시퀀스를 찾아 그것을 증가시켜요.

'12.34'.succ;      # OUTPUT: «13.34»
'img001.png'.succ; # OUTPUT: «img002.png»

실제 증가 단계는 마지막 영숫자 문자를 그것이 속한 문자 범위에 매핑하고, 그 범위에서 다음 문자를 고르며, 오버플로 시 이전 글자로 올림해요.

'aa'.succ;   # OUTPUT: «ab»
'az'.succ;   # OUTPUT: «ba»
'109'.succ;  # OUTPUT: «110»
'α'.succ;    # OUTPUT: «β»
'a9'.succ;   # OUTPUT: «b0»

문자열 증가는 Unicode를 인식하며, 문자가 한 문자 범위에 고유하게 분류될 수 있는 문자 체계에서 일반적으로 동작해요.

method pred

method pred(Str:D: --> Str:D)

1만큼 감소된 문자열을 반환해요.

문자열 감소는 문자열 증가(succ 참고)와 마찬가지로 "마법" 같아요. 언더플로에서는 실패해요.

'b0'.pred;           # OUTPUT: «a9»
'a0'.pred;           # OUTPUT: Failure
'img002.png'.pred;   # OUTPUT: «img001.png»

routine ord

multi        ord(Str:D  --> Int:D)
multi method ord(Str:D: --> Int:D)

문자열에서 첫 번째 그래핌의 기본 문자들의 코드포인트 번호를 반환해요.

예시:

ord("A"); # 65
"«".ord;  # 171

method ords

multi method ords(Str:D: --> Seq)

문자열을 구성하는 코드포인트를 설명하는 Unicode 코드포인트 번호들의 목록을 반환해요.

예시:

"aå«".ords; # (97 229 171)

문자열은 그래핌으로 표현돼요. 문자열의 한 문자가 여러 코드포인트로 표현된다면, 그 코드포인트들이 모두 ords 결과에 나타나요. 따라서 결과의 요소 수가 항상 chars와 같지는 않지만 codes와는 같아요. codes는 코드포인트를 다른 방식으로 계산해서, 결과가 더 빠를 수도 있어요.

반환되는 코드포인트들은 문자열을 NFC로 나타낸 거예요. 다른 형태가 필요하면 NFD, NFKC, NFKD 메서드를 참고하세요.

method trans

multi method trans(Str:D: Pair:D \what, *%n --> Str)
multi method trans(Str:D: *@changes, :complement(:$c), :squash(:$s), :delete(:$d) --> Str)

하나 이상의 문자를 하나 이상의 문자로 대체해요. 키와 값 모두에서 범위가 지원돼요. Regex도 키로 동작해요. 키와 값의 목록을 쓰면 부분 문자열도 대체할 수 있어요. :complement와 함께 호출하면 매치된 값이나 범위 외의 모든 것이 단일 값으로 대체되고, :delete면 대응하는 대체가 없는 매치된 문자들이 제거돼요. :complement와 :delete를 결합하면 매치된 값 외의 모든 것을 제거하되, 대체 문자가 지정된 경우에는 :delete가 무시돼요. 부사 :squash는 반복되는 매치된 문자를 단일 문자로 줄여요.

예시:

my $str = 'say $x<b> && $y<a>';
$str.=trans( '<' => '«' );
$str.=trans( '<' => '«', '>' => '»' );

$str.=trans( [ '<'   , '>'   , '&' ] =>
             [ '&lt;', '&gt;', '&amp;' ]);

$str.=trans( ['a'..'y'] => ['A'..'z'] );

"abcdefghij".trans(/<[aeiou]> \w/ => '');                     # OUTPUT: «cdgh»

"a123b123c".trans(['a'..'z'] => 'x', :complement);            # OUTPUT: «axxxbxxxc»
"aaa1123bb123c".trans('a'..'z' => 'A'..'Z', :squash);         # OUTPUT: «A1123B123C»
"aaa1123bb123c".trans('a'..'z' => 'x', :complement, :squash); # OUTPUT: «aaaxbbxc»

일반적으로 치환 후 문자열은 같은 길이를 유지해요.

say "a123b123c".trans('23' => '4');   # OUTPUT: «a144b144c␤»
say "a123b123c".trans('123' => 'þð'); # OUTPUT: «aþðþbþðþc␤»

:squash와 :delete는 이 경우 같은 효과를 가지며 엄격한 치환을 만들어요.

say "a123b123c".trans('123' => 'þð', :squash); # OUTPUT: «aþðbþðc␤»
say "a123b123c".trans('123' => 'þð', :delete); # OUTPUT: «aþðbþðc␤»

:delete는 원본 문자열에서 매치되지 않은 문자도 제거해요.

say "abc".trans("abc".comb => 1..2, :delete);  # OUTPUT: «12␤»

두 형태의 multi 메서드 동작이 약간 다르다는 점을 주의하세요. 첫 번째 형태는 원본이 한 문자이면 문자 하나만 변환해요.

say "abcd".trans( "a" => "zz" );  # OUTPUT: «zbcd␤»
say "abcd".trans( "ba" => "yz" ); # OUTPUT: «zycd␤»

두 번째 경우는 원본이 한 문자보다 길기 때문에 예상대로 동작해요. 그러나 multi 메서드의 Pair가 원본이나 대상으로 Str을 가지지 않으면 두 번째 multi 메서드로 처리되고 동작이 달라져요.

say "abcd".trans: ["a"] => ["zz"]; # OUTPUT: «zzbcd␤»

이 경우 Pair의 원본과 대상이 모두 Str이 아니에요. Pair 시그니처의 메서드는 두 번째 메서드를 호출해서, 위 호출을 "abcd".trans: ["a"] => ["zz"],(뒤에 쉼표를 붙여 Pair가 아닌 Positional로 만든 것)와 동등하게 만들어 출력에 보이는 동작을 만들어내요.

method indent

multi method indent(Int $steps where { $_ == 0 } )
multi method indent(Int $steps where { $_ > 0  } )
multi method indent($steps where { .isa(Whatever) || .isa(Int) && $_ < 0 } )

문자열의 각 줄을 $steps만큼 들여쓰기해요. $steps가 음수면 대신 내어쓰기(outdent)해요. $steps가 *이면 문자열을 여백(margin)까지 내어써요.

"  indented by 2 spaces\n    indented even more".indent(*)
    eq "indented by 2 spaces\n  indented even more"

method trim

method trim(Str:D: --> Str)

앞뒤 공백을 제거해요. 문자열의 메서드로도, 함수로도 쓸 수 있어요. 메서드로 쓰면 정리된 문자열을 반환해요. 제자리에서 정리하려면 .=trim으로 써야 해요.

my $line = '   hello world    ';
say '<' ~ $line.trim ~ '>';        # OUTPUT: «<hello world>␤»
say '<' ~ trim($line) ~ '>';       # OUTPUT: «<hello world>␤»
$line.trim;
say '<' ~ $line ~ '>';             # OUTPUT: «<   hello world    >␤»
$line.=trim;
say '<' ~ $line ~ '>';             # OUTPUT: «<hello world>␤»

참고: trim-trailing과 trim-leading

method trim-trailing

method trim-trailing(Str:D: --> Str)

문자열 끝에서 공백 문자를 제거해요. 참고: trim

method trim-leading

method trim-leading(Str:D: --> Str)

문자열 시작에서 공백 문자를 제거해요. 참고: trim

method NFC

method NFC(Str:D: --> NFC:D)

NFC 형식(Unicode Normalization Form C / Composed)의 코드포인트 문자열을 반환해요.

method NFD

method NFD(Str:D: --> NFD:D)

NFD 형식(Unicode Normalization Form D / Decomposed)의 코드포인트 문자열을 반환해요.

method NFKC

method NFKC(Str:D: --> NFKC:D)

NFKC 형식(Unicode Normalization Form KC / Compatibility Composed)의 코드포인트 문자열을 반환해요.

method NFKD

method NFKD(Str:D: --> NFKD:D)

NFKD 형식(Unicode Normalization Form KD / Compatibility Decomposed)의 코드포인트 문자열을 반환해요.

method ACCEPTS

multi method ACCEPTS(Str:D: $other)

문자열이 $other와 같으면 True를 반환해요.

method Capture

method Capture()

X::Cannot::Capture를 던져요.

routine val

multi val(*@maybevals)
multi val(Slip:D \maybevals)
multi val(List:D \maybevals)
multi val(Pair:D \ww-thing)
multi val(\one-thing)
multi val(Str:D $MAYBEVAL, :$val-or-fail)

숫자 값으로 파싱될 수 있는 Str을 받으면, 적절한 allomorph를 생성하려 시도해요. IntStr, NumStr, RatStr, ComplexStr 중 하나를 반환하거나, 숫자 값을 파싱할 수 없으면 평범한 Str을 반환해요.

say val("42").^name;    # OUTPUT: «IntStr␤»
say val("42e0").^name;  # OUTPUT: «NumStr␤»
say val("42.0").^name;  # OUTPUT: «RatStr␤»
say val("42+0i").^name; # OUTPUT: «ComplexStr␤»

문자열의 일부로 플러스, 마이너스 기호와 Unicode "Minus Sign"을 쓸 수 있어요.

say val("−42");         # OUTPUT: «−42␤»

Unicode 범주 Nl(number letters)과 No(other numbers)에 속하는 문자는 언어에서 숫자 리터럴로 쓸 수 있지만, val로는 의도적으로 숫자로 변환되지 않아요. val을 쓰면 failure가 생겨요. 합성 숫자(예: 7̈)도 마찬가지예요. 그런 문자를 Numeric으로 변환하려면 unival을 참고하세요.

method Version

method Version(Str:D: --> Version:D)

Rakudo 2020.01 릴리스부터 사용 가능해요.

문자열을 Version으로 강제 변환해요.

이는 시그니처의 타입 강제 변환에 쓸 수 있어요. 예를 들어:

sub f(Version(Str) $want-version) { say $want-version.^name };
f "1.2.3";  # OUTPUT: «Version␤»

method Date

method Date(Str:D:)

Rakudo 2020.05 릴리스부터 사용 가능해요.

문자열이 제대로 형식화돼 있다면 Str을 Date 객체로 강제 변환해요. Date(Str)도 동작해요.

예시:

say '2015-11-24'.Date.year;  # OUTPUT: «2015␤»
say Date('2015-11-24').year; # OUTPUT: «2015␤»

method DateTime

method DateTime(Str:D:)

Rakudo 2020.05 릴리스부터 사용 가능해요.

문자열이 제대로 형식화돼 있다면 Str을 DateTime 객체로 강제 변환해요. DateTime(Str)도 동작해요.

예시:

say ('2012-02-29T12:34:56Z').DateTime.hour; # OUTPUT: «12␤»
say DateTime('2012-02-29T12:34:56Z').hour;  # OUTPUT: «12␤»

Rakudo 2022.07 릴리스부터는 "YYYY-MM-DD" 문자열만 지정해 그 날짜의 자정을 나타낼 수도 있어요.

say "2023-03-04".DateTime;  # OUTPUT: «2023-03-04T00:00:00Z␤»