Cool 타입

Cool 타입 (raku-type-cool)

문자열로도 숫자로도 다룰 수 있는 객체들의 기반 클래스예요. "Convenient OO Loop"의 줄임말이죠. Raku의 많은 내장 클래스가 Cool을 상속받는데, 그 덕에 값이 알아서 알맞은 형태로 강제 변환돼요.

출처: Raku Docs - Cool

정의

class Cool is Any { }

Cool은 문자열과 숫자로 의미 있게 강제 변환될 수 있는 인스턴스들을 가진 여러 내장 클래스의 기반 클래스예요. 예를 들어 Array는 수학 연산에 쓰일 수 있는데, 그때 숫자 표현은 배열이 담은 요소의 개수가 돼요. 동시에 문자열에 이어 붙일 수도 있는데, 그때는 모든 요소를 공백으로 이어 붙인 문자열 표현이 돼요. Array가 Cool이기 때문에 이런 강제 변환이 자동으로 일어나는 거예요.

Cool의 메서드는 invocant를 더 구체적인 타입으로 강제 변환한 뒤 같은 이름의 메서드를 그 타입에서 호출해요. Int와 Str 둘 다 Cool에서 상속받는데, 예를 들어 Int에서 substr을 호출하면 먼저 그 정수를 Str로 바꿔요.

123.substr(1, 1);   # '2', same as 123.Str.substr(1, 1)

몇몇 내장 타입이 Cool을 상속받아요. 아래 표는 Cool이 제공하는 메서드와 각자가 어떤 타입으로 강제 변환하는지를 정리한 거예요.

method	coercion type
abs	Numeric
conj	Numeric
sqrt	Numeric
sign	Real
rand	Numeric
sin	Numeric
asin	Numeric
cos	Numeric
acos	Numeric
tan	Numeric
tanh	Numeric
atan	Numeric
atan2	Numeric
atanh	Numeric
sec	Numeric
asec	Numeric
cosec	Numeric
acosec	Numeric
cotan	Numeric
cotanh	Numeric
acotan	Numeric
sinh	Numeric
asinh	Numeric
cosh	Numeric
acosh	Numeric
sech	Numeric
asech	Numeric
cosech	Numeric
acosech	Numeric
acotanh	Numeric
cis	Numeric
log	Numeric
exp	Numeric
roots	Numeric
log10	Numeric
log2	Numeric
unpolar	Numeric
round	Numeric
floor	Numeric
ceiling	Numeric
truncate	Numeric
chr	Int
ord	Str
chars	Str
fmt	Str
uniname	Str
uninames	Seq
unival	Str
univals	Str
uniprop	Str
unimatch	Str
uc	Str
lc	Str
fc	Str
tc	Str
tclc	Str
flip	Str
trans	Str
contains	Str
index	Str
rindex	Str
ords	Str
split	Str
match	Str
comb	Str
subst	Str
sprintf	Str
printf	Str
samecase	Str
trim	Str
trim-leading	Str
trim-trailing	Str
EVAL	Str
chomp	Str
chop	Str
codes	Str
Complex	Numeric
FatRat	Numeric
Int	Numeric
Num	Numeric
Rat	Numeric
Real	Numeric
UInt	Numeric

메서드

routine abs

sub abs(Numeric() $x)
method abs()

invocant(서브 형식에서는 인자)을 Numeric으로 강제 변환하고 절댓값(즉 음이 아닌 수)을 돌려줘요.

say (-2).abs;       # OUTPUT: «2␤»
say abs "6+8i";     # OUTPUT: «10␤»

method conj

method conj()

invocant를 Numeric으로 강제 변환하고 Complex 켤레(허수부 부호를 뒤집은 수)를 돌려줘요.

say "1+2i".conj;        # OUTPUT: «1-2i␤»

method EVAL

method EVAL(*%_)

invocant를 첫 인자 $code로 넘기면서 루틴 형식의 EVAL을 호출해요. 이름 인자가 있으면 그대로 전달해요.

routine sqrt

sub sqrt(Numeric(Cool) $x)
method sqrt()

invocant를 Numeric으로 강제 변환하고 제곱근을 돌려줘요. 즉 스스로를 곱하면 원래 수가 되는 수예요.

say 4.sqrt;             # OUTPUT: «2␤»
say sqrt(2);            # OUTPUT: «1.4142135623731␤»

음수 인자에는 NaN을 돌려줘요. 6.e 언어 버전부터는(라쿠도 컴파일러 2023.02+에 초기 구현 존재) 음수 인자에 Complex 값을 돌려줘요.

say sqrt(-1);           # OUTPUT: «0+1i␤»

method sign

method sign()

invocant를 Real로 강제 변환하고 부호를 돌려줘요. 수가 0이면 0, 양수면 1, 음수면 -1이에요.

say 6.sign;             # OUTPUT: «1␤»
say (-6).sign;          # OUTPUT: «-1␤»
say "0".sign;           # OUTPUT: «0␤»

method rand

method rand()

invocant를 Num으로 강제 변환하고 0과 그 수 사이의 의사 난수 값을 돌려줘요.

say 1e5.rand;           # OUTPUT: «33128.495184283␤»

routine sin

sub sin(Numeric(Cool))
method sin()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고, 라디안으로 해석해 사인(sine)을 돌려줘요.

say sin(0);             # OUTPUT: «0␤»
say sin(pi/4);          # OUTPUT: «0.707106781186547␤»
say sin(pi/2);          # OUTPUT: «1␤»

Raku는 컴퓨터 대수 시스템이 아니라서 sin(pi)가 정확히 0을 내지는 않고 아주 작은 Num을 내준다는 점을 기억하세요.

routine asin

sub asin(Numeric(Cool))
method asin()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 라디안 단위의 아크사인(arc-sine)을 돌려줘요.

say 0.1.asin;               # OUTPUT: «0.10016742116156␤»
say asin(0.1);              # OUTPUT: «0.10016742116156␤»

routine cos

