[dfa/Cursor] Implement backslash escapes for character classes

[pugs.git] / src / perl6 / CORE.setting

# CORE.setting
#
# Copyright 2009-2010, Larry Wall
#
# You may copy this software under the terms of the Artistic License,
#     version 2.0 or later.

my module CORE;

constant Nil = ();

my enum Bool <False True>;

my enum Order < Increase Same Decrease >;
my enum TrigBase <Radians Degrees Gradians Circles>;

my role Stash { }
my role Role does Stash { }
my role Package does Stash { }
my role Module does Stash { }
my role Class does Module { }
my role Grammar does Class { }
my role List { }
my role Iterable { }

# XXX does this mean anything?
my role Matcher { }

my class CallFrame { }  # or is this a role?
my class P6opaque { }
my class Mu { }
my class Any { }
my class Junction { }
my class junction { }
my class Whatever { }
my class WhateverCode { }
my class HyperWhatever { }
my class Capture { }
my class Parcel { }
my class Iterator does List { }
my class Match { }
my class Signature { }
my class Parameter { }
my class Proxy { }
my class Scalar { }
my class Array does Iterable { }
my class Hash does Iterable { }
my class KeyHash does Iterable { }
my class KeySet does Iterable { }
my class KeyBag does Iterable { }
my class KeyWeight does Iterable { }
my class Pair { }
my class PairMap { }
my class Enum { }
my class EnumMap { }
my class Seq { }
my class SeqIter does List { }
my class Range { }
my class RangeIter does List { }
my class Set { }
my class Bag { }
my class Mapping { }
my class Sink { }
my class Undef { }
my class Failure { }
my class EMPTY is Failure { }
my class Exception { }
my class Code { }
my class Block { }
my class Routine { }
my class Sub { }
my class Macro { }
my class Method { }
my class Submethod { }
my class Regex { }
my class Multi { }

my role Stringy { }
my class Str { }
my class Cat { }
my class Blob { }
my class Char { }
my class AnyChar { }
my class CharLingua { }
my class Byte { }
my class Codepoint { }
my class Grapheme { }
my class StrPos { }
my class StrLen { }
my class Version { }

my role Numeric { }
my role Real { }
my class Num { 
    # for now, limit denominator to one quintillion to fit in Rat64.
    constant pi is export = 3.14159_26535_89793_238;   # 46_26433_83279_50288;
    constant e  is export = 2.71828_18284_59045_235;   # 36_02874_71352_66249;
    constant i  is export = 1i;
}
import Num <pi e i>;

my class num { }
my class num16 { }
my class num32 { }
my class num64 { }
my class num128 { }

my class Complex { }
my class complex { }

# (eventually these should be instantiated generics, complex:of(num64) and such)
my class complex16 { }
my class complex32 { }
my class complex64 { }
my class complex128 { }

my role Integral { }
my class Int { }
my class int { }

my class int1 { }
my class int2 { }
my class int4 { }
my class int8 { }
my class int16 { }
my class int32 { }
my class int64 { }
my class int128 { }

my role Rational { }
my class Rat { }
my class FatRat { }
my class rat { }
my class rat8 { }
my class rat16 { }
my class rat32 { }
my class rat64 { }
my class rat128 { }

my class UInt { }
my class uint { }
my class uint1 { }
my class uint2 { }
my class uint4 { }
my class uint8 { }
my class uint16 { }
my class uint32 { }
my class uint64 { }
my class uint128 { }

my role Buf { }
my class buf { }
my class buf1 { }
my class buf2 { }
my class buf4 { }
my class buf8 { }
my class buf16 { }
my class buf32 { }
my class buf64 { }

my class utf8 { }
my class utf16 { }
my class utf32 { }

my class Bit { }
my class bit { }
my class bool { }

my role Ordered { }
my role Callable { }
my role Positional { }
my role Associative { }
my role Abstraction { }
my role Integral { }
my role AttributeDeclarand { }
my role ContainerDeclarand { }

my subset Comparator   of Code where { .signature === :(Any, Any --> Int ) };
my subset KeyExtractor of Code where { .signature === :(Any --> Any) };
my subset OrderingPair of Pair where { .left ~~ KeyExtractor && .right ~~ Comparator };
my subset Ordering of Mu where Signature | KeyExtractor | Comparator | OrderingPair | Whatever;

my class Instant { }
my class Duration { }
my class Date { }
my class DateTime { }

my class IO { }

my class KitchenSink { }

my proto WHAT { }
my proto WHERE { }
my proto HOW { }
my proto WHICH { }
my proto VAR { }
my proto WHO { }
my proto WHENCE { }
my proto new { }
my proto fail { }
my proto temp { }
my proto let { }
my proto any { }
my proto all { }
my proto none { }
my proto one { }
my proto not { }
my proto so { }
my proto next { }
my proto last { }
my proto redo { }
my proto succeed { }
my proto goto { }

