| ! | prefix | From (Operators) |
| !!! | listop | From (Operators) |
| !=, infix ≠ | infix | From (Operators) |
| % | infix | From (Operators) |
| %% | infix | From (Operators) |
| & | infix | From (Operators) |
| && | infix | From (Operators) |
| &*chdir | sub | From (Independent routines) |
| ( ) | term, postcircumfix | From (Operators, Operators) |
| (&), infix ∩ | infix | From (Operators, Sets, bags, and mixes) |
| (+), infix ⊎ | infix | From (Operators, Sets, bags, and mixes) |
| (<), infix ⊂ | infix | From (Operators, Sets, bags, and mixes) |
| (<=), infix ⊆ | infix | From (Operators, Sets, bags, and mixes) |
| (==), infix ≡ | infix | From (Operators, Sets, bags, and mixes) |
| (>), infix ⊃ | infix | From (Operators, Sets, bags, and mixes) |
| (>=), infix ⊇ | infix | From (Operators, Sets, bags, and mixes) |
| (^), infix ⊖ | infix | From (Operators, Sets, bags, and mixes) |
| (|), infix ∪ | infix | From (Operators, Sets, bags, and mixes) |
| (-), infix ∖ | infix | From (Operators, Sets, bags, and mixes) |
| (.), infix ⊍ | infix | From (Operators, Sets, bags, and mixes) |
| (C-like) form | prefix | From (Signature) |
| (cont), infix ∋ | infix | From (Operators, Sets, bags, and mixes) |
| (elem), infix ∈ | infix | From (Operators, Sets, bags, and mixes) |
| * | infix | From (Operators) |
| ** | infix | From (Operators) |
| + | prefix, infix | From (Operators, Operators) |
| +& | infix | From (Operators) |
| ++ | prefix, postfix | From (Operators, Operators) |
| ++⚛ | prefix | From (atomicint) |
| +< | infix | From (Operators) |
| +> | infix | From (Operators) |
| +^ | prefix, infix | From (Operators, Operators) |
| +| | infix | From (Operators) |
| , | infix | From (Operators) |
| ,= | postfix | From (Operators) |
| / | infix | From (Operators) |
| // | infix | From (Operators) |
| : | infix | From (Operators) |
| ::= | infix | From (Operators) |
| := | infix | From (Operators) |
| < | infix | From (Operators) |
| < > | term, postcircumfix | From (Operators, Operators) |
| <=, infix ≤ | infix | From (Operators) |
| <== | infix | From (Operators) |
| <=> | infix | From (Operators, Order) |
| <> | postcircumfix | From (Operators) |
| = (item assignment) | infix | From (Operators) |
| = (list assignment) | infix | From (Operators) |
| =:= | infix | From (Operators) |
| ==, infix ⩵ | infix | From (Operators) |
| === | infix, method | From (IntStr, RatStr, NumStr, ComplexStr, Enumeration) |
| ===, infix ⩶ | infix | From (Operators) |
| ==> | infix | From (Operators) |
| => | infix | From (Operators) |
| =~= | infix | From (Operators) |
| > | infix | From (Operators) |
| >=, infix ≥ | infix | From (Operators) |
| ? | prefix | From (Operators, Bool) |
| ?& | infix | From (Operators) |
| ?? !! | infix | From (Operators) |
| ??? | listop | From (Operators) |
| ?^ | prefix, infix | From (Operators, Operators) |
| ?| | infix | From (Operators) |
| [ ] | circumfix, postcircumfix | From (Operators, Operators) |
| ^ | prefix, infix | From (Operators, Operators) |
| ^^ | infix | From (Operators) |
| ^.. | infix | From (Operators) |
| ^..^ | infix | From (Operators) |
| ^ff | infix | From (Operators) |
| ^ff^ | infix | From (Operators) |
| ^fff | infix | From (Operators) |
| ^fff^ | infix | From (Operators) |
| { } | term, postcircumfix | From (Operators, Operators) |
| | | prefix, infix | From (Operators, Operators) |
| || | infix | From (Operators) |
| « » | postcircumfix | From (Operators) |
| π | term | From (Terms) |
| τ | term | From (Terms) |
| ∅ | term | From (Sets, bags, and mixes, Terms) |
| ∉ | infix | From (Operators, Sets, bags, and mixes) |
| ∌ | infix | From (Operators, Sets, bags, and mixes) |
| ≢ | infix | From (Operators, Sets, bags, and mixes) |
| ⊄ | infix | From (Operators, Sets, bags, and mixes) |
| ⊅ | infix | From (Operators, Sets, bags, and mixes) |
| ⊈ | infix | From (Operators, Sets, bags, and mixes) |
| ⊉ | infix | From (Operators, Sets, bags, and mixes) |
| ⚛ | prefix | From (Scalar, atomicint) |
| ⚛++ | postfix | From (atomicint) |
| ⚛+= | infix | From (atomicint) |
| ⚛= | infix | From (Scalar, atomicint) |
| ⚛−= | infix | From (atomicint) |
| ⚛-= | infix | From (atomicint) |
| ⚛-- | postfix | From (atomicint) |
| 𝑒 | term | From (Terms) |
| - | prefix, infix | From (Operators, Operators) |
| -- | prefix, postfix | From (Operators, Operators) |
| --⚛ | prefix | From (atomicint) |
| . | infix | From (Operators) |
| .= | infix | From (Operators) |
| .. | infix | From (Operators) |
| ..^ | infix | From (Operators) |
| ... | infix, listop | From (Operators, Operators) |
| ACCEPTS | method | From (Whatever, Baggy, Any, Signature, List, Mu, Numeric, Map, Setty, Pair, Regex, Bool, Allomorph, IO::Path, Str, Code, Range) |
| ASSIGN-KEY | method | From (Subscripts) |
| ASSIGN-POS | method | From (Subscripts) |
| AT-KEY | method | From (Subscripts, Associative) |
| AT-POS | method | From (Subscripts, Positional, Sequence, Range) |
| Array | method | From (Any) |
| BIND-KEY | method | From (Subscripts) |
| BIND-POS | method | From (Subscripts) |
| BUILD | submethod | From (Type system) |
| Bag | method | From (Any, MixHash, Setty, Mix) |
| BagHash | method | From (Any, MixHash, Setty, Mix) |
| Baggy | method | From (QuantHash) |
| Bool | method, routine | From (Baggy, Blob, List, Mu, Failure, Numeric, Map, Setty, Promise, Regex, Rational, Allomorph, Str, Junction, Capture, StrDistance, Proc, Match) |
| Bridge | method | From (Int, Rational, Num, Real) |
| CALL-ME | method | From (Enumeration, Callable) |
| CREATE | method | From (Mu) |
| Capture | method | From (Whatever, Blob, RatStr, Supply, Signature, List, Mu, Failure, QuantHash, Map, Seq, ComplexStr, Int, Str, Num, Capture, Callable, Version, Range, Channel) |
| Channel | method | From (Supply) |
| Complex | method | From (ComplexStr, Real, Cool) |
| DELETE-KEY | method | From (Subscripts) |
| DELETE-POS | method | From (Subscripts) |
| DESTROY | method, submethod | From (IO::CatHandle, IO::Handle) |
| DISTROnames | method | From (Raku) |
| Date | method | From (Date, DateTime, Instant, Str) |
| DateTime | method | From (Date, DateTime, Instant, Str) |
| EOF | method | From (IO::CatHandle, IO::Handle) |
| EVAL | routine, method | From (Independent routines, Cool) |
| EVALFILE | sub | From (Independent routines) |
| EXISTS-KEY | method | From (Subscripts, Associative) |
| EXISTS-POS | method | From (Subscripts, Positional, Sequence, Range) |
| FALLBACK | method | From (Nil) |
| FatRat | method | From (Num, Cool) |
| Hash | method | From (Any, QuantHash) |
| IO | method | From (Distribution::Resource, Dateish, IO::CatHandle, IO::Handle, IO::Notification::Change, IO::Path, IO::Pipe, IO::Special, Cool) |
| IO::Notification.watch-path | method | From (Supply) |
| Instant | method | From (DateTime) |
| Int | method, routine | From (IntStr, List, Map, Rational, Bool, IO::Path, Str, Num, Enumeration, Real, StrDistance, Cool, Match) |
| KERNELnames | method | From (Raku) |
| List | method | From (Any, Slip, Array) |
| MAIN | sub | From (Functions, Command line interface) |
| Map | method | From (Any) |
| Mix | method | From (Any, Setty) |
| MixHash | method | From (Any, Setty) |
| Mixy | method | From (QuantHash) |
| NFC | method | From (Uni, Str) |
| NFD | method | From (Uni, Str) |
| NFKC | method | From (Uni, Str) |
| NFKD | method | From (Uni, Str) |
| Num | method | From (NumStr, Rational, Str, Num, Real, Cool) |
| Numeric | method, routine | From (IntStr, Thread, RatStr, X::AdHoc, Sequence, List, Nil, NumStr, Numeric, Map, ComplexStr, Bool, IO::Path, Str, Endian, Capture, Enumeration, StrDistance) |
| Pair | method | From (Pair) |
| Promise | method | From (Supply) |
| READ | method | From (IO::CatHandle, IO::Handle) |
| Range | method | From (Int, Rational) |
| Rat | method | From (RatStr, Str, Num, Real, Cool) |
| Real | method | From (IntStr, RatStr, NumStr, ComplexStr, Complex, Enumeration, Real, Cool) |
| SPEC | method | From (IO::Path) |
| STORE | method | From (Subscripts, Subscripts, Positional, Associative) |
| Seq | method | From (Any, Supply, Seq) |
| Set | method | From (Baggy, Any, List) |
| SetHash | method | From (Baggy, Any) |
| Setty | method | From (QuantHash) |
| Slip | method | From (Any, Array) |
| Str | method | From (Date, Blob, Thread, Sequence, List, Nil, Mu, Backtrace, DateTime, Pair, Allomorph, IO::CatHandle, IO::Handle, IO::Path, IO::Special, Num, ForeignCode, Junction, Code, Systemic, Label, Real, StrDistance, Version, Match) |
| Stringy | method | From (Blob, Sequence) |
| Supply | method | From (Supplier, Any, Promise, IO::CatHandle, IO::Handle, IO::Socket::Async, Proc::Async, Channel) |
| T | routine | From (Telemetry) |
| UInt | method | From (Cool) |
| USAGE | sub | From (Command line interface) |
| VMnames | method | From (Raku) |
| Version | method | From (Str) |
| WHERE | method | From (Mu) |
| WHEREFORE | method | From (Pod::Block::Declarator) |
| WHICH | method | From (Mu, Allomorph, IO::Special, Range) |
| WHY | method | From (Mu, Metamodel::Documenting) |
| WRITE | method | From (IO::CatHandle, IO::Handle) |
| X | infix | From (Operators) |
| Z | infix | From (Operators) |
| abs | routine | From (Numeric, Complex, Cool) |
| abs2rel | method | From (IO::Spec::Cygwin, IO::Spec::Unix) |
| absolute | method | From (IO::Path) |
| accept | method | From (IO::Socket::INET) |
| accepts_type | method | From (Metamodel::DefiniteHOW) |
| accessed | method | From (IO::Path, IO::Special) |
| acos | routine | From (Cool) |
| acosec | routine | From (Cool) |
| acosech | routine | From (Cool) |
| acosh | routine | From (Cool) |
| acotan | routine | From (Cool) |
| acotanh | routine | From (Cool) |
| acquire | method | From (Semaphore) |
| act | method | From (Supply) |
| action | method | From (X::Cannot::Empty, X::Cannot::Lazy, X::TypeCheck::Splice) |
| actions | method | From (Match) |
| add | method | From (BagHash, IO::Path) |
| add_attribute | method | From (Metamodel::AttributeContainer) |
| add_enum_value | method | From (Metamodel::EnumHOW) |
| add_fallback | method | From (Metamodel::ClassHOW) |
| add_method | method | From (Metamodel::MethodContainer) |
| add_parent | method | From (Metamodel::EnumHOW, Metamodel::MultipleInheritance) |
| add_private_method | method | From (Metamodel::PrivateMethodContainer) |
| add_role | method | From (Metamodel::RoleContainer) |
| add_stash | method | From (Metamodel::Stashing) |
| add_trustee | method | From (Metamodel::Trusting) |
| addendum | method | From (X::Method::NotFound) |
| adverb | method | From (X::Syntax::Regex::Adverb) |
| after | infix, method | From (Operators, X::Parameter::WrongOrder, StrDistance) |
| all | method | From (Any) |
| allocate | method | From (Blob) |
| allof | method | From (Promise) |
| alternative-names | method | From (Encoding) |
| and | infix | From (Operators) |
| andthen | infix | From (Operators) |
| annotations | method | From (CallFrame) |
| antipair | method | From (Pair) |
| antipairs | method, routine | From (Baggy, Any, List, Map, Setty, Pair, Capture) |
| any | method | From (Any) |
| anyof | method | From (Promise) |
| api | method | From (Metamodel::Versioning) |
| app_lifetime | method | From (Thread) |
| append | method, sub | From (Any, Nil, Buf, Hash, Independent routines, Array) |
| arch | method | From (Kernel) |
| archetypes | method | From (Metamodel::PackageHOW) |
| archname | method | From (Kernel) |
| are | method | From (Any) |
| args | method | From (Proc::Async) |
| arity | method | From (Signature, ForeignCode, Code) |
| asec | routine | From (Cool) |
| asech | routine | From (Cool) |
| asin | routine | From (Cool) |
| asinh | routine | From (Cool) |
| assuming | method | From (Code) |
| ast | method | From (Match) |
| at | method | From (Promise) |
| atan | routine | From (Cool) |
| atan2 | routine | From (Cool) |
| atanh | routine | From (Cool) |
| atomic-assign | sub | From (Scalar, atomicint) |
| atomic-dec-fetch | sub | From (atomicint) |
| atomic-fetch | sub | From (Scalar, atomicint) |
| atomic-fetch-add | sub | From (atomicint) |
| atomic-fetch-dec | sub | From (atomicint) |
| atomic-fetch-inc | sub | From (atomicint) |
| atomic-fetch-sub | sub | From (atomicint) |
| atomic-inc-fetch | sub | From (atomicint) |
| attributes | method | From (Metamodel::AttributeContainer) |
| auth | method | From (CompUnit, Metamodel::Versioning, Systemic) |
| await | sub | From (Promise, Channel) |
| backend | method | From (Compiler) |
| backtrace | method | From (Exception) |
| bag | sub | From (Bag) |
| bail-out | sub | From (Test) |
| base | method | From (Real) |
| base-repeating | method | From (Rational) |
| base_type | method | From (Metamodel::DefiniteHOW) |
| basename | method | From (IO::Path, IO::Spec::Unix, IO::Spec::Win32) |
| batch | method | From (Any, Supply, List) |
| before | infix, method | From (Operators, StrDistance) |
| bind-stderr | method | From (Proc::Async) |
| bind-stdin | method | From (Proc::Async) |
| bind-stdout | method | From (Proc::Async) |
| bind-udp | method | From (IO::Socket::Async) |
| bits | method | From (Kernel) |
| bless | method | From (Mu) |
| block | method | From (X::Phaser::Multiple) |
| bool-only | method | From (PredictiveIterator) |
| bounds | method | From (Range) |
| break | method | From (Promise) |
| broken | method | From (Promise) |
| build-date | method | From (Compiler) |
| but | infix | From (Operators) |
| bytes | method | From (Blob) |
| cache | method | From (Any, PositionalBindFailover) |
| callframe | sub | From (CallFrame) |
| calling-package | method | From (X::Method::Private::Permission) |
| can | method | From (Metamodel::ClassHOW, Metamodel::MROBasedMethodDispatch) |
| can-ok | sub | From (Test) |
| cancel | method | From (Cancellation) |
| candidates | method | From (CompUnit::Repository::FileSystem, CompUnit::Repository::Installation, Routine) |
| cando | method | From (Code, Routine) |
| canonpath | method | From (IO::Spec::Cygwin, IO::Spec::QNX, IO::Spec::Unix, IO::Spec::Win32) |
| caps | method | From (Match) |
| caption | method | From (Pod::Block::Table) |
| capture | method | From (Parameter) |
| cas | sub | From (Scalar, atomicint) |
| catdir | method | From (IO::Spec::Cygwin, IO::Spec::Unix, IO::Spec::Win32) |
| categorize | routine | From (Any, List) |
| categorize-list | method | From (Baggy, Hash) |
| catfile | method | From (IO::Spec::Unix, IO::Spec::Win32) |
| catpath | method | From (IO::Spec::Cygwin, IO::Spec::Unix, IO::Spec::Win32) |
| cause | method | From (Promise) |
| ceiling | method, routine | From (Complex, Rational, Real, Cool) |
| cglobal | sub | From (Native calling interface) |
| changed | method | From (IO::Path, IO::Special) |
| channel | method | From (X::Channel::ReceiveOnClosed, X::Channel::SendOnClosed) |
| chars | method, routine | From (Blob, Str, Cool, Match) |
| chdir | method, sub | From (IO::Path, Independent routines) |
| child | method | From (IO::Path) |
| child-name | method | From (X::Inheritance::NotComposed) |
| child-typename | method | From (X::Inheritance::Unsupported) |
| chmod | method, sub | From (IO::Path, Independent routines) |
| chomp | method, routine | From (Allomorph, IO::CatHandle, IO::Handle, Str, Cool) |
| chop | method, routine | From (Allomorph, Str, Cool) |
| chr | routine | From (Int, Cool) |
| chrs | method, routine | From (Nil, Cool) |
| chunks | method | From (Match) |
| cis | routine | From (Cool) |
| classify | routine | From (Any, List) |
| classify-list | method | From (Baggy, Hash) |
| cleanup | method | From (IO::Path) |
| clone | method | From (Date, Mu, DateTime, Array, Match) |
| close | method, routine | From (Tap, IO::CatHandle, IO::Handle, IO::Pipe, IO::Socket, IO::Socket::Async, Channel) |
| close-stdin | method | From (Proc::Async) |
| closed | method | From (Channel) |
| cmp | infix | From (Operators, List, Pair, Allomorph, Order) |
| cmp-ok | sub | From (Test) |
| code | method | From (CallFrame, Backtrace::Frame) |
| codename | method | From (Compiler) |
| codes | method, routine | From (Uni, Cool) |
| coerce_type | method | From (Parameter) |
| coll | infix | From (Operators) |
| collate | method | From (Any, Supply) |
| column | method | From (X::Comp) |
| comb | method, routine | From (Allomorph, IO::CatHandle, IO::Handle, IO::Path, Str, Cool) |
| combinations | method, routine | From (Any, List) |
| command | method | From (Proc, Proc::Async) |
| comment | method | From (X::OutOfRange) |
| compiler | method | From (Raku) |
| composalizer | method | From (Metamodel::EnumHOW) |
| compose | method | From (Metamodel::ClassHOW, Metamodel::EnumHOW) |
| compose_type | method | From (Metamodel::Primitives) |
| compose_values | method | From (Metamodel::EnumHOW) |
| composer | method | From (X::Composition::NotComposable) |
| compute_mro | method | From (Metamodel::C3MRO) |
| concise | method | From (Backtrace) |
| condition | method | From (X::Phaser::PrePost, Lock) |
| config | method | From (Pod::Block, Systemic) |
| configure_destroy | method | From (Metamodel::Primitives) |
| configure_type_checking | method | From (Metamodel::Primitives) |
| conj | method | From (Numeric, Complex, Cool) |
| connect | method | From (IO::Socket::Async) |
| constant | prefix | From (Variables) |
| constraints | method | From (Parameter) |
| construct | method | From (X::Syntax::Regex::Adverb) |
| contains | method | From (Str, Cool) |
| content | method | From (Distribution::Hash, Distribution::Locally, Distribution::Path, Distribution) |
| contents | method | From (Pod::Block) |
| copy | routine, method | From (IO::Path, Parameter) |
| cos | routine | From (Cool) |
| cosec | routine | From (Cool) |
| cosech | routine | From (Cool) |
| cosh | routine | From (Cool) |
| cotan | routine | From (Cool) |
| cotanh | routine | From (Cool) |
| count | method | From (Signature, ForeignCode, Code) |
| count-only | method | From (PredictiveIterator) |
| cpu-cores | method | From (Kernel) |
| cpu-usage | method | From (Kernel) |
| create_type | method | From (Metamodel::Primitives) |
| cross | routine | From (List) |
| cue | method | From (Scheduler) |
| curdir | method | From (IO::Spec::Unix) |
| curupdir | method | From (IO::Spec::Unix) |
| d | method | From (IO::Path, IO::Special) |
| day | method | From (Dateish) |
| day-fraction | method | From (DateTime) |
| day-of-month | method | From (Dateish) |
| day-of-week | method | From (Dateish) |
| day-of-year | method | From (Dateish) |
| daycount | method | From (Dateish) |
| days-in-month | method | From (Dateish) |
| dd-mm-yyyy | method | From (Dateish) |
| declaration | method | From (X::Declaration::Scope) |
| decode | method | From (Blob) |
| decoder | method | From (Encoding) |
| deepmap | method | From (Any) |
| default | method | From (Baggy, Setty, Hash, Scalar, Parameter, Array) |
| defined | method, routine | From (Mu, Mu, Failure, Junction) |
| definite | method | From (Metamodel::DefiniteHOW) |
| delayed | method | From (Supply) |
| delete | method | From (CompUnit::PrecompilationRepository) |
| delete-by-compiler | method | From (CompUnit::PrecompilationRepository) |
| denominator | method | From (Rational) |
| desc | method | From (Systemic) |
| destroyers | method | From (Metamodel::Finalization) |
| devnull | method | From (IO::Spec::Unix, IO::Spec::Win32) |
| diag | sub | From (Test) |
| did-you-mean | method | From (X::NYI) |
| die | routine | From (Exception) |
| dies-ok | sub | From (Test) |
| dir | routine | From (IO::Path) |
| dir-sep | method | From (IO::Spec::Unix, IO::Spec::Win32) |
| dirname | method | From (IO::Path) |
| distribution | method | From (CompUnit) |
| div | infix | From (Operators, Int) |
| do | method | From (Supply) |
| does | trait, infix, routine | From (Type system, Operators, Mu) |
| does-ok | sub | From (Test) |
| done | method, sub | From (Supplier, Independent routines) |
| done-testing | sub | From (Test) |
| duckmap | method | From (Any) |
| dynamic | routine, method | From (Hash, Scalar, Array) |
| e | term, method | From (Terms, IO::Path, IO::Special) |
| eager | method, routine | From (Any, Sequence, List) |
| earlier | method | From (Dateish) |
| elems | method, routine | From (Subscripts, Baggy, Any, Blob, Positional, Supply, List, Map, Uni, Setty, Seq, Metamodel::EnumHOW, Capture, Range, Array) |
| emit | method, sub | From (Supplier, Mu, Independent routines) |
| enclosing | method | From (X::ControlFlow) |
| encode | method | From (Str) |
| encoder | method | From (Encoding) |
| encoding | method | From (IO::CatHandle, IO::Handle) |
| end | method, routine | From (Any, List) |
| endian | method | From (Kernel) |
| ends-with | method | From (Str) |
| enum_from_value | method | From (Metamodel::EnumHOW) |
| enum_value_list | method | From (Metamodel::EnumHOW) |
| enum_values | method | From (Metamodel::EnumHOW) |
| enums | routine, method | From (Bool, Enumeration) |
| eof | method | From (IO::CatHandle, IO::Handle) |
| eq | infix | From (Operators) |
| eqv | infix | From (Operators, ObjAt, Allomorph, Match) |
| eval-dies-ok | sub | From (Test) |
| eval-lives-ok | sub | From (Test) |
| event | method | From (IO::Notification::Change) |
| exception | method | From (Failure) |
| excludes-max | method | From (Range) |
| excludes-min | method | From (Range) |
| exit | sub | From (Independent routines) |
| exitcode | method | From (Proc) |
| exp | routine | From (Numeric, Cool) |
| expected | method | From (X::TypeCheck) |
| explicitly-manage | sub | From (Native calling interface) |
| expmod | routine | From (Int) |
| export_callback | method | From (Metamodel::EnumHOW) |
| extension | method | From (IO::Path, IO::Spec::Unix) |
| f | method | From (IO::Path, IO::Special) |
| fail | routine, sub, method | From (Exception, Failure, Channel) |
| fails-like | sub | From (Test) |
| fc | method, routine | From (Allomorph, Str, Cool) |
| feature | method | From (X::NYI) |
| ff | infix | From (Operators) |
| ff^ | infix | From (Operators) |
| fff | infix | From (Operators) |
| fff^ | infix | From (Operators) |
| file | method | From (CallFrame, Backtrace::Frame, Code, Label) |
| filename | method | From (X::Comp) |
| files | method | From (CompUnit::Repository::FileSystem, CompUnit::Repository::Installation) |
| find | method | From (Encoding::Registry) |
| find_method | method | From (Metamodel::DefiniteHOW, Metamodel::MROBasedMethodDispatch) |
| find_method_qualified | method | From (Metamodel::MROBasedMethodDispatch) |
| find_private_method | method | From (Metamodel::PrivateMethodContainer) |
| finish | method | From (Thread) |
| first | routine, method | From (Any, Supply, List) |
| first-date-in-month | method | From (Date) |
| flat | method, sub | From (Any, Supply, Iterable, Backtrace, Independent routines, Range, Array) |
| flatmap | method | From (Any, List) |
| flip | method, routine | From (Allomorph, Str, Cool) |
| floor | method, routine | From (Complex, Rational, Real, Cool) |
| flunk | sub | From (Test) |
| flush | method | From (IO::CatHandle, IO::Handle) |
| flush_cache | method | From (Metamodel::Mixins) |
| fmt | method | From (Sequence, List, Pair, Cool, Range) |
| format | method | From (X::Temporal::InvalidFormat) |
| formatter | method | From (Dateish) |
| free-memory | method | From (Kernel) |
| freeze | method | From (Pair) |
| from | method | From (X::IO::Copy, X::IO::Move, X::IO::Rename, CompUnit, List, Match) |
| from-list | method | From (Supply) |
| from-loop | method | From (Seq) |
| from-posix | method | From (Instant) |
| from-slurpy | method | From (X::AdHoc) |
| full | method | From (Backtrace) |
| full-barrier | sub | From (Thread) |
| gcd | infix | From (Operators) |
| ge | infix | From (Operators) |
| generate_mixin | method | From (Metamodel::Mixins) |
| get | method, routine | From (IO::CatHandle, IO::Handle, IO::Socket, IO::Socket::INET) |
| get_value | method | From (Attribute) |
| getc | method, routine | From (IO::CatHandle, IO::Handle) |
| gist | method, routine | From (Date, Blob, Exception, Sequence, List, Nil, Mu, Backtrace, Map, Submethod, Attribute, Complex, IO::Handle, IO::Notification::Change, IO::Path, ForeignCode, Junction, Systemic, Version, Array) |
| got | method | From (X::OutOfRange, X::TypeCheck) |
| grab | method | From (Baggy, Supply, Setty) |
| grabpairs | method | From (Baggy, Setty) |
| grep | method, routine | From (Any, Supply, List, HyperSeq, RaceSeq) |
| gt | infix | From (Operators) |
| handle | method | From (X::Proc::Async::CharsOrBytes, X::Proc::Async::TapBeforeSpawn) |
| handled | method | From (Failure) |
| handles | trait, method | From (Type system, IO::CatHandle) |
| hardware | method | From (Kernel) |
| has_accessor | method | From (Attribute) |
| hash | method | From (Baggy, Any, QuantHash, Capture, Match) |
| head | method | From (Any, Supply, List) |
| headers | method | From (Pod::Block::Table) |
| hh-mm-ss | method | From (DateTime) |
| hidden | method | From (Metamodel::MultipleInheritance) |
| hides | trait, method | From (Type system, Metamodel::MultipleInheritance) |
| hostname | method | From (Kernel) |
| hour | method | From (DateTime) |
| how | method | From (X::Parameter::Default) |
| hyper | method | From (Iterable, HyperSeq, RaceSeq) |
| i | term, postfix | From (Terms, Complex) |
| id | method | From (Thread, Compiler) |
| illegal | method | From (X::ControlFlow) |
| im | method | From (Complex) |
| in | method | From (Promise) |
| in-timezone | method | From (DateTime) |
| indent | method | From (Str) |
| index | method, routine | From (Str, Cool) |
| indices | method | From (Str) |
| indir | sub | From (Independent routines) |
| infinite | method | From (Range) |
| infix | method | From (X::Syntax::InfixInTermPosition) |
| infix:<**> | sub | From (Complex) |
| infix:<*> | sub | From (Range) |
| infix:<+> | sub | From (Date, DateTime, Range) |
| infix: | sub | From (Range) |
| infix:<-> | sub | From (Date, DateTime, Range) |
| infix: | sub | From (DateTime, Range) |
| infix:«!=» | sub | From (DateTime) |
| infix:«<=>» | sub | From (DateTime) |
| infix:«<=» | sub | From (DateTime) |
| infix:«<» | sub | From (DateTime) |
| infix:«==» | sub | From (DateTime) |
| infix:«>=» | sub | From (DateTime) |
| infix:«>» | sub | From (DateTime) |
| install | method | From (CompUnit::Repository::Installation) |
| install_method_cache | method | From (Metamodel::Primitives) |
| instead | method | From (X::Syntax::Reserved) |
| int-bounds | method | From (Range) |
| interval | method | From (Supply) |
| invalid-str | method | From (X::Temporal::InvalidFormat) |
| invert | method, routine | From (Baggy, Any, List, Map, Pair, HyperSeq, RaceSeq) |
| invocant | method | From (X::Method::InvalidQualifier, Parameter) |
| is | trait, sub | From (Traits, Test) |
| is DEPRECATED | trait | From (Routine) |
| is cached | trait | From (Routine) |
| is default | trait | From (Routine) |
| is dynamic | trait | From (Variable) |
| is export | trait | From (Mu, Routine) |
| is hidden-from-backtrace | trait | From (Routine) |
| is nodal | trait | From (Type system) |
| is pure | trait | From (Routine) |
| is raw | trait | From (Routine) |
| is required | trait | From (Type system) |
| is rw | trait | From (Type system, Routine) |
| is-absolute | method | From (IO::Path, IO::Spec::Cygwin, IO::Spec::Unix, IO::Spec::Win32) |
| is-approx | sub | From (Test) |
| is-approx-calculate | sub | From (Test) |
| is-deeply | sub | From (Test) |
| is-hidden | method | From (Backtrace::Frame) |
| is-implementation-detail | method | From (Traits, Code) |
| is-initial-thread | method | From (Thread) |
| is-int | method | From (Range) |
| is-lazy | method | From (Seq, HyperSeq, RaceSeq, Iterator) |
| is-leap-year | method | From (Dateish) |
| is-prime | routine | From (Int) |
| is-relative | method | From (IO::Path) |
| is-routine | method | From (Backtrace::Frame) |
| is-setting | method | From (Backtrace::Frame) |
| is-win | method | From (Distro) |
| is-wrapped | method | From (Routine) |
| isNaN | method | From (Complex, Rational) |
| is_approx | sub | From (Test) |
| is_composed | method | From (Metamodel::EnumHOW) |
| is_mixin | method | From (Metamodel::Mixins) |
| is_trusted | method | From (Metamodel::Trusting) |
| is_type | method | From (Metamodel::Primitives) |
| isa | routine | From (Mu) |
| isa-ok | sub | From (Test) |
| isnt | sub | From (Test) |
| item | sub, method | From (Any, Mu) |
| iterator | method | From (Any, Iterable, Mu, Seq, PositionalBindFailover, Junction, HyperSeq, RaceSeq) |
| join | method, routine | From (Any, Thread, List, IO::Spec::Cygwin, IO::Spec::Unix, IO::Spec::Win32) |
| julian-date | method | From (DateTime) |
| keep | method | From (Promise) |
| kept | method | From (Promise) |
| key | method | From (X::Syntax::NegatedPair, Pair, Enumeration) |
| keyof | method | From (QuantHash, Associative, Hash) |
| keys | method, routine | From (Baggy, Any, List, Map, Setty, Pair, Capture) |
| kill | method | From (Proc::Async) |
| kv | method, routine | From (Baggy, Any, List, Map, Setty, Pair, Capture, Enumeration) |
| kxxv | method | From (Baggy) |
| l | method | From (IO::Path, IO::Special) |
| lang | method | From (X::Eval::NoSuchLang) |
| last | method | From (Label) |
| last-date-in-month | method | From (Date) |
| lastcall | sub | From (Independent routines) |
| later | method | From (Dateish) |
| lazy | method | From (Iterable) |
| lc | method, routine | From (Allomorph, Str, Cool) |
| lcm | infix | From (Operators) |
| le | infix | From (Operators) |
| leading | method | From (Pod::Block::Declarator) |
| leg | infix | From (Operators) |
| let | prefix | From (Operators, Variables) |
| level | method | From (Pod::Heading, Pod::Item) |
| like | sub | From (Test) |
| line | method | From (CallFrame, X::Comp, Backtrace::Frame, Code, Label) |
| lines | method, routine | From (Supply, IO::CatHandle, IO::Handle, IO::Path, IO::Socket::INET, Str, Cool) |
| link | routine | From (IO::Path) |
| list | method, routine | From (Any, Blob, Supply, List, Failure, Backtrace, QuantHash, Buf, Map, Uni, PositionalBindFailover, Capture, Range, Channel, Match) |
| listen | method | From (IO::Socket::Async) |
| live | method | From (Supply) |
| lives-ok | sub | From (Test) |
| load | method | From (CompUnit::Repository, CompUnit::Repository::FileSystem, CompUnit::Repository::Installation) |
| load-repo-id | method | From (CompUnit::PrecompilationRepository) |
| load-unit | method | From (CompUnit::PrecompilationRepository) |
| loaded | method | From (CompUnit::Repository, CompUnit::Repository::FileSystem, CompUnit::Repository::Installation) |
| loads | method | From (Scheduler) |
| local | method | From (DateTime) |
| lock | method | From (Lock::Async, IO::CatHandle, IO::Handle, Lock) |
| log | routine | From (Numeric, Cool) |
| log10 | routine | From (Numeric, Cool) |
| log2 | routine | From (Numeric, Cool) |
| lookup | method | From (Metamodel::ClassHOW, Metamodel::MethodContainer) |
| lsb | routine | From (Int) |
| lt | infix | From (Operators) |
| made | method | From (Match) |
| make | routine | From (Match) |
| map | routine, method | From (Any, Supply, List, Backtrace, HyperSeq, RaceSeq) |
| match | method | From (Str, Cool) |
| max | infix, routine, method | From (Operators, Any, Supply, Range) |
| maxpairs | method | From (Any, Setty) |
| merge | method | From (Supply) |
| message | method | From (Exception, X::NYI, X::StubCode, CX::Done, CX::Emit, CX::Last, CX::Next, CX::Proceed, CX::Redo, CX::Return, CX::Succeed, CX::Take) |
| message Defined as: | sub | From (X::DateTime::TimezoneClash) |
| meta | method | From (Distribution::Hash, Distribution::Path, Distribution, Pod::FormattingCode) |
| method | method | From (X::Method::InvalidQualifier, X::Method::NotFound, X::Method::Private::Permission, X::Method::Private::Unqualified, X::Proc::Async::MustBeStarted, X::Proc::Async::OpenForWriting) |
| method_table | method | From (Metamodel::MethodContainer) |
| methods | method | From (Metamodel::MethodContainer) |
| migrate | method | From (Supply) |
| min | infix, routine, method | From (Operators, Any, Supply, Range) |
| minmax | infix, routine, method | From (Operators, Any, Supply, Range) |
| minpairs | method | From (Any, Setty) |
| minute | method | From (DateTime) |
| misplaced | method | From (X::Parameter::WrongOrder) |
| mix | sub | From (Mix) |
| mixin | method | From (Metamodel::Mixins) |
| mixin_attribute | method | From (Metamodel::Mixins) |
| mkdir | method, sub | From (IO::Path, Independent routines) |
| mm-dd-yyyy | method | From (Dateish) |
| mod | infix | From (Operators) |
| mode | method | From (X::IO::Mkdir, IO::Path, IO::Special) |
| modified | method | From (IO::Path, IO::Special) |
| modified-julian-date | method | From (DateTime) |
| month | method | From (Dateish) |
| move | routine | From (IO::Path) |
| mro | method | From (Metamodel::C3MRO) |
| mro_unhidden | method | From (Metamodel::C3MRO) |
| msb | routine | From (Int) |
| multi | method | From (Routine) |
| multiness | method | From (X::Anon::Multi) |
| my | method | From (CallFrame) |
| name | method | From (Encoding, Thread, X::Attribute::NoPackage, X::Attribute::Package, X::Attribute::Required, X::Bind::NativeType, X::Dynamic::NotFound, X::IO::Link, X::IO::Symlink, X::Signature::NameClash, Encoding::Registry, Metamodel::DefiniteHOW, Metamodel::Naming, Attribute, Pod::Block::Named, Scalar, ForeignCode, Parameter, Systemic, Routine, Label, Variable) |
| named | method | From (Parameter) |
| named_names | method | From (Parameter) |
| narrow | method | From (Numeric) |
| native-descriptor | method | From (IO::CatHandle, IO::Handle, IO::Socket, IO::Socket::Async, IO::Socket::Async::ListenSocket) |
| nativecast | sub | From (Native calling interface) |
| nativesizeof | sub | From (Native calling interface) |
| ne | infix | From (Operators) |
| need | method | From (CompUnit::Repository, CompUnit::Repository::FileSystem, CompUnit::Repository::Installation) |
| new | method, routine | From (Distribution::Hash, Distribution::Path, Date, IntStr, Supplier, Blob, Thread, RatStr, X::NYI, Nil, Mu, Failure, NumStr, Backtrace, Map, Uni, Seq, Metamodel::PackageHOW, ComplexStr, Int, DateTime, Proxy, Pair, Complex, Rational, IO::CatHandle, IO::Path, IO::Path::Cygwin, IO::Path::Parts, IO::Path::QNX, IO::Path::Unix, IO::Path::Win32, IO::Socket::INET, IO::Special, Num, Telemetry::Sampler, Junction, Semaphore, Supplier::Preserving, Version, CX::Warn, Proc, Proc::Async) |
| new-from-daycount | method | From (Date) |
| new-from-pairs | method | From (Baggy, Setty) |
| new-unit | method | From (CompUnit::PrecompilationRepository) |
| new_type | method | From (Metamodel::ClassHOW, Metamodel::DefiniteHOW, Metamodel::EnumHOW, Metamodel::PackageHOW) |
| next | method | From (Label) |
| next-handle | method | From (IO::CatHandle) |
| next-interesting-index | method | From (Backtrace) |
| nice | method | From (Backtrace) |
| nl-in | method | From (IO::CatHandle, IO::Handle) |
| nl-out | method | From (Any, IO::CatHandle, IO::Handle) |
| nodemap | method | From (Any) |
| nok | sub | From (Test) |
| nominalize | method | From (Metamodel::DefiniteHOW) |
| none | method | From (Any) |
| norm | method | From (Rational) |
| not | prefix, method | From (Operators, Mu) |
| notandthen | infix | From (Operators) |
| note | routine | From (Independent routines) |
| now | term, method | From (Terms, DateTime) |
| nude | method | From (Rational) |
| numerator | method | From (Rational) |
| o, infix ∘ | infix | From (Operators) |
| of | method, trait | From (Positional, QuantHash, Associative, Hash, Scalar, Code, Variable, Array) |
| offset | method | From (DateTime) |
| offset-in-hours | method | From (DateTime) |
| offset-in-minutes | method | From (DateTime) |
| ok | sub | From (Test) |
| old | method | From (X::Obsolete) |
| on-close | method | From (Supply) |
| on-switch | method | From (IO::CatHandle) |
| one | method | From (Any) |
| open | method, sub | From (IO::CatHandle, IO::Handle, IO::Path, Independent routines) |
| opened | method | From (IO::CatHandle, IO::Handle) |
| operation | method | From (X::TypeCheck) |
| optional | method | From (Parameter) |
| or | infix | From (Operators) |
| ord | routine | From (Str, Cool) |
| ords | method, routine | From (Nil, Str, Cool) |
| orelse | infix | From (Operators) |
| orig | method | From (Match) |
| os-error | method | From (X::OS) |
| osname | method | From (VM) |
| out-buffer | method | From (IO::CatHandle, IO::Handle) |
| outer-caller-idx | method | From (Backtrace) |
| pack | sub | From (Blob) |
| package | method | From (X::Augment::NoSuchType, Attribute, Routine) |
| package-kind | method | From (X::Anon::Augment, X::Attribute::Package, X::Attribute::Undeclared, X::Augment::NoSuchType) |
| package-name | method | From (X::Attribute::Undeclared) |
| packages | method | From (X::Package::Stubbed) |
| pair | method | From (Enumeration) |
| pairs | method, routine | From (Baggy, Any, List, Map, Pair, Capture) |
| pairup | method | From (Any) |
| parameter | method | From (X::Parameter::Default, X::Parameter::MultipleTypeConstraints, X::Parameter::Placeholder, X::Parameter::Twigil, X::Parameter::WrongOrder) |
| params | method | From (Signature) |
| parent | method | From (X::Inheritance::Unsupported, IO::Path) |
| parent-name | method | From (X::Inheritance::NotComposed) |
| parents | method | From (Metamodel::MultipleInheritance) |
| parse | method | From (Grammar) |
| parse-base | routine | From (Str) |
| parse-names | routine | From (Str) |
| parsefile | method | From (Grammar) |
| parts | method | From (IO::Path, Version) |
| pass | sub | From (Test) |
| path | method | From (X::IO::Chdir, X::IO::Dir, X::IO::DoesNotExist, X::IO::Mkdir, X::IO::Rmdir, X::IO::Unlink, IO::CatHandle, IO::Handle, IO::Notification::Change, IO::Pipe, IO::Spec::Unix, IO::Spec::Win32, Cool, Proc::Async) |
| path-sep | method | From (Distro) |
| payload | method | From (X::AdHoc) |
| peer-host | method | From (IO::Socket::Async) |
| peer-port | method | From (IO::Socket::Async) |
| periods | routine | From (Telemetry) |
| perl | method | From (Mu) |
| permutations | method, routine | From (Any, List) |
| phaser | method | From (X::Phaser::PrePost) |
| pi | term | From (Terms) |
| pick | method, routine | From (Baggy, Any, List, Setty, Bool, Enumeration, Range) |
| pickpairs | method | From (Baggy, Setty) |
| pid | method | From (Proc, Proc::Async) |
| placeholder | method | From (X::Placeholder::Block, X::Signature::Placeholder) |
| plan | sub | From (Test) |
| plus | method | From (Version) |
| polar | method | From (Complex) |
| poll | method | From (Channel) |
| polymod | method | From (Int, Real) |
| pop | method, sub | From (Buf, Independent routines, Array) |
| pos | method | From (X::Str::Numeric, Match) |
| positional | method | From (Parameter) |
| posix | method | From (DateTime) |
| postfix | method | From (X::Redeclaration) |
| postmatch | method | From (Match) |
| precomp-ext | method | From (VM) |
| precomp-target | method | From (VM) |
| precompiled | method | From (CompUnit) |
| pred | method, routine | From (Date, Numeric, Bool, Allomorph, IO::Path, Str, Enumeration) |
| prefix | method | From (Distribution::Locally, VM, Parameter) |
| prematch | method | From (Match) |
| prepend | method, routine | From (Any, Nil, Buf, Array) |
| primary | method | From (Collation) |
| print | method, sub | From (Mu, IO::CatHandle, IO::Handle, IO::Socket, IO::Socket::Async, Independent routines, Proc::Async) |
| print-nl | method | From (IO::CatHandle, IO::Handle) |
| print-to | method | From (IO::Socket::Async) |
| printf | method, routine | From (IO::CatHandle, IO::Handle, Independent routines, Cool) |
| private | method | From (X::Method::NotFound) |
| private_method_names | method | From (Metamodel::PrivateMethodContainer) |
| private_method_table | method | From (Metamodel::PrivateMethodContainer) |
| private_methods | method | From (Metamodel::PrivateMethodContainer) |
| proc | method | From (X::Proc::Async, X::Proc::Unsuccessful, IO::Pipe) |
| produce | routine, method | From (Any, Supply, List) |
| promise | method | From (X::Promise::CauseOnlyValidOnBroken, X::Promise::Vowed) |
| prompt | sub | From (Independent routines) |
| protect | method | From (Lock::Async, Lock) |
| protect-or-queue-on-recursion | method | From (Lock::Async) |
| publish_method_cache | method | From (Metamodel::MROBasedMethodDispatch) |
| pull-one | method | From (Iterator) |
| push | method, sub | From (Any, Nil, Buf, Hash, Independent routines, Array) |
| push-all | method | From (Iterator) |
| push-at-least | method | From (Iterator) |
| push-exactly | method | From (Iterator) |
| push-until-lazy | method | From (Iterator) |
| put | method, sub | From (Mu, IO::CatHandle, IO::Handle, IO::Socket, Independent routines, Proc::Async) |
| qualifier-type | method | From (X::Method::InvalidQualifier) |
| quaternary | method | From (Collation) |
| quit | method | From (Supplier) |
| r | method | From (IO::Path, IO::Special) |
| race | method | From (Iterable, HyperSeq, RaceSeq) |
| radix | method | From (X::Syntax::Number::RadixOutOfRange) |
| raku | method | From (Mu, Complex, Allomorph, IO::Path, IO::Path::Cygwin, IO::Path::QNX, IO::Path::Unix, IO::Path::Win32, FatRat, Junction, Rat, Range) |
| rand | term, method, routine | From (Terms, Num, Real, Cool, Range) |
| range | method | From (X::OutOfRange) |
| raw | method | From (Parameter) |
| re | method | From (Complex) |
| read | method | From (IO::CatHandle, IO::Handle, IO::Socket) |
| read-bits | method | From (Blob) |
| read-int128 | method | From (Blob) |
| read-int16 | method | From (Blob) |
| read-int32 | method | From (Blob) |
| read-int64 | method | From (Blob) |
| read-int8 | method | From (Blob) |
| read-num32 | method | From (Blob) |
| read-num64 | method | From (Blob) |
| read-ubits | method | From (Blob) |
| read-uint128 | method | From (Blob) |
| read-uint16 | method | From (Blob) |
| read-uint32 | method | From (Blob) |
| read-uint64 | method | From (Blob) |
| read-uint8 | method | From (Blob) |
| readchars | method | From (IO::CatHandle, IO::Handle) |
| readonly | method | From (Attribute, Parameter) |
| ready | method | From (Proc::Async) |
| reallocate | method | From (Buf) |
| reals | method | From (Complex) |
| reason | method | From (X::Numeric::Real, X::Str::Numeric) |
| rebless | method | From (Metamodel::Primitives) |
| receive | method | From (Channel) |
| recv | method | From (IO::Socket) |
| redispatcher | method | From (X::NoDispatcher) |
| redo | method | From (Label) |
| reduce | routine, method | From (Any, Supply, List) |
| rel2abs | method | From (IO::Spec::Cygwin, IO::Spec::Unix, IO::Spec::Win32) |
| relative | method | From (IO::Path) |
| release | method | From (Distro, Kernel, Compiler, Semaphore) |
| remove | method | From (BagHash) |
| rename | routine | From (IO::Path) |
| repeated | method, routine | From (Any, Supply, Independent routines) |
| repl Note: repl was introduced in release 2021.06 of the Rakudo compiler. | sub | From (Independent routines) |
| replace-with | method | From (Match) |
| replacement | method | From (X::Obsolete) |
| repo | method | From (CompUnit) |
| repo-id | method | From (CompUnit) |
| report | routine | From (Telemetry) |
| required | method | From (Attribute) |
| reserved | method | From (X::Syntax::Reserved) |
| resolve | method | From (CompUnit::Repository, CompUnit::Repository::FileSystem, CompUnit::Repository::Installation, IO::Path) |
| restore | method | From (Routine::WrapHandle) |
| result | method | From (Promise) |
| resume | method | From (Exception) |
| rethrow | method | From (Exception) |
| return | method | From (Mu) |
| return-rw | method | From (Mu) |
| returns | method | From (Signature) |
| reverse | routine, method | From (Any, Blob, Supply, List, Mix, Range) |
| right | method | From (X::Parameter::Placeholder) |
| rindex | routine | From (Str, Cool) |
| rmdir | routine | From (IO::Path) |
| role | method | From (X::Role::Initialization) |
| roles_to_compose | method | From (Metamodel::RoleContainer) |
| rolish | method | From (X::Mixin::NotComposable) |
| roll | method, routine | From (Baggy, Any, List, Setty, Bool, Mixy, Enumeration, Range) |
| rootdir | method | From (IO::Spec::Unix, IO::Spec::Win32) |
| roots | method, routine | From (Numeric, Cool) |
| rotate | method, routine | From (Supply, List) |
| rotor | method | From (Any, Supply, List) |
| round | method, routine | From (Complex, Real, Cool) |
| roundrobin | routine | From (List) |
| routine-type | method | From (X::Anon::Multi) |
| run | method, sub | From (Thread, Independent routines) |
| rw | method | From (Metamodel::AttributeContainer, Attribute, IO::Path, Parameter) |
| rwx | method | From (IO::Path) |
| s | method | From (IO::Path, IO::Special) |
| samecase | method, routine | From (Allomorph, Str, Cool) |
| samemark | method, routine | From (Allomorph, Str) |
| say | method, sub | From (Mu, IO::CatHandle, IO::Handle, Independent routines, Proc::Async) |
| schedule-on | method | From (Supply) |
| scheduler | method | From (Promise) |
| scope | method | From (X::Declaration::Scope, X::Syntax::Variable::Twigil) |
| sec | routine | From (Cool) |
| sech | routine | From (Cool) |
| second | method | From (DateTime) |
| secondary | method | From (Collation) |
| seek | method | From (IO::CatHandle, IO::Handle) |
| self | term, method | From (Terms, Mu, Failure) |
| send | method | From (Channel) |
| serial | method | From (Any, HyperSeq, RaceSeq) |
| set | method, sub | From (SetHash, Collation, Set) |
| set-instruments | method | From (Telemetry::Sampler) |
| set_api | method | From (Metamodel::Versioning) |
| set_auth | method | From (Metamodel::Versioning) |
| set_composalizer | method | From (Metamodel::EnumHOW) |
| set_export_callback | method | From (Metamodel::EnumHOW) |
| set_hidden | method | From (Metamodel::MultipleInheritance) |
| set_is_mixin | method | From (Metamodel::Mixins) |
| set_mixin_attribute | method | From (Metamodel::Mixins) |
| set_name | method | From (Metamodel::Naming) |
| set_package | method | From (Metamodel::Primitives) |
| set_rw | method | From (Metamodel::AttributeContainer) |
| set_value | method | From (Attribute) |
| set_ver | method | From (Metamodel::Versioning) |
| set_why | method | From (Metamodel::Documenting) |
| setup_finalization | method | From (Metamodel::Finalization) |
| setup_mixin_cache | method | From (Metamodel::Mixins) |
| shape | method | From (Array) |
| share | method | From (Supply) |
| shell | sub, method | From (Independent routines, Proc) |
| shift | method, sub | From (Buf, Independent routines, Array) |
| short-id | method | From (CompUnit::Repository::FileSystem, CompUnit::Repository::Installation) |
| short-name | method | From (CompUnit) |
| shortname | method | From (Metamodel::DefiniteHOW) |
| sibling | method | From (IO::Path) |
| sigil | method | From (Parameter) |
| sign | method | From (Real, Cool) |
| signal | method, sub | From (Lock::ConditionVariable, Supply, Kernel, Proc) |
| signals | method | From (Kernel) |
| signature | method | From (ForeignCode, Code, Systemic) |
| sin | routine | From (Cool) |
| sinh | routine | From (Cool) |
| sink | method | From (List, Seq, HyperSeq, Proc, RaceSeq) |
| sink-all | method | From (Iterator) |
| skip | method, sub | From (Any, Supply, Test, Seq) |
| skip-at-least | method | From (Iterator) |
| skip-at-least-pull-one | method | From (Iterator) |
| skip-one | method | From (Iterator) |
| skip-rest | sub | From (Test) |
| sleep | sub | From (Date) |
| sleep-timer | sub | From (Date) |
| sleep-until | sub | From (Date) |
| slip | sub | From (Slip) |
| slurp | method, routine, sub | From (IO::CatHandle, IO::Handle, IO::Path, Independent routines) |
| slurp-rest | method | From (IO::Handle) |
| slurpy | method | From (Parameter) |
| snap | routine | From (Telemetry) |
| snapper | routine | From (Telemetry) |
| so | prefix, method | From (Operators, Mu, Bool) |
| socket-host | method | From (IO::Socket::Async, IO::Socket::Async::ListenSocket) |
| socket-port | method | From (IO::Socket::Async, IO::Socket::Async::ListenSocket) |
| sort | method, routine | From (Any, Supply, List, Map) |
| source | method | From (X::Numeric::Real, X::Str::Numeric) |
| source-package | method | From (X::Method::Private::Permission) |
| spawn | method | From (Proc) |
| splice | method, routine | From (Buf, Array) |
| split | method, routine | From (Supply, Allomorph, IO::CatHandle, IO::Handle, IO::Path, IO::Spec::Cygwin, IO::Spec::Unix, IO::Spec::Win32, Str, Cool) |
| splitdir | method | From (IO::Spec::Unix, IO::Spec::Win32) |
| splitpath | method | From (IO::Spec::Cygwin, IO::Spec::Unix, IO::Spec::Win32) |
| sprintf | routine, method | From (Independent routines, Cool) |
| spurt | method, sub | From (IO::Handle, IO::Path, Independent routines) |
| sqrt | routine, method | From (Numeric, Complex, Cool) |
| squish | method, routine | From (Any, Supply, Independent routines) |
| srand | sub | From (Num) |
| stable | method | From (Supply) |
| start | method | From (Thread, Supply, Promise, Proc::Async) |
| started | method | From (Proc::Async) |
| starts-with | method | From (Str) |
| status | method | From (X::Promise::CauseOnlyValidOnBroken, Promise) |
| stderr | method | From (Proc::Async) |
| stdout | method | From (Proc::Async) |
| store-file | method | From (CompUnit::PrecompilationRepository) |
| store-repo-id | method | From (CompUnit::PrecompilationRepository) |
| store-unit | method | From (CompUnit::PrecompilationRepository) |
| sub_signature | method | From (Parameter) |
| subbuf | method | From (Blob) |
| subbuf-rw | method, routine | From (Buf, Buf) |
| subname | method | From (Backtrace::Frame) |
| subparse | method | From (Grammar) |
| subst | method | From (Allomorph, Str, Cool) |
| subst-mutate | method | From (Allomorph, Str) |
| substr | method, routine | From (Allomorph, Str, Cool) |
| substr-eq | method | From (Str) |
| substr-rw | method, routine | From (Allomorph, Str, Cool) |
| subtest | sub | From (Test) |
| succ | method, routine | From (Date, Numeric, Bool, Allomorph, IO::Path, Str, Enumeration) |
| suffix | method | From (Parameter) |
| sum | method, routine | From (Any, List, Range) |
| summary | method | From (Backtrace) |
| symbol | method | From (X::Caller::NotDynamic, X::Export::NameClash, X::Redeclaration, X::Undeclared) |
| symlink | routine | From (IO::Path) |
| t | method | From (IO::CatHandle, IO::Handle) |
| tail | method | From (Any, Supply, List) |
| take | method, routine | From (Mu, Mu) |
| take-rw | routine | From (Mu) |
| tan | routine | From (Cool) |
| tanh | routine | From (Cool) |
| tap | method | From (Supply) |
| target | method | From (X::IO::Link, X::IO::Symlink, X::Mixin::NotComposable, X::Numeric::Real, X::Temporal::InvalidFormat, Match) |
| target-name | method | From (X::Composition::NotComposable) |
| tau | term | From (Terms) |
| tc | method, routine | From (Allomorph, Str, Cool) |
| tclc | method, routine | From (Allomorph, Str, Cool) |
| tell | method | From (IO::CatHandle, IO::Handle) |
| temp | prefix | From (Operators, Variables) |
| term | method | From (Pod::Defn) |
| term:<> | term | From (Syntax) |
| tertiary | method | From (Collation) |
| then | method | From (Promise) |
| throttle | method | From (Supply) |
| throw | method | From (Exception) |
| throws-like | sub | From (Test) |
| time | term | From (Terms) |
| timezone | method | From (DateTime) |
| tmpdir | method | From (IO::Spec::Cygwin, IO::Spec::Unix, IO::Spec::Win32) |
| to | method | From (X::IO::Copy, X::IO::Move, X::IO::Rename, List, Match) |
| to-posix | method | From (Instant) |
| today | method | From (Date) |
| todo | sub | From (Test) |
| toggle | method | From (Any) |
| total | method | From (Baggy, Setty, Mix) |
| total-memory | method | From (Kernel) |
| trailing | method | From (Pod::Block::Declarator) |
| trans | method | From (Str, Cool) |
| tree | method | From (Any) |
| trim | method, routine | From (Allomorph, Str, Cool) |
| trim-leading | method, routine | From (Allomorph, Str, Cool) |
| trim-trailing | method, routine | From (Allomorph, Str, Cool) |
| truncate | method, routine | From (Complex, Real, Cool) |
| truncated-to | method | From (Date, DateTime) |
| trusts | trait, method | From (Type system, Metamodel::Trusting) |
| try_acquire | method | From (Semaphore) |
| trying | method | From (X::IO::DoesNotExist) |
| twigil | method | From (X::Parameter::Twigil, X::Syntax::Variable::Twigil, Parameter) |
| type | method | From (X::Bind::Slice, X::Does::TypeObject, Attribute, Pod::FormattingCode, Parameter) |
| type_captures | method | From (Parameter) |
| type_check | method | From (Metamodel::DefiniteHOW) |
| typename | method | From (X::Assignment::RO, X::Method::NotFound) |
| uc | method, routine | From (Allomorph, Str, Cool) |
| udp | method | From (IO::Socket::Async) |
| uncaught_handler | method | From (Scheduler) |
| undefine | sub | From (Independent routines) |
| unicmp | infix | From (Operators) |
| unimatch | routine | From (Cool) |
| uniname | routine | From (Cool) |
| uninames | routine | From (Cool) |
| uninstall | method | From (CompUnit::Repository::Installation) |
| uniparse | routine | From (Str) |
| uniprop | routine | From (Cool) |
| uniprops | sub | From (Cool) |
| unique | method, routine | From (Any, Supply, Independent routines) |
| unival | routine, method | From (Int, Str) |
| univals | method | From (Str) |
| unlike | sub | From (Test) |
| unlink | routine | From (IO::Path) |
| unlock | method | From (Lock::Async, IO::CatHandle, IO::Handle, Lock) |
| unpack | method | From (Blob) |
| unpolar | routine, method | From (Independent routines, Cool) |
| unset | method | From (SetHash) |
| unshift | method, routine | From (Any, Nil, Buf, Array) |
| unwrap | method | From (Routine) |
| updir | method | From (IO::Spec::Unix) |
| usage-name | method | From (Parameter) |
| use-ok | sub | From (Test) |
| utc | method | From (DateTime) |
| val | routine | From (Str) |
| value | method | From (Pair, Enumeration) |
| values | method, routine | From (Baggy, Any, List, Map, Setty, Pair, Capture) |
| variable | method | From (X::Syntax::NoSelf) |
| ver | method | From (Metamodel::Versioning) |
| verbose-config | method | From (Compiler) |
| version | method | From (CompUnit, Systemic) |
| volume | method | From (IO::Path) |
| vow | method | From (Promise) |
| w | method | From (IO::Path, IO::Special, Proc::Async) |
| wait | method | From (Lock::ConditionVariable, Supply) |
| warn | sub | From (Exception) |
| watch | method | From (IO::Path) |
| watch-path | method | From (IO::Notification) |
| week | method | From (Dateish) |
| week-number | method | From (Dateish) |
| week-year | method | From (Dateish) |
| weekday-of-month | method | From (Dateish) |
| what | method | From (X::Cannot::Empty, X::Cannot::Lazy, X::OutOfRange, X::Redeclaration, X::Syntax::Malformed, X::Syntax::Missing, X::Syntax::Variable::Numeric, X::Undeclared, IO::Special) |
| when | method | From (X::Obsolete) |
| whole-second | method | From (DateTime) |
| why | method | From (X::Attribute::Required) |
| with-lock-hidden-from-recursion-check | method | From (Lock::Async) |
| wordcase | routine | From (Str, Cool) |
| words | method, routine | From (Supply, IO::CatHandle, IO::Handle, IO::Path, Str, Cool) |
| workaround | method | From (X::NYI) |
| wrap | method | From (Routine) |
| write | method | From (IO::CatHandle, IO::Handle, IO::Socket, IO::Socket::Async, Proc::Async) |
| write-bits | method | From (Buf, Buf) |
| write-int128 | method | From (Buf, Buf) |
| write-int16 | method | From (Buf, Buf) |
| write-int32 | method | From (Buf, Buf) |
| write-int64 | method | From (Buf, Buf) |
| write-int8 | method | From (Buf, Buf) |
| write-num32 | method | From (Buf, Buf) |
| write-num64 | method | From (Buf, Buf) |
| write-to | method | From (IO::Socket::Async) |
| write-ubits | method | From (Buf, Buf) |
| write-uint128 | method | From (Buf, Buf) |
| write-uint16 | method | From (Buf, Buf) |
| write-uint32 | method | From (Buf, Buf) |
| write-uint64 | method | From (Buf, Buf) |
| write-uint8 | method | From (Buf, Buf) |
| x | infix, method | From (Operators, IO::Path, IO::Special) |
| xor | infix | From (Operators) |
| xx | infix | From (Operators) |
| yada | method | From (Routine) |
| year | method | From (Dateish) |
| yield | method | From (Thread) |
| yyyy-mm-dd | method | From (Dateish) |
| z | method | From (IO::Path) |
| zip | method, routine | From (Supply, List) |
| zip-latest | method | From (Supply) |
| ~ | prefix, infix | From (Operators, Operators, Junction) |
| ~& | infix | From (Operators) |
| ~< | infix | From (Operators) |
| ~> | infix | From (Operators) |
| ~^ | prefix, infix | From (Operators, Operators) |
| ~| | infix | From (Operators) |
| ~~ | infix | From (Operators) |