sub cos(Numeric(Cool))
method cos()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고, 라디안으로 해석해 코사인(cosine)을 돌려줘요.

say 0.cos;                  # OUTPUT: «1␤»
say pi.cos;                 # OUTPUT: «-1␤»
say cos(pi/2);              # OUTPUT: «6.12323399573677e-17␤»

routine acos

sub acos(Numeric(Cool))
method acos()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 라디안 단위의 아크코사인(arc-cosine)을 돌려줘요.

say 1.acos;                 # OUTPUT: «0␤»
say acos(-1);               # OUTPUT: «3.14159265358979␤»

routine tan

sub tan(Numeric(Cool))
method tan()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고, 라디안으로 해석해 탄젠트(tangent)를 돌려줘요.

say tan(3);                 # OUTPUT: «-0.142546543074278␤»
say 3.tan;                  # OUTPUT: «-0.142546543074278␤»

routine atan

sub atan(Numeric(Cool))
method atan()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 라디안 단위의 아크탄젠트(arc-tangent)를 돌려줘요.

say atan(3);                # OUTPUT: «1.24904577239825␤»
say 3.atan;                 # OUTPUT: «1.24904577239825␤»

routine atan2

sub atan2($y, $x = 1e0)
method atan2($x = 1e0)

서브는 다른 언어나 수학 텍스트에서 보던 것처럼 명확히 두 인자로 쓰는 게 보통이에요. 하지만 단일 인자 형식도 있고, 그 결과는 항상 atan과 일치해요.

say atan2 3, 1;             # OUTPUT: «1.2490457723982544␤»
say atan2 3;                # OUTPUT: «1.2490457723982544␤»
say atan2 ⅔, ⅓;             # OUTPUT: «1.1071487177940904␤»

메서드는 self와 단일 인자를 Numeric으로 강제 변환해 라디안 단위의 두 인자 아크탄젠트(atan2)를 계산해요.

say 3.atan2;                # OUTPUT: «1.24904577239825␤»
say ⅔.atan2(⅓);             # OUTPUT: «1.1071487177940904␤»

메서드든 서브든 $x 인자는 기본값이 1이라서, 두 단일 인자 경우 모두 x축에서 원점-점(3, 1) 벡터까지의 각도 θ(라디안)를 돌려줘요.

routine sec

sub sec(Numeric(Cool))
method sec()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고, 라디안으로 해석해 시컨트(secant), 즉 코사인의 역수를 돌려줘요.

say 45.sec;                 # OUTPUT: «1.90359440740442␤»
say sec(45);                # OUTPUT: «1.90359440740442␤»

routine asec

sub asec(Numeric(Cool))
method asec()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 라디안 단위의 아크시컨트(arc-secant)를 돌려줘요.

say 1.asec;                 # OUTPUT: «0␤»
say sqrt(2).asec;           # OUTPUT: «0.785398163397448␤»

routine cosec

sub cosec(Numeric(Cool))
method cosec()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고, 라디안으로 해석해 코시컨트(cosecant), 즉 사인의 역수를 돌려줘요.

say 0.45.cosec;             # OUTPUT: «2.29903273150897␤»
say cosec(0.45);            # OUTPUT: «2.29903273150897␤»

routine acosec

sub acosec(Numeric(Cool))
method acosec()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 라디안 단위의 아크코시컨트(arc-cosecant)를 돌려줘요.

say 45.acosec;              # OUTPUT: «0.0222240516182672␤»
say acosec(45)              # OUTPUT: «0.0222240516182672␤»

routine cotan

sub cotan(Numeric(Cool))
method cotan()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고, 라디안으로 해석해 코탄젠트(cotangent), 즉 탄젠트의 역수를 돌려줘요.

say 45.cotan;               # OUTPUT: «0.617369623783555␤»
say cotan(45);              # OUTPUT: «0.617369623783555␤»

routine acotan

sub acotan(Numeric(Cool))
method acotan()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 라디안 단위의 아크코탄젠트(arc-cotangent)를 돌려줘요.

say 45.acotan;              # OUTPUT: «0.0222185653267191␤»
say acotan(45)              # OUTPUT: «0.0222185653267191␤»

routine sinh

sub sinh(Numeric(Cool))
method sinh()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 쌍곡 사인(Sine hyperbolicus)을 돌려줘요.

say 1.sinh;                 # OUTPUT: «1.1752011936438␤»
say sinh(1);                # OUTPUT: «1.1752011936438␤»

routine asinh

sub asinh(Numeric(Cool))
method asinh()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 역쌍곡 사인(Inverse Sine hyperbolicus)을 돌려줘요.

say 1.asinh;                # OUTPUT: «0.881373587019543␤»
say asinh(1);               # OUTPUT: «0.881373587019543␤»

routine cosh

sub cosh(Numeric(Cool))
method cosh()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 쌍곡 코사인(Cosine hyperbolicus)을 돌려줘요.

say cosh(0.5);              # OUTPUT: «1.12762596520638␤»

routine acosh

sub acosh(Numeric(Cool))
method acosh()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 역쌍곡 코사인(Inverse Cosine hyperbolicus)을 돌려줘요.

say acosh(45);              # OUTPUT: «4.4996861906715␤»

routine tanh

sub tanh(Numeric(Cool))
method tanh()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고, 라디안으로 해석해 쌍곡 탄젠트(Tangent hyperbolicus)를 돌려줘요.

say tanh(0.5);              # OUTPUT: «0.46211715726001␤»
say tanh(atanh(0.5));       # OUTPUT: «0.5␤»

routine atanh

sub atanh(Numeric(Cool))
method atanh()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 역쌍곡 탄젠트(Inverse tangent hyperbolicus)를 돌려줘요.

say atanh(0.5);             # OUTPUT: «0.549306144334055␤»

routine sech

sub sech(Numeric(Cool))
method sech()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 쌍곡 시컨트(Secant hyperbolicus)를 돌려줘요.

say 0.sech;                 # OUTPUT: «1␤»

routine asech