my proto die { }
my proto exit { }
my proto warn { }
my proto note { }
my proto caller { }
my proto callframe { }
my proto eval { }
my proto evalfile { }
my proto callsame { }
my proto callwith { }
my proto nextsame { }
my proto nextwith { }
my proto lastcall { }
my proto defined { }
my proto notdef { }
my proto undefine { }
my proto item { }
my proto list { }
my proto slice { }
my proto eager { }
my proto hyper { }

my proto cat { }
my proto classify { }
my proto quotemeta { }
my proto chr { }
my proto ord { }
my proto p5chop { }
my proto chop { }
my proto p5chomp { }
my proto chomp { }
my proto trim { }
my proto trim-leading { }
my proto trim-trailing { }
my proto index { }
my proto rindex { }
my proto substr { }
my proto join { }
my proto split { }
my proto comb { }
my proto pack { }
my proto unpack { }
my proto uc { }
my proto ucfirst { }
my proto lc { }
my proto lcfirst { }
my proto normalize { }
my proto nfc { }
my proto nfd { }
my proto nfkc { }
my proto nfkd { }
my proto samecase { }
my proto sameaccent { }
my proto capitalize { }
my proto chars { }
my proto graphs { }
my proto codes { }
my proto bytes { }

my proto say { }
my proto print { }
my proto open { }
my proto close { }
my proto printf { }
my proto sprintf { }
my proto unlink { }
my proto link { }
my proto symlink { }
my proto elems { }
my proto end { }
my proto grep { }
my proto map { }
my proto first { }
my proto reduce { }
my proto sort { }
my proto min { }
my proto max { }
my proto minmax { }
my proto uniq { }
my proto push { }
my proto rotate { }
my proto reverse { }
my proto flip { }
my proto take { }
my proto splice { }
my proto slurp { }
my proto get { }
my proto lines { }
my proto getc { }
my proto prompt { }
my proto chdir { }
my proto chmod { }

my proto zip { }
my proto each { }
my proto roundrobin { }
my proto return { }
my proto leave { }
my proto make { }
my proto pop { }
my proto shift { }
my proto unshift { }
my proto keys { }
my proto values { }
my proto hash { }
my proto kv { }
my proto key { }
my proto value { }
my proto pairs { }
my proto invert { }
my proto pair { }
my proto enum { }

my proto sign { }
my proto abs { }
my proto floor { }
my proto ceiling { }
my proto round { }
my proto truncate { }
my proto exp { }
my proto log { }
my proto log10 { }
my proto sqrt { }
my proto roots { }
my proto rand { }
my proto srand { }
my proto pick { }
my proto cis { }
my proto unpolar { }

my proto sin { }
my proto cos { }
my proto tan { }
my proto asin { }
my proto acos { }
my proto atan { }
my proto sec { }
my proto cosec { }
my proto cotan { }
my proto asec { }
my proto acosec { }
my proto acotan { }
my proto sinh { }
my proto cosh { }
my proto tanh { }
my proto asinh { }
my proto acosh { }
my proto atanh { }
my proto sech { }
my proto cosech { }
my proto cotanh { }
my proto asech { }
my proto acosech { }
my proto acotanh { }
my proto atan2 { }

my proto today { }

my proto gmtime { }
my proto localtime { }
my proto time { }
my proto times { }
my proto gethost { }
my proto getpw { }
my proto chroot { }
my proto getlogin { }
my proto run { }
my proto runinstead { }
my proto fork { }
my proto wait { }
my proto kill { }
my proto sleep { }