sub asech(Numeric(Cool))
method asech()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 역쌍곡 시컨트(Inverse hyperbolic secant)를 돌려줘요.

say 0.8.asech;              # OUTPUT: «0.693147180559945␤»

routine cosech

sub cosech(Numeric(Cool))
method cosech()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 쌍곡 코시컨트(Hyperbolic cosecant)를 돌려줘요.

say cosech(pi/2);           # OUTPUT: «0.434537208094696␤»

routine acosech

sub acosech(Numeric(Cool))
method acosech()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 역쌍곡 코시컨트(Inverse hyperbolic cosecant)를 돌려줘요.

say acosech(4.5);           # OUTPUT: «0.220432720979802␤»

routine cotanh

sub cotanh(Numeric(Cool))
method cotanh()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 쌍곡 코탄젠트(Hyperbolic cotangent)를 돌려줘요.

say cotanh(pi);             # OUTPUT: «1.00374187319732␤»

routine acotanh

sub acotanh(Numeric(Cool))
method acotanh()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 역쌍곡 코탄젠트(Inverse hyperbolic cotangent)를 돌려줘요.

say acotanh(2.5);           # OUTPUT: «0.423648930193602␤»

routine cis

sub cis(Numeric(Cool))
method cis()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 cos(argument) + i*sin(argument)(cis)를 돌려줘요.

say cis(pi/4);              # OUTPUT: «0.707106781186548+0.707106781186547i␤»

routine log

multi        log(Numeric(Cool) $number, Numeric(Cool) $base?)
multi method log(Cool:D: Cool:D $base?)

인자들(메서드 형식에서는 invocant 포함)을 Numeric으로 강제 변환하고 $base를 밑으로 하는 로그(Logarithm)를 돌려줘요. 밑을 주지 않으면 e(오일러 수)를 밑으로 하는 자연로그(Natural logarithm)가 돼요. $base가 1이면 예외를 던져요.

say (e*e).log;              # OUTPUT: «2␤»

음수 인자에는 NaN을 돌려줘요. 6.e 언어 버전부터는(라쿠도 컴파일러 2023.02+에 초기 구현 존재) 음수 인자에 Complex 값을 돌려줘요.

routine log10

multi method log10()
multi        log10(Numeric $x)
multi        log10(Cool    $x)

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고(이미 그 형식이면 그냥 쓰고) 밑 10 로그를 돌려줘요. 즉 10을 그 수만큼 거듭제곱하면 대략 원래 수가 되는 수예요. 0에는 -Inf를 돌려줘요.

say log10(1001);            # OUTPUT: «3.00043407747932␤»

음수 인자에는 NaN을 돌려줘요. 6.e 언어 버전부터는(라쿠도 컴파일러 2023.02+에 초기 구현 존재) 음수 인자에 Complex 값을 돌려줘요.

routine log2

multi method log2()
multi        log2(Numeric $x)
multi        log2(Cool    $x)

invocant를 Numeric으로 강제 변환하고 밑 2 로그를 돌려줘요. 즉 2를 그 수만큼 거듭제곱하면(컴퓨터 정밀도 한계 때문에 대략) 원래 수가 되는 수예요. 0에는 -Inf를 돌려줘요.

say log2(5);            # OUTPUT: «2.321928094887362␤»
say "4".log2;           # OUTPUT: «2␤»
say 4.log2;             # OUTPUT: «2␤»

음수 인자에는 NaN을 돌려줘요. 6.e 언어 버전부터는(라쿠도 컴파일러 2023.02+에 초기 구현 존재) 음수 인자에 Complex 값을 돌려줘요.

routine exp

multi        exp(Cool:D $pow, Cool:D $base?)
multi method exp(Cool:D: Cool:D $base?)

인자들(메서드 형식에서는 invocant 포함)을 Numeric으로 강제 변환하고 $base를 첫 번째 수만큼 거듭제곱한 값을 돌려줘요. $base를 주지 않으면 e(오일러 수)를 써요.

say 0.exp;      # OUTPUT: «1␤»
say 1.exp;      # OUTPUT: «2.71828182845905␤»
say 10.exp;     # OUTPUT: «22026.4657948067␤»

method unpolar

method unpolar(Numeric(Cool))

인자들(메서드 형식에서는 invocant 포함)을 Numeric으로 강제 변환하고, 주어진 극좌표에서 복소수를 만들어요. invocant(서브 형식에서는 첫 인자)는 크기(magnitude)이고, 인자(서브 형식에서는 두 번째 인자)는 각도예요. 각도는 라디안으로 간주해요.

say sqrt(2).unpolar(pi/4);      # OUTPUT: «1+1i␤»

routine round

multi        round(Numeric(Cool), $scale = 1)
multi method round(Cool:D: $scale = 1)

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 $scale 단위로 반올림해요. $scale이 1이면 가장 가까운 정수로 반올림하고, 다른 배수면 그 수의 가장 가까운 배수가 돼요.

say 1.7.round;          # OUTPUT: «2␤»
say 1.07.round(0.1);    # OUTPUT: «1.1␤»
say 21.round(10);       # OUTPUT: «20␤»
say round(1000, 23.01)  # OUTPUT: «989.43␤»

수가 정확히 중간에 있으면 항상 올림해요.

say (−.5 ).round;       # OUTPUT: «0␤»
say ( .5 ).round;       # OUTPUT: «1␤»
say (−.55).round(.1);   # OUTPUT: «-0.5␤»
say ( .55).round(.1);   # OUTPUT: «0.6␤»

이 메서드를 쓸 때는 타입에 주의하세요. 원하는 정밀도를 얻으려면 타입이 맞아야 해요. Real 타입에서는 결과 타입이 인자 타입이 돼요(Complex 인자는 Real로 강제 변환돼 Num이 됨). Complex를 반올림하면 인자 타입과 무관하게 결과도 Complex예요.

9930972392403501.round(1)      .raku.say; # OUTPUT: «9930972392403501␤»
9930972392403501.round(1e0)    .raku.say; # OUTPUT: «9.9309723924035e+15␤»
9930972392403501.round(1e0).Int.raku.say; # OUTPUT: «9930972392403500␤»