my proto postfix:<i> ($x) { }
my proto infix:<.> ($x,$y) { }
my proto postfix:['->'] ($x) { }
my proto postfix:<++> ($x) { }
my proto postfix:«--» ($x) { }
my proto prefix:<++> ($x) { }
my proto prefix:«--» ($x) { }
my proto infix:<**> ($x,$y) { }
my proto prefix:<!> ($x) { }
my proto prefix:<+> ($x) { }
my proto prefix:<-> ($x) { }
my proto prefix:<~~> ($x) { }
my proto prefix:<~> ($x) { }
my proto prefix:<??> ($x) { }
my proto prefix:<?> ($x) { }
my proto prefix:<~^> ($x) { }
my proto prefix:<+^> ($x) { }
my proto prefix:<?^> ($x) { }
my proto prefix:<^^> ($x) { }
my proto prefix:<^> ($x) { }
my proto prefix:<||> ($x) { }
my proto prefix:<|> ($x) { }
my proto infix:<*> ($x,$y) { }
my proto infix:</> ($x,$y) { }
my proto infix:<div> ($x,$y) { }
my proto infix:<%> ($x,$y) { }
my proto infix:<mod> ($x,$y) { }
my proto infix:<+&> ($x,$y) { }
my proto infix:« << » ($x,$y) { }
my proto infix:« >> » ($x,$y) { }
my proto infix:<~&> ($x,$y) { }
my proto infix:<?&> ($x,$y) { }
my proto infix:« ~< » ($x,$y) { }
my proto infix:« ~> » ($x,$y) { }
my proto infix:« +< » ($x,$y) { }
my proto infix:« +> » ($x,$y) { }
my proto infix:<+> ($x,$y) { }
my proto infix:<-> ($x,$y) { }
my proto infix:<+|> ($x,$y) { }
my proto infix:<+^> ($x,$y) { }
my proto infix:<~|> ($x,$y) { }
my proto infix:<~^> ($x,$y) { }
my proto infix:<?|> ($x,$y) { }
my proto infix:<?^> ($x,$y) { }
my proto infix:<x> ($x,$y) { }
my proto infix:<xx> ($x,$y) { }
my proto infix:<~> ($x,$y) { }
my proto infix:<&> ($x,$y) { }
my proto infix:<|> ($x,$y) { }
my proto infix:<^> ($x,$y) { }
my proto infix:« <=> » ($x,$y) { }
my proto infix:<..> ($x,$y) { }
my proto infix:<^..> ($x,$y) { }
my proto infix:<..^> ($x,$y) { }
my proto infix:<^..^> ($x,$y) { }
my proto infix:<==> ($x,$y) { }
my proto infix:<!=> ($x,$y) { }
my proto infix:« < » ($x,$y) { }
my proto infix:« <= » ($x,$y) { }
my proto infix:« > » ($x,$y) { }
my proto infix:« >= » ($x,$y) { }
my proto infix:<~~> ($x,$y) { }
my proto infix:<!~> ($x,$y) { }
my proto infix:<=~> ($x,$y) { }
my proto infix:<eq> ($x,$y) { }
my proto infix:<ne> ($x,$y) { }
my proto infix:<lt> ($x,$y) { }
my proto infix:<le> ($x,$y) { }
my proto infix:<gt> ($x,$y) { }
my proto infix:<ge> ($x,$y) { }
my proto infix:<=:=> ($x,$y) { }
my proto infix:<===> ($x,$y) { }
my proto infix:<eqv> ($x,$y) { }
my proto infix:<before> ($x,$y) { }
my proto infix:<after> ($x,$y) { }
my proto infix:<&&> ($x,$y) { }
my proto infix:<||> ($x,$y) { }
my proto infix:<^^> ($x,$y) { }
my proto infix:<//> ($x,$y) { }
my proto infix:<min> ($x,$y) { }
my proto infix:<max> ($x,$y) { }
my proto infix:<?? !!> ($x,$y) { }
my proto infix:<!!> ($x,$y) { }
my proto infix:<?> ($x,$y) { }
my proto infix:<ff> ($x,$y) { }
my proto infix:<^ff> ($x,$y) { }
my proto infix:<ff^> ($x,$y) { }
my proto infix:<^ff^> ($x,$y) { }
my proto infix:<fff> ($x,$y) { }
my proto infix:<^fff> ($x,$y) { }
my proto infix:<fff^> ($x,$y) { }
my proto infix:<^fff^> ($x,$y) { }
my proto infix:<=> ($x,$y) { }
my proto infix:<:=> ($x,$y) { }
my proto infix:<::=> ($x,$y) { }
my proto infix:<.=> ($x,$y) { }
my proto infix:« => » ($x,$y) { }
my proto prefix:<so> ($x) { }
my proto prefix:<not> ($x) { }
my proto infix:<,> ($x,$y) { }
my proto infix:<:> ($x,$y) { }
my proto infix:<X> ($x,$y) { }
my proto infix:<Z> ($x,$y) { }
my proto infix:<minmax> ($x,$y) { }
my proto infix:<...> ($x,$y) { }
my proto infix:<and> ($x,$y) { }
my proto infix:<andthen> ($x,$y) { }
my proto infix:<or> ($x,$y) { }
my proto infix:<orelse> ($x,$y) { }
my proto infix:<xor> ($x,$y) { }
my proto infix:« <== » ($x,$y) { }
my proto infix:« ==> » ($x,$y) { }
my proto infix:« <<== » ($x,$y) { }
my proto infix:« ==>> » ($x,$y) { }

my package PROCESS {
    my %ENV is export;
}

YOU_ARE_HERE;