routine floor

multi        floor(Numeric(Cool))
multi method floor

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 가장 가까운 정수로 내림해요.

say "1.99".floor;       # OUTPUT: «1␤»
say "-1.9".floor;       # OUTPUT: «-2␤»
say 0.floor;            # OUTPUT: «0␤»

method fmt

method fmt($format = '%s')

$format으로 invocant의 형식화된 표현을 돌려줘요. sprintf를 $format을 형식 문자열로, invocant를 두 번째 인자로 호출한 것과 같아요. $format은 Stringy로 강제 변환되고 기본값은 '%s'예요.

형식 문자열에 대한 자세한 내용은 sprintf 문서를 보세요.

say 11.fmt('This Int equals %03d');         # OUTPUT: «This Int equals 011␤»
say '16'.fmt('Hexadecimal %x');             # OUTPUT: «Hexadecimal 10␤»

routine ceiling

multi        ceiling(Numeric(Cool))
multi method ceiling

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 가장 가까운 정수로 올림해요.

say "1".ceiling;        # OUTPUT: «1␤»
say "-0.9".ceiling;     # OUTPUT: «0␤»
say "42.1".ceiling;     # OUTPUT: «43␤»

routine truncate

multi        truncate(Numeric(Cool))
multi method truncate()

invocant(서브 형식에서는 인자)를 Numeric으로 강제 변환하고 0 방향으로 반올림해요(버림).

say 1.2.truncate;       # OUTPUT: «1␤»
say truncate -1.2;      # OUTPUT: «-1␤»

routine ord

sub ord(Str(Cool))
method ord()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 첫 코드포인트(code point)의 유니코드 코드포인트 번호를 돌려줘요.

say 'a'.ord;            # OUTPUT: «97␤»

역연산은 chr이에요. 기억하기 좋게는 "서수(ordinal) 번호를 돌려준다"고 외우면 돼요.

method path

method path(Cool:D: --> IO::Path:D)

DEPRECATED(지원 중단). 6.d 버전부터 지원이 중단됐어요. 이후 버전에서 제거될 예정이에요.

invocant를 문자열로 바꿔 IO::Path 객체로 변환해요. 대신 .IO 메서드를 쓰세요.

routine chr

sub chr(Int(Cool))
method chr()

invocant(서브 형식에서는 인자)를 Int로 강제 변환하고 유니코드 코드포인트(code points)로 해석해, 그 코드포인트로 이루어진 Str을 돌려줘요.

say '65'.chr;       # OUTPUT: «A␤»

역연산은 ord예요. "정수를 character(문자)로 바꾼다"고 외우면 돼요.

routine chars

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

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 문자열의 문자 수를 돌려줘요. JVM에서는 현재 그래핌 대신 코드포인트를 얻는다는 점을 주의하세요.

say 'møp'.chars;    # OUTPUT: «3␤»
say 'ã̷̠̬̊'.chars;     # OUTPUT: «1␤»
say '👨‍👩‍👧‍👦🏿'.chars;    # OUTPUT: «1␤»

문자열이 native(기본형)면 문자 수도 native int로 돌려줘요.

그래핌(grapheme)은 사용자가 보는 문자예요. 즉 사용자가 "문자"라고 생각하는 것이죠. 그래핌은 코드포인트를 여럿 담을 수 있어요. 결합 문자(Combining characters)처럼 Prepend나 Extend 문자가 관여할 때 그래핌 수와 코드포인트 수가 보통 달라져요. \c[ZWJ](Zero-width joiner, 너비 없는 결합자)도 그런 예시예요.

문자의 Grapheme_Cluster_Break 속성으로 어떻게 행동할지 확인할 수 있어요.

say ‘ã̷̠̬̊’.uniprops(‘Grapheme_Cluster_Break’); # OUTPUT: «(Other Extend Extend Extend Extend)␤»
say ‘👨‍👩‍👧‍👦🏿’.uniprops(‘Grapheme_Cluster_Break’); # OUTPUT: «(E_Base_GAZ ZWJ E_Base_GAZ ZWJ E_Base_GAZ ZWJ E_Base_GAZ E_Modifier)␤»

그래핌에 대해 더 자세히 알고 싶다면 유니코드 표준(Unicode Standard)을 보세요. Raku는 NFG(normal form graphemes)라는 방식으로 그래핌을 효율적으로 표현하며 이 표준을 밀접하게 따르고 있어요.

routine codes

sub codes(Str(Cool))
method codes()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 유니코드 코드포인트(code points)의 개수를 돌려줘요.

say 'møp'.codes;    # OUTPUT: «3␤»

같은 결과를 이렇게도 얻을 수 있어요.

say +'møp'.ords;    # OUTPUT: «3␤»

ords는 먼저 실제 코드포인트를 얻는 거라 속도 차이가 있을 수 있어요.

routine flip

sub flip(Cool $s --> Str:D)
method flip()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 뒤집은 버전을 돌려줘요.

say 421.flip;       # OUTPUT: «124␤»

routine trim

sub trim(Str(Cool))
method trim()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 앞뒤 공백을 모두 벗긴 문자열을 돌려줘요.

my $stripped = '  abc '.trim;
say "<$stripped>";          # OUTPUT: «<abc>␤»

routine trim-leading

sub trim-leading(Str(Cool))
method trim-leading()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 앞 공백만 벗긴 문자열을 돌려줘요.

my $stripped = '  abc '.trim-leading;
say "<$stripped>";          # OUTPUT: «<abc >␤»

routine trim-trailing

sub trim-trailing(Str(Cool))
method trim-trailing()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 뒤 공백만 벗긴 문자열을 돌려줘요.

my $stripped = '  abc '.trim-trailing;
say "<$stripped>";          # OUTPUT: «<  abc>␤»

routine lc

sub lc(Str(Cool))
method lc()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 소문자로 case-fold한 결과를 돌려줘요.

say "ABC".lc;       # OUTPUT: «abc␤»

routine uc

sub uc(Str(Cool))
method uc()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 대문자로 case-fold한 결과를 돌려줘요.

say "Abc".uc;       # OUTPUT: «ABC␤»

routine fc

sub fc(Str(Cool))
method fc()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고, 대소문자 구분 없는 문자열 비교에 알맞은 유니코드 "case fold" 연산 결과를 돌려줘요. (일반적으로 돌려받은 문자열은 비교 말고 다른 목적에는 별로 쓸모가 없을 거예요.)

say "groß".fc;       # OUTPUT: «gross␤»

routine tc

sub tc(Str(Cool))
method tc()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 첫 글자를 titlecase(없으면 대문자)로 case-fold한 결과를 돌려줘요.

say "abC".tc;       # OUTPUT: «AbC␤»

routine tclc

sub tclc(Str(Cool))
method tclc()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 첫 글자는 titlecase(없으면 대문자)로, 나머지는 소문자로 case-fold한 결과를 돌려줘요.

say 'abC'.tclc;     # OUTPUT: «Abc␤»

routine wordcase

sub wordcase(Str(Cool) $input, :&filter = &tclc, Mu :$where = True)
method wordcase(:&filter = &tclc, Mu :$where = True)

invocant(서브 형식에서는 첫 인자)를 Str로 강제 변환하고, $where에 스마트매치되는 각 단어를 &filter로 걸러내요. 기본 필터(첫 글자 대문자, 나머지 소문자)와 기본 매처(모든 것을 받아들임)로는 각 단어를 titlecase로 만들어요.

say "raku programming".wordcase;        # OUTPUT: «Raku Programming␤»

매처를 쓰면 이렇게 돼요.

say "have fun working on raku".wordcase(:where({ .chars > 3 }));
                                # Have fun Working on Raku

사용자 필터도 같이 쓰면 이렇게 돼요.

say "have fun working on raku".wordcase(:filter(&uc), :where({ .chars > 3 }));
                                # HAVE fun WORKING on RAKU

routine samecase

sub samecase(Cool $string, Cool $pattern)
method samecase(Cool:D: Cool $pattern)

invocant(서브 형식에서는 첫 인자)를 Str로 강제 변환하고 그 위에 Str.samecase를 호출해요.

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

$pattern의 대소문자 패턴을 그대로 따라가서 각 위치의 대소문자를 맞춰주는 거예요.

routine uniprop

multi        uniprop(Str:D, |c)
multi        uniprop(Int:D $code)
multi        uniprop(Int:D $code, Stringy:D $propname)
multi method uniprop(|c)

첫 문자의 유니코드 속성(unicode property)을 돌려줘요. 속성을 지정하지 않으면 일반 범주(General Category)를 돌려줘요. 불리언 속성에 대해서는 Bool을 돌려줘요. 문자열의 모든 문자에 대한 속성을 얻으려면 uniprops 루틴을 쓸 수 있어요.

say 'a'.uniprop;               # OUTPUT: «Ll␤»
say '1'.uniprop;               # OUTPUT: «Nd␤»
say 'a'.uniprop('Alphabetic'); # OUTPUT: «True␤»
say '1'.uniprop('Alphabetic'); # OUTPUT: «False␤»

sub uniprops

sub uniprops(Str:D $str, Stringy:D $propname = "General_Category")

invocant를 Str로 해석하고, 각 문자에 대한 유니코드 속성(unicode property)을 Seq로 돌려줘요. 속성을 지정하지 않으면 일반 범주를 돌려줘요. 불리언 속성은 Bool을 돌려줘요. uniprop과 비슷하지만 전달된 문자열의 각 문자에 대해서 동작해요.

routine uniname

sub uniname(Str(Cool) --> Str)
method uniname(--> Str)

invocant나 첫 인자를 Str로 해석하고, 첫 문자의 첫 코드포인트에 대한 유니코드 코드포인트 이름을 돌려줘요. 여러 코드포인트를 다루는 uninames와, 반대 방향인 uniparse도 참고하세요.

# Camelia in Unicode
say ‘»ö«’.uniname;
# OUTPUT: «RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK␤»
say "Ḍ̇".uniname; # Note, doesn't show "COMBINING DOT ABOVE"
# OUTPUT: «LATIN CAPITAL LETTER D WITH DOT BELOW␤»

# Find the char with the longest Unicode name.
say (0..0x1FFFF).sort(*.uniname.chars)[*-1].chr.uniname;
# OUTPUT: «BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE RIGHT AND MIDDLE LEFT TO LOWER CENTRE␤»

라쿠도 컴파일러 2021.04 릴리스부터 사용할 수 있어요.

routine uninames

sub uninames(Str:D)
method uninames()

주어진 Str의 모든 코드포인트에 대한 유니코드 이름들의 Seq를 돌려줘요.

say ‘»ö«’.uninames.raku;
# OUTPUT: «("RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK", "LATIN SMALL LETTER O WITH DIAERESIS", "LEFT-POINTING DOUBLE ANGLE QUOTATION MARK").Seq␤»

이 예시도 보세요. 각 요소가 그 문자의 모든 코드포인트에 대한 Seq인 Seq를 얻어요.

say "Ḍ̇'oh".comb>>.uninames.raku;
# OUTPUT: «(("LATIN CAPITAL LETTER D WITH DOT BELOW", "COMBINING DOT ABOVE").Seq, ("APOSTROPHE",).Seq, ("LATIN SMALL LETTER O",).Seq, ("LATIN SMALL LETTER H",).Seq)␤»

주어진 Str의 첫 문자의 첫 코드포인트 이름은 uniname을, 반대 방향은 uniparse를 보세요.

routine unimatch

multi unimatch(Str:D $str, |c)
multi unimatch(Int:D $code, Stringy:D $pvalname, Stringy:D $propname = $pvalname)

주어진 정수 코드포인트나 주어진 문자열의 첫 글자가, 당신이 준 값과 같은 유니코드 속성을 가지는지 검사해요. 검사할 유니코드 속성을 지정하면 그 속성이 주어진 값과 일치할 때만 True를 돌려줘요.

say unimatch 'A', 'Latin';           # OUTPUT: «True␤»
say unimatch 'A', 'Latin', 'Script'; # OUTPUT: «True␤»
say unimatch 'A', 'Ll';              # OUTPUT: «False␤»

마지막 속성은 "소문자"를 뜻해서 False가 나오는 거예요.

routine chop

sub chop(Str(Cool))
method chop()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고 마지막 문자를 뗀 문자열을 돌려줘요.

say 'raku'.chop;                        # OUTPUT: «rak␤»

routine chomp

sub chomp(Str(Cool))
method chomp()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고, 마지막 문자가 논리적 줄바꿈이면 그 문자를 뗀 문자열을 돌려줘요.

say 'ab'.chomp.chars;                   # OUTPUT: «2␤»
say "a\n".chomp.chars;                  # OUTPUT: «1␤»

routine substr

sub substr(Str(Cool) $str, |c)
method substr(|c)

invocant(서브 형식에서는 첫 인자)를 Str로 강제 변환하고 그 위에 Str.substr을 인자들과 함께 호출해요.

routine substr-rw

multi method substr-rw(|) is rw
multi        substr-rw(|) is rw

invocant(서브 형식에서는 첫 인자)를 Str로 강제 변환하고 그 위에 Str.substr-rw를 인자들과 함께 호출해요.

routine ords

sub ords(Str(Cool) $str)
method ords()

invocant(서브 형식에서는 첫 인자)를 Str로 강제 변환하고 각 문자에 대한 유니코드 코드포인트 목록을 돌려줘요.

say "Camelia".ords;              # OUTPUT: «67 97 109 101 108 105 97␤»
say ords 10;                     # OUTPUT: «49 48␤»

이것은 ord의 목록 반환 버전이에요. 역연산은 chrs. 코드포인트 개수만 궁금하다면 codes가 더 빠를 수 있어요.

routine chrs

sub chrs(*@codepoints --> Str:D)
method chrs()

invocant(서브 형식에서는 인자 목록)를 정수 목록으로 강제 변환하고, 각 정수를 유니코드 코드포인트로 해석해 문자들을 이어 붙인 문자열을 돌려줘요.

say <67 97 109 101 108 105 97>.chrs;   # OUTPUT: «Camelia␤»

이것은 chr의 목록 입력 버전이에요. 역연산은 ords.

routine split

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

invocant(서브 형식에서는 두 번째 인자)를 Str로 강제 변환하고, 문자열에서 찾은 구분자들을 기준으로 조각들을 나눠 Seq로 돌려줘요.

$delimiter가 문자열이면 리터럴로 검색되지 정규식으로 취급되지 않아요. 구분자를 목록으로 지정해 여러 개 줄 수도 있는데, Cool과 Regex 객체를 섞을 수 있어요.

say split(';', "a;b;c").raku;               # OUTPUT: «("a", "b", "c").Seq␤»
say split(';', "a;b;c", 2).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+/, 4], '1a2bb345').raku; # OUTPUT: «("1", "2", "3", "5").Seq␤»

기본적으로 split은 매치 부분을 빼고, 매치되지 않은 부분만 목록으로 돌려줘요. :k, :v, :kv, :p 부사 중 하나를 지정하면 그게 달라져요. 매치들을 매치되지 않은 부분들과 번갈아 끼워 넣은 목록이라고 생각하면 돼요.

:v는 그 목록의 값들을 번갈아 끼워 넣어요. 정규식을 매처로 썼다면 Match 객체, Cool을 매처로 썼다면 Str 객체가 돼요. 구분자를 여러 개 지정하면 전부 Cool이 아닌 한 모든 구분자에 대해 Match 객체가 생성돼요.

say 'abc'.split(/b/, :v);               # OUTPUT: «(a ｢b｣ c)␤»
say 'abc'.split('b', :v);               # OUTPUT: «(a b c)␤»

:k는 키, 즉 인덱스들을 번갈아 끼워 넣어요.

say 'abc'.split(/b/, :k);               # OUTPUT: «(a 0 c)␤»

:kv는 인덱스와 매치 둘 다 넣어요.

say 'abc'.split(/b/, :kv);               # OUTPUT: «(a 0 ｢b｣ c)␤»

:p는 그것들을 Pair로 넣는데, 값 타입은 :v와 같은 규칙을 따라요.

say 'abc'.split(/b/, :p);               # OUTPUT: «(a 0 => ｢b｣ c)␤»
say 'abc'.split('b', :p);               # OUTPUT: «(a 0 => b c)␤»

한 번의 split 호출에서는 :k, :v, :kv, :p 중 하나만 쓸 수 있어요.

빈 조각은 결과 목록에서 제거되지 않는다는 점을 주의하세요. 그 동작을 원하면 :skip-empty 이름 인자를 쓰세요.

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

routine lines

sub lines(Str(Cool))
method lines()

invocant(서브 형식에서는 인자)를 Str로 강제 변환하고, 줄바꿈 문자를 뗀 줄들로 분해해 그 줄들 목록을 돌려줘요.

say lines("a\nb\n").join('|');          # OUTPUT: «a|b␤»
say "some\nmore\nlines".lines.elems;    # OUTPUT: «3␤»

이 메서드는 IO::Path 객체가 Cool을 상속받으므로 파일을 줄 단위로 처리할 때 쓸 수 있어요.

for 'huge-csv'.IO.lines -> $line {
    # Do something with $line
}

# or if you'll be processing later
my @lines = 'huge-csv'.IO.lines;

인자 없이 서브 lines를 호출하면 $*ARGFILES에서 동작해요. 값을 제자리에서 바꾸려면 is copy로 쓰기 가능한 컨테이너를 강제하세요.

for $*IN.lines -> $_ is copy { s/(\w+)/{$0 ~ $0}/; .say }

method words

method words(Cool:D: |c)

invocant(서브루틴으로 호출하면 첫 인자)를 Str로 강제 변환하고, 문자열을 이루는 단어 목록을 돌려줘요. 추가 인자와 그 의미는 Str.words를 확인하세요.

say <The quick brown fox>.words.join('|');     # OUTPUT: «The|quick|brown|fox␤»
say <The quick brown fox>.words(2).join('|');  # OUTPUT: «The|quick␤»

Cool은 많은 다른 클래스의 기반이고, Match 같은 일부 클래스는 문자열로 변환될 수 있어요. 바로 그게 여기서 일어나는 일이에요.

say ( "easy come, easy goes" ~~ m:g/(ea\w+)/).words(Inf);
# OUTPUT: «(easy easy)␤»
say words( "easy come, easy goes" ~~ m:g/(ea\w+)/ , ∞);
# OUTPUT: «(easy easy)␤»

위 예시는 words를 호출하는 두 방법을 보여줘요. 첫 인자는 시그니처에 의해 invocant로 바뀌죠. Inf는 두 번째 인자의 기본값이라서 두 경우(그리고 두 형식) 모두 그냥 생략할 수 있어요.

오직 공백(줄바꿈 없는 공백 포함)만 단어 경계로 취급돼요.

say <Flying on a Boeing 747>.words.join('|');  # OUTPUT: «Flying|on|a|Boeing|747␤»

이 경우 "Boeing 747"에는 (소스에서만 보이는) 줄바꿈 없는 공백이 포함돼 있어요. 원래 배열이 4개 요소였어도 words는 (결과) Str을 그 공백에서 여전히 나눠요.

say <Flying on a Boeing 747>.join('|');        # OUTPUT: «Flying|on|a|Boeing 747␤»

더 많은 예시와 호출 방법은 Str.words를 보세요.

routine comb

multi        comb(Regex $matcher, Cool $input, $limit = *)
multi        comb(Str $matcher, Cool $input, $limit = *)
multi        comb(Int:D $size, Cool $input, $limit = *)
multi method comb(|c)

Regex, 문자열, 또는 정의된 숫자에 대한 invocant(메서드 형식) 또는 두 번째 인자(서브 형식)의 모든 매치(지정하면 많아야 $limit개)의 Seq를 돌려줘요.

say "6 or 12".comb(/\d+/).join(", ");           # OUTPUT: «6, 12␤»
say comb(/\d <[1..9]> /,(11..30)).join("--");
# OUTPUT:
# «11--12--13--14--15--16--17--18--19--21--22--23--24--25--26--27--28--29␤»

두 번째 문장은 comb의 첫 번째 형식 예시예요. 10의 배수를 제외하는 Regex와 Cool인 Range가 $input으로 쓰였죠. comb은 결과 문자열에 .comb을 적용하기 전에 Range를 문자열화해요. 서로 다른 종류의 입력 문자열에 어떻게 작용하는지는 Str.comb을 확인하세요. 첫 인자가 정수면 입력을 나눌 조각의 (최대) 크기를 나타내요.

say comb(3,[3,33,333,3333]).join("*");  # OUTPUT: «3 3*3 3*33 *333*3␤»

이 경우 입력은 리스트인데, Str로 변환된 뒤(공백 포함) 크기 3의 조각으로 나눠져요.

method contains

method contains(Cool:D: |c)

invocant를 Str로 강제 변환하고 그 위에 Str.contains를 호출해요. 인자와 일반 문법은 그 메서드 버전을 참고하세요.

say 123.contains("2")# OUTPUT: «True␤»

Int는 Cool의 하위 클래스라서 123이 Str로 강제 변환된 뒤 contains가 호출돼요.

say (1,1, * + * … * > 250).contains(233)# OUTPUT: «True␤»

Seq도 Cool의 하위 클래스이고 쉼표로 구분된 형태로 문자열화돼요. 이 경우 Int도 썼는데 역시 문자열화될 거예요. "233"이 그 시퀀스에 포함돼 있으니 True를 돌려줘요. 이 시퀀스는 지연(lazy)이 아니라는 점에 주의하세요. 지연 시퀀스의 문자열화는 당연한 이유로 각 성분을 다 포함하지 않아요.

routine index

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

첫 두 인자(메서드 형식에서는 invocant도 포함)를 Str로 강제 변환하고, 문자열 $s에서 $pos부터 $needle을 검색해요. $needle이 발견된 문자열 안의 오프셋을 돌려주고, 발견하지 못하면 Nil을 돌려줘요.

예시는 Str 타입 문서를 보세요.

routine rindex

multi        rindex(Cool:D $s, Cool:D $needle --> Int:D)
multi        rindex(Cool:D $s, Cool:D $needle, Cool:D $pos --> Int:D)
multi method rindex(Cool:D: Cool:D $needle --> Int:D)
multi method rindex(Cool:D: Cool:D $needle, Cool:D $pos --> Int:D)

첫 두 인자(메서드 형식에서는 invocant 포함)를 Str로, $pos를 Int로 강제 변환하고, $pos보다 앞(이하)에 있는 $needle의 마지막 위치를 돌려줘요. $needle을 찾지 못하면 Nil을 돌려줘요.

예시는 Str 타입 문서를 보세요.

method match

method match(Cool:D: $target, *%adverbs)

invocant를 Stringy로 강제 변환하고 그 위에 match 메서드를 호출해요.

routine roots

multi        roots(Numeric(Cool) $x, Int(Cool) $n)
multi method roots(Int(Cool) $n)

첫 인자(메서드 형식에서는 invocant)를 Numeric으로, 두 번째 $n을 Int로 강제 변환하고, $n개의 Complex 제곱근 목록을 만들어요. 즉 $n제곱하면 대략 원래 수가 되는 수들이죠.

예를 들면 이렇게요.

my $original = 16;
my @roots = $original.roots(4);
say @roots;

for @roots -> $r {
    say abs($r ** 4 - $original);
}

# OUTPUT:«2+0i 1.22464679914735e-16+2i -2+2.44929359829471e-16i -3.67394039744206e-16-2i␤»
# OUTPUT:«1.77635683940025e-15␤»
# OUTPUT:«4.30267170434156e-15␤»
# OUTPUT:«8.03651692704705e-15␤»
# OUTPUT:«1.04441561648202e-14␤»

method subst

method subst(|)

invocant를 Stringy로 강제 변환하고 Str.subst를 호출해요.

method trans

method trans(|)

invocant를 Str로 강제 변환하고 Str.trans를 호출해요.

method IO

method IO(--> IO::Path:D)

invocant를 IO::Path로 강제 변환해요.

.say for '.'.IO.dir;        # gives a directory listing

method sprintf

method sprintf(*@args)

많은 언어에서 흔한 일련의 형식 지시어에 따라 문자열을 돌려줘요. 객체가 형식 문자열이 되고, 주어진 인자들이 그 형식에 따라 포맷될 대상이 돼요.

"% 6s".sprintf('Þor').say; # OUTPUT: «   Þor␤»

method printf

method printf(*@args)

객체가 형식 문자열이 되는 한, 그 형식으로 인자들을 포맷해 출력해요.

"%.8f".printf(now - now ); # OUTPUT: «-0.00004118»

method Complex

multi method Complex()

invocant를 Numeric으로 강제 변환하고 그 .Complex 메서드를 호출해요. Numeric으로 강제 변환할 수 없으면 실패해요.

say 1+1i.Complex;         # OUTPUT: «1+1i␤»
say π.Complex;            # OUTPUT: «3.141592653589793+0i␤»
say <1.3>.Complex;        # OUTPUT: «1.3+0i␤»
say (-4/3).Complex;       # OUTPUT: «-1.3333333333333333+0i␤»
say "foo".Complex.^name;  # OUTPUT: «Failure␤»

method FatRat

multi method FatRat()

invocant를 Numeric으로 강제 변환하고 그 .FatRat 메서드를 호출해요. Numeric으로 강제 변환할 수 없으면 실패해요.

say 1+0i.FatRat;          # OUTPUT: «1␤»
say 2e1.FatRat;           # OUTPUT: «20␤»
say 1.3.FatRat;           # OUTPUT: «1.3␤»
say (-4/3).FatRat;        # OUTPUT: «-1.333333␤»
say "foo".FatRat.^name;   # OUTPUT: «Failure␤»

method Int

multi method Int()

invocant를 Numeric으로 강제 변환하고 그 .Int 메서드를 호출해요. Numeric으로 강제 변환할 수 없으면 실패해요.

say 1+0i.Int;             # OUTPUT: «1␤»
say <2e1>.Int;            # OUTPUT: «20␤»
say 1.3.Int;              # OUTPUT: «1␤»
say (-4/3).Int;           # OUTPUT: «-1␤»
say "foo".Int.^name;      # OUTPUT: «Failure␤»

method Num

multi method Num()

invocant를 Numeric으로 강제 변환하고 그 .Num 메서드를 호출해요. Numeric으로 강제 변환할 수 없으면 실패해요.

say 1+0i.Num;             # OUTPUT: «1␤»
say 2e1.Num;              # OUTPUT: «20␤»
say (16/9)².Num;          # OUTPUT: «3.1604938271604937␤»
say (-4/3).Num;           # OUTPUT: «-1.3333333333333333␤»
say "foo".Num.^name;      # OUTPUT: «Failure␤»

method Rat

multi method Rat()

invocant를 Numeric으로 강제 변환하고 그 .Rat 메서드를 호출해요. Numeric으로 강제 변환할 수 없으면 실패해요.

say 1+0i.Rat;                             # OUTPUT: «1␤»
say 2e1.Rat;                              # OUTPUT: «20␤»
say (-4/3).Rat;                           # OUTPUT: «-1.333333␤»
say "foo".Rat.^name;                      # OUTPUT: «Failure␤»
say (.numerator, .denominator) for π.Rat; # OUTPUT: «(355 113)␤»

method Real

multi method Real()

invocant를 Numeric으로 강제 변환하고 그 .Real 메서드를 호출해요. Numeric으로 강제 변환할 수 없으면 실패해요.

say 1+0i.Real;            # OUTPUT: «1␤»
say 2e1.Real;             # OUTPUT: «20␤»
say 1.3.Real;             # OUTPUT: «1.3␤»
say (-4/3).Real;          # OUTPUT: «-1.333333␤»
say "foo".Real.^name;     # OUTPUT: «Failure␤»

method UInt

multi method UInt()

invocant를 Int로 강제 변환해요. Int로 강제 변환할 수 없거나, invocant가 강제 변환된 Int가 음수면 실패해요.

say 1+0i.UInt;            # OUTPUT: «1␤»
say 2e1.UInt;             # OUTPUT: «20␤»
say 1.3.UInt;             # OUTPUT: «1␤»
say (-4/3).UInt.^name;    # OUTPUT: «Failure␤»
say "foo".UInt.^name;     # OUTPUT: «Failure␤»

method uniparse

method uniparse(Cool:D: --> Str:D)

라쿠도 컴파일러 2021.04 릴리스부터 사용할 수 있어요. invocant를 Str로 강제 변환한 뒤 그 위에 uniparse를 호출해요. 이건 주로 Match 객체에만 의미가 있어요.

method Order

method Order(Cool:D: --> Order:D)

라쿠도 컴파일러 2022.02 릴리스부터 사용할 수 있어요. invocant를 Int로 강제 변환한 뒤 Order 열거형 중 하나를 돌려줘요. 음수면 Less, 0이면 Same, 양수면 More예요.

method Failure

method Failure(Cool:D: --> Failure:D)

라쿠도 컴파일러 2022.06 릴리스부터 사용할 수 있어요. invocant의 문자열 표현으로 X::AdHoc 예외를 만들고 그것을 Failure 객체로 강제 변환해요. 주로 핫 코드가 인라인될 가능성을 높이기 위해 오류 분기 코드의 바이트코드를 줄이는 용도로 써요.