├── .circleci
└── config.yml
├── .dockerignore
├── .github
├── issue_template.md
└── pull_request_template.md
├── .gitignore
├── .travis.yml
├── Build.pm6
├── CONTRIBUTING.md
├── CREDITS
├── Dockerfile
├── LICENSE
├── META6.json
├── Makefile
├── README.md
├── app-start
├── app.pl
├── assets
├── js
│ ├── jquery-3.1.1.min.js
│ ├── jquery-ui.min.js
│ ├── jquery.tablesorter.js
│ └── main.js
└── sass
│ ├── _highlights.scss
│ ├── _jquery-ui.scss
│ └── style.scss
├── bin
└── p6doc
├── cpanfile
├── doc
├── 404.pod6
├── HomePage.pod6
├── Language
│ ├── 101-basics.pod6
│ ├── 5to6-nutshell.pod6
│ ├── 5to6-overview.pod6
│ ├── 5to6-perlfunc.pod6
│ ├── 5to6-perlop.pod6
│ ├── 5to6-perlsyn.pod6
│ ├── 5to6-perlvar.pod6
│ ├── about.pod6
│ ├── classtut.pod6
│ ├── community.pod6
│ ├── concurrency.pod6
│ ├── containers.pod6
│ ├── contexts.pod6
│ ├── control.pod6
│ ├── create-cli.pod6
│ ├── enumeration.pod6
│ ├── exceptions.pod6
│ ├── experimental.pod6
│ ├── faq.pod6
│ ├── functions.pod6
│ ├── glossary.pod6
│ ├── grammar_tutorial.pod6
│ ├── grammars.pod6
│ ├── hashmap.pod6
│ ├── haskell-to-p6.pod6
│ ├── intro.pod6
│ ├── io-guide.pod6
│ ├── io.pod6
│ ├── ipc.pod6
│ ├── iterating.pod6
│ ├── js-nutshell.pod6
│ ├── list.pod6
│ ├── math.pod6
│ ├── module-packages.pod6
│ ├── modules-core.pod6
│ ├── modules-extra.pod6
│ ├── modules.pod6
│ ├── mop.pod6
│ ├── nativecall.pod6
│ ├── nativetypes.pod6
│ ├── newline.pod6
│ ├── numerics.pod6
│ ├── objects.pod6
│ ├── opener-chars.pod6
│ ├── operators.pod6
│ ├── optut.pod6
│ ├── packages.pod6
│ ├── performance.pod6
│ ├── phasers.pod6
│ ├── pod.pod6
│ ├── pragmas.pod6
│ ├── py-nutshell.pod6
│ ├── quoting.pod6
│ ├── rb-nutshell.pod6
│ ├── regexes-best-practices.pod6
│ ├── regexes.pod6
│ ├── setbagmix.pod6
│ ├── statement-prefixes.pod6
│ ├── structures.pod6
│ ├── subscripts.pod6
│ ├── syntax.pod6
│ ├── system.pod6
│ ├── tables.pod6
│ ├── temporal.pod6
│ ├── terms.pod6
│ ├── testing.pod6
│ ├── traits.pod6
│ ├── traps.pod6
│ ├── typesystem.pod6
│ ├── unicode.pod6
│ ├── unicode_ascii.pod6
│ ├── unicode_entry.pod6
│ └── variables.pod6
├── Native
│ └── int.pod6
├── Programs
│ ├── 01-debugging.pod6
│ ├── 02-reading-docs.pod6
│ ├── 03-environment-variables.pod6
│ └── README.md
└── Type
│ ├── AST.pod6
│ ├── Any.pod6
│ ├── Array.pod6
│ ├── Associative.pod6
│ ├── Attribute.pod6
│ ├── Backtrace.pod6
│ ├── Backtrace
│ └── Frame.pod6
│ ├── Bag.pod6
│ ├── BagHash.pod6
│ ├── Baggy.pod6
│ ├── Blob.pod6
│ ├── Block.pod6
│ ├── Bool.pod6
│ ├── Buf.pod6
│ ├── CX
│ ├── Done.pod6
│ ├── Emit.pod6
│ ├── Last.pod6
│ ├── Next.pod6
│ ├── Proceed.pod6
│ ├── Redo.pod6
│ ├── Return.pod6
│ ├── Succeed.pod6
│ ├── Take.pod6
│ └── Warn.pod6
│ ├── CallFrame.pod6
│ ├── Callable.pod6
│ ├── Cancellation.pod6
│ ├── Capture.pod6
│ ├── Channel.pod6
│ ├── Code.pod6
│ ├── Collation.pod6
│ ├── CompUnit.pod6
│ ├── CompUnit
│ ├── Repository.pod6
│ └── Repository
│ │ ├── FileSystem.pod6
│ │ └── Installation.pod6
│ ├── Compiler.pod6
│ ├── Complex.pod6
│ ├── ComplexStr.pod6
│ ├── Cool.pod6
│ ├── CurrentThreadScheduler.pod6
│ ├── Date.pod6
│ ├── DateTime.pod6
│ ├── Dateish.pod6
│ ├── Distribution.pod6
│ ├── Distribution
│ ├── Hash.pod6
│ ├── Locally.pod6
│ └── Path.pod6
│ ├── Distro.pod6
│ ├── Duration.pod6
│ ├── Encoding.pod6
│ ├── Encoding
│ └── Registry.pod6
│ ├── Endian.pod6
│ ├── Enumeration.pod6
│ ├── Exception.pod6
│ ├── Failure.pod6
│ ├── FatRat.pod6
│ ├── ForeignCode.pod6
│ ├── Grammar.pod6
│ ├── Hash.pod6
│ ├── HyperSeq.pod6
│ ├── HyperWhatever.pod6
│ ├── IO.pod6
│ ├── IO
│ ├── ArgFiles.pod6
│ ├── CatHandle.pod6
│ ├── Handle.pod6
│ ├── Notification.pod6
│ ├── Path.pod6
│ ├── Path
│ │ ├── Cygwin.pod6
│ │ ├── QNX.pod6
│ │ ├── Unix.pod6
│ │ └── Win32.pod6
│ ├── Pipe.pod6
│ ├── Socket.pod6
│ ├── Socket
│ │ ├── Async.pod6
│ │ └── INET.pod6
│ ├── Spec.pod6
│ ├── Spec
│ │ ├── Cygwin.pod6
│ │ ├── QNX.pod6
│ │ ├── Unix.pod6
│ │ └── Win32.pod6
│ └── Special.pod6
│ ├── Instant.pod6
│ ├── Int.pod6
│ ├── IntStr.pod6
│ ├── Iterable.pod6
│ ├── Iterator.pod6
│ ├── Junction.pod6
│ ├── Kernel.pod6
│ ├── Label.pod6
│ ├── List.pod6
│ ├── Lock.pod6
│ ├── Lock
│ └── Async.pod6
│ ├── Macro.pod6
│ ├── Map.pod6
│ ├── Match.pod6
│ ├── Metamodel
│ ├── AttributeContainer.pod6
│ ├── C3MRO.pod6
│ ├── ClassHOW.pod6
│ ├── ConcreteRoleHOW.pod6
│ ├── CurriedRoleHOW.pod6
│ ├── EnumHOW.pod6
│ ├── Finalization.pod6
│ ├── MROBasedMethodDispatch.pod6
│ ├── MethodContainer.pod6
│ ├── MultipleInheritance.pod6
│ ├── Naming.pod6
│ ├── PackageHOW.pod6
│ ├── ParametricRoleGroupHOW.pod6
│ ├── ParametricRoleHOW.pod6
│ ├── Primitives.pod6
│ ├── PrivateMethodContainer.pod6
│ ├── RoleContainer.pod6
│ ├── RolePunning.pod6
│ ├── Trusting.pod6
│ └── Versioning.pod6
│ ├── Method.pod6
│ ├── Mix.pod6
│ ├── MixHash.pod6
│ ├── Mixy.pod6
│ ├── Mu.pod6
│ ├── NFC.pod6
│ ├── NFD.pod6
│ ├── NFKC.pod6
│ ├── NFKD.pod6
│ ├── Nil.pod6
│ ├── Num.pod6
│ ├── NumStr.pod6
│ ├── Numeric.pod6
│ ├── ObjAt.pod6
│ ├── Order.pod6
│ ├── Pair.pod6
│ ├── Parameter.pod6
│ ├── Perl.pod6
│ ├── Pod
│ ├── Block.pod6
│ ├── Block
│ │ ├── Code.pod6
│ │ ├── Comment.pod6
│ │ ├── Declarator.pod6
│ │ ├── Named.pod6
│ │ ├── Para.pod6
│ │ └── Table.pod6
│ ├── Defn.pod6
│ ├── FormattingCode.pod6
│ ├── Heading.pod6
│ └── Item.pod6
│ ├── Positional.pod6
│ ├── PositionalBindFailover.pod6
│ ├── PredictiveIterator.pod6
│ ├── Proc.pod6
│ ├── Proc
│ └── Async.pod6
│ ├── Promise.pod6
│ ├── Proxy.pod6
│ ├── PseudoStash.pod6
│ ├── QuantHash.pod6
│ ├── RaceSeq.pod6
│ ├── Range.pod6
│ ├── Rat.pod6
│ ├── RatStr.pod6
│ ├── Rational.pod6
│ ├── Real.pod6
│ ├── Regex.pod6
│ ├── Routine.pod6
│ ├── Routine
│ └── WrapHandle.pod6
│ ├── Scalar.pod6
│ ├── Scheduler.pod6
│ ├── Semaphore.pod6
│ ├── Seq.pod6
│ ├── Sequence.pod6
│ ├── Set.pod6
│ ├── SetHash.pod6
│ ├── Setty.pod6
│ ├── Signature.pod6
│ ├── Slip.pod6
│ ├── Stash.pod6
│ ├── Str.pod6
│ ├── StrDistance.pod6
│ ├── Stringy.pod6
│ ├── Sub.pod6
│ ├── Submethod.pod6
│ ├── Supplier.pod6
│ ├── Supplier
│ └── Preserving.pod6
│ ├── Supply.pod6
│ ├── Systemic.pod6
│ ├── Tap.pod6
│ ├── Telemetry.pod6
│ ├── Telemetry
│ ├── Instrument
│ │ ├── Thread.pod6
│ │ ├── ThreadPool.pod6
│ │ └── Usage.pod6
│ ├── Period.pod6
│ └── Sampler.pod6
│ ├── Test.pod6
│ ├── Thread.pod6
│ ├── ThreadPoolScheduler.pod6
│ ├── UInt.pod6
│ ├── Uni.pod6
│ ├── VM.pod6
│ ├── ValueObjAt.pod6
│ ├── Variable.pod6
│ ├── Version.pod6
│ ├── Whatever.pod6
│ ├── WhateverCode.pod6
│ ├── X
│ ├── AdHoc.pod6
│ ├── Anon
│ │ ├── Augment.pod6
│ │ └── Multi.pod6
│ ├── Assignment
│ │ └── RO.pod6
│ ├── Attribute
│ │ ├── NoPackage.pod6
│ │ ├── Package.pod6
│ │ ├── Required.pod6
│ │ └── Undeclared.pod6
│ ├── Augment
│ │ └── NoSuchType.pod6
│ ├── Bind.pod6
│ ├── Bind
│ │ ├── NativeType.pod6
│ │ └── Slice.pod6
│ ├── Caller
│ │ └── NotDynamic.pod6
│ ├── Channel
│ │ ├── ReceiveOnClosed.pod6
│ │ └── SendOnClosed.pod6
│ ├── Comp.pod6
│ ├── Composition
│ │ └── NotComposable.pod6
│ ├── Constructor
│ │ └── Positional.pod6
│ ├── Control.pod6
│ ├── ControlFlow.pod6
│ ├── ControlFlow
│ │ └── Return.pod6
│ ├── DateTime
│ │ └── TimezoneClash.pod6
│ ├── Declaration
│ │ ├── Scope.pod6
│ │ └── Scope
│ │ │ └── Multi.pod6
│ ├── Does
│ │ └── TypeObject.pod6
│ ├── Dynamic
│ │ └── NotFound.pod6
│ ├── Eval
│ │ └── NoSuchLang.pod6
│ ├── Export
│ │ └── NameClash.pod6
│ ├── IO.pod6
│ ├── IO
│ │ ├── Chdir.pod6
│ │ ├── Chmod.pod6
│ │ ├── Copy.pod6
│ │ ├── Cwd.pod6
│ │ ├── Dir.pod6
│ │ ├── DoesNotExist.pod6
│ │ ├── Link.pod6
│ │ ├── Mkdir.pod6
│ │ ├── Move.pod6
│ │ ├── Rename.pod6
│ │ ├── Rmdir.pod6
│ │ ├── Symlink.pod6
│ │ └── Unlink.pod6
│ ├── Inheritance
│ │ ├── NotComposed.pod6
│ │ └── Unsupported.pod6
│ ├── Method
│ │ ├── InvalidQualifier.pod6
│ │ ├── NotFound.pod6
│ │ └── Private
│ │ │ ├── Permission.pod6
│ │ │ └── Unqualified.pod6
│ ├── Mixin
│ │ └── NotComposable.pod6
│ ├── NYI.pod6
│ ├── NoDispatcher.pod6
│ ├── Numeric
│ │ └── Real.pod6
│ ├── OS.pod6
│ ├── Obsolete.pod6
│ ├── OutOfRange.pod6
│ ├── Package
│ │ └── Stubbed.pod6
│ ├── Parameter
│ │ ├── Default.pod6
│ │ ├── MultipleTypeConstraints.pod6
│ │ ├── Placeholder.pod6
│ │ ├── Twigil.pod6
│ │ └── WrongOrder.pod6
│ ├── Phaser
│ │ ├── Multiple.pod6
│ │ └── PrePost.pod6
│ ├── Placeholder
│ │ ├── Block.pod6
│ │ └── Mainline.pod6
│ ├── Pod.pod6
│ ├── Proc
│ │ ├── Async.pod6
│ │ ├── Async
│ │ │ ├── AlreadyStarted.pod6
│ │ │ ├── BindOrUse.pod6
│ │ │ ├── CharsOrBytes.pod6
│ │ │ ├── MustBeStarted.pod6
│ │ │ ├── OpenForWriting.pod6
│ │ │ └── TapBeforeSpawn.pod6
│ │ └── Unsuccessful.pod6
│ ├── Promise
│ │ ├── CauseOnlyValidOnBroken.pod6
│ │ └── Vowed.pod6
│ ├── Redeclaration.pod6
│ ├── Role
│ │ └── Initialization.pod6
│ ├── Scheduler
│ │ └── CueInNaNSeconds.pod6
│ ├── Seq
│ │ └── Consumed.pod6
│ ├── Sequence
│ │ └── Deduction.pod6
│ ├── Signature
│ │ ├── NameClash.pod6
│ │ └── Placeholder.pod6
│ ├── Str
│ │ └── Numeric.pod6
│ ├── StubCode.pod6
│ ├── Syntax.pod6
│ ├── Syntax
│ │ ├── Augment
│ │ │ └── WithoutMonkeyTyping.pod6
│ │ ├── Comment
│ │ │ └── Embedded.pod6
│ │ ├── Confused.pod6
│ │ ├── InfixInTermPosition.pod6
│ │ ├── Malformed.pod6
│ │ ├── Missing.pod6
│ │ ├── NegatedPair.pod6
│ │ ├── NoSelf.pod6
│ │ ├── Number
│ │ │ └── RadixOutOfRange.pod6
│ │ ├── P5.pod6
│ │ ├── Perl5Var.pod6
│ │ ├── Regex
│ │ │ ├── Adverb.pod6
│ │ │ └── SolitaryQuantifier.pod6
│ │ ├── Reserved.pod6
│ │ ├── Self
│ │ │ └── WithoutObject.pod6
│ │ ├── Signature
│ │ │ └── InvocantMarker.pod6
│ │ ├── Term
│ │ │ └── MissingInitializer.pod6
│ │ ├── UnlessElse.pod6
│ │ └── Variable
│ │ │ ├── Match.pod6
│ │ │ ├── Numeric.pod6
│ │ │ └── Twigil.pod6
│ ├── Temporal.pod6
│ ├── Temporal
│ │ └── InvalidFormat.pod6
│ ├── TypeCheck.pod6
│ ├── TypeCheck
│ │ ├── Assignment.pod6
│ │ ├── Binding.pod6
│ │ ├── Return.pod6
│ │ └── Splice.pod6
│ └── Undeclared.pod6
│ ├── atomicint.pod6
│ ├── independent-routines.pod6
│ └── utf8.pod6
├── highlights
├── highlight-file.coffee
├── highlight-filename-from-stdin.coffee
├── highlight-folder.coffee
└── package.json
├── html
├── .htaccess
├── css
│ └── custom-theme
│ │ └── images
│ │ ├── ui-bg_glass_45_C0E472_1x400.png
│ │ ├── ui-bg_glass_75_c0e472_1x400.png
│ │ ├── ui-bg_glass_75_f5e47b_1x400.png
│ │ ├── ui-bg_highlight-soft_75_f5e47b_1x100.png
│ │ ├── ui-bg_inset-hard_95_e47286_1x100.png
│ │ ├── ui-bg_inset-hard_95_f5e47b_1x100.png
│ │ ├── ui-icons_000000_256x240.png
│ │ ├── ui-icons_63a4ff_256x240.png
│ │ └── ui-icons_e13755_256x240.png
├── favicon.ico
└── images
│ ├── Camelia-faded.svg
│ ├── Camelia.svg
│ ├── External-link-04-bold-12x12.svg
│ ├── camelia-404.png
│ ├── camelia-small.png
│ └── pencil.svg
├── lib
├── Pod
│ ├── Cache.pm6
│ ├── Convenience.pm6
│ └── To
│ │ └── SectionFilter.pm6
└── Test-Files.pm6
├── p6doc.iml
├── resources
└── i18n
│ ├── de
│ └── README.de.md
│ ├── es
│ └── README.es.md
│ ├── fr
│ └── README.fr.md
│ ├── it
│ └── README.it.md
│ ├── jp
│ └── README.jp.md
│ ├── nl
│ └── README.nl.md
│ ├── pt
│ └── README.pt.md
│ └── zh
│ ├── README.zh.md
│ └── doc
│ └── Language
│ ├── 5to6-nutshell.zh.pod6
│ ├── 5to6-overview.zh.pod6
│ ├── 5to6-perlfunc.zh.pod6
│ ├── 5to6-perlop.zh.pod6
│ ├── 5to6-perlsyn.zh.pod6
│ ├── 5to6-perlvar.zh.pod6
│ ├── faq.zh.pod6
│ └── rb-nutshell.zh.pod6
├── shippable.yml
├── t
├── 00-meta.t
├── 01-load.t
├── 02-pod-valid.t
├── 02-tests-valid.t
├── 03-pod6.t
├── 05-pod-convenience.t
└── 07-tabs.t
├── template
├── footer.html
├── head.html
├── header.html
└── search_template.js
├── type-graph.txt
├── util
├── Dockerfile
├── clean-spell
├── ignored-methods.txt
├── issue-with-all-pod6.p6
├── list-missing-methods.p6
├── missing-methods.p6
├── missing-types.p6
├── new-type.p6
├── perl-nbsp.p6
├── sync
├── sync-build-log
├── test-links.sh
├── to-raku.p6
├── travis-build.sh
├── travis-test.sh
├── trigger-rebuild.txt
├── unskip.p6
├── update-and-sync
├── update-and-test
└── xt-recent.sh
├── writing-docs
├── CREATING-NEW-DOCS.md
├── EXAMPLES.md
├── SQUASHATHONS.md
└── STYLEGUIDE.md
└── xt
├── aspell.t
├── braces.t
├── camelia-invocations.t
├── code.pws
├── double-dots.t
├── duplicates.t
├── examples-compilation.t
├── headings.t
├── links-not-links.t
├── perl-nbsp.t
├── return-type.t
├── space-after-comma.t
├── trailing-whitespace.t
├── type-graph.t
├── word-variants.t
└── words.pws
/.circleci/config.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | jobs:
3 | test-linux:
4 | docker:
5 | - image: antoniogamiz/documentable
6 | steps:
7 | - checkout
8 | - run:
9 | name: Test documentable
10 | command: |
11 | # test one build
12 | documentable start -a
13 |
14 | workflows:
15 | version: 2
16 | test-deploy:
17 | jobs:
18 | - test-linux
19 |
--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | .sass-cache/
2 | .git/
3 | .gitignore
4 | .travis.yml
5 | writing-docs
6 | build
7 | .github
8 | .precomp
9 | .pod-cache
10 | xt
11 |
--------------------------------------------------------------------------------
/.github/issue_template.md:
--------------------------------------------------------------------------------
1 | ## The problem
2 |
3 |
4 | ## Suggestions
5 |
6 |
7 |
24 |
--------------------------------------------------------------------------------
/.github/pull_request_template.md:
--------------------------------------------------------------------------------
1 | ## The problem
2 |
3 |
4 | ## Solution provided
5 |
6 |
18 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.swp
2 | index.data
3 | *~
4 | html/*.html
5 | html/css/app.css
6 | html/perl6.xhtml
7 | html/routine/
8 | html/type/
9 | html/op/
10 | html/language/
11 | html/programs/
12 | html/syntax/
13 | html/images/type-graph*
14 | html/js/search.js
15 | html/js/app.js
16 | .precomp
17 | precompiled
18 | assets/assetpack.db
19 | assets/cache
20 | .sass-cache/
21 | links.txt
22 | links.tmp
23 | xt/aspell.pws
24 | highlights/node_modules
25 | **/npm-debug.log
26 | highlights/atom-language-perl6/
27 | .DS_store
28 | highlights/package-lock.json
29 | .pod-cache
30 | retest
31 | build/
32 | node_modules/
33 | package-lock.json
34 | *.epub
35 | .idea
36 |
--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language:
2 | - minimal
3 |
4 | os:
5 | - linux
6 |
7 | dist: bionic
8 |
9 | cache:
10 | directories:
11 | - precompiled
12 | - html
13 | - highlights/node_modules
14 | - $HOME/.rakudobrew
15 |
16 |
17 | services:
18 | - docker
19 |
20 | fast_finish: true
21 |
22 | branches:
23 | except:
24 | - gh-pages
25 |
26 | before_install:
27 | - nvm install 7.2.1
28 | - nvm use 7.2.1
29 |
30 | install:
31 | - util/travis-build.sh
32 |
33 | script:
34 | - export CXX=$(command -v g++-4.8 >/dev/null 2>&1; if [ $? -eq 1 ]; then printf "g++"; else printf "g++-4.8"; fi)
35 | - $CXX --version
36 | - util/travis-test.sh
37 |
38 | matrix:
39 | include:
40 | - env: BUILDENV=docker
41 |
--------------------------------------------------------------------------------
/Build.pm6:
--------------------------------------------------------------------------------
1 | # Since the p6doc pod is now moved from 'lib' to 'doc' in the distribution we
2 | # need this to install pod under .../share/perl6/doc
3 | # This fixes p6doc command line use.
4 |
5 | use v6;
6 | use File::Find;
7 |
8 | class Build {
9 | method build($workdir) {
10 | my $doc-dir = $workdir.IO.child('doc');
11 | my $dest-pref = $*REPO.repo-chain.grep(/site/).first.prefix.child("doc");
12 | mkdir($dest-pref) unless $dest-pref.d;
13 |
14 | my @files = find(dir => "$workdir/doc", type => 'file').list;
15 | my $copied-all = True;
16 | for @files -> $file {
17 | next if $file.basename eq 'HomePage.pod6';
18 |
19 | my $rel-dest = $file.relative($doc-dir);
20 | my $abs-dest = IO::Path.new($rel-dest, :CWD($dest-pref)).absolute;
21 |
22 | mkdir($abs-dest.IO.parent) unless $abs-dest.IO.parent.d;
23 |
24 | say "Copying {$rel-dest} to {$abs-dest}";
25 |
26 | copy($file, $abs-dest);
27 | $copied-all = False unless $abs-dest.IO.e;
28 | }
29 |
30 | # Zef considers the build to have passed only if a truthy value is returned.
31 | $copied-all;
32 | }
33 | method isa($what) { # Only needed for older panda compatibility
34 | return True if $what.^name eq 'Panda::Builder';
35 | callsame;
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM jjmerelo/rakudo-nostar:latest
2 |
3 | RUN buildDeps=' \
4 | build-essential \
5 | cpanminus \
6 | ' \
7 | runtimeDeps=' \
8 | graphviz \
9 | make \
10 | ruby-sass \
11 | ' \
12 | testDeps=' \
13 | aspell \
14 | ' \
15 | \
16 | && set -x \
17 | && apt-get update \
18 | && apt-get --yes --no-install-recommends install $buildDeps $runtimeDeps $testDeps \
19 | && rm -rf /var/lib/apt/lists/* \
20 | \
21 | && cpanm -vn Mojolicious \
22 | && n=/usr/local/bin/n \
23 | && curl -fsSL https://raw.githubusercontent.com/tj/n/master/bin/n > "$n" \
24 | && chmod +x "$n" \
25 | && n stable
26 |
27 | WORKDIR /perl6/doc
28 | COPY . .
29 | RUN zef install zef && zef update && zef install --deps-only .
30 |
31 | RUN make test && make html
32 |
33 | EXPOSE 3000
34 |
35 | CMD ["morbo", "-w", "assets/sass", "-w", "assets/js", "-w", "html/js/search.js", "-l", "http://0.0.0.0:3000", "app.pl"]
36 |
--------------------------------------------------------------------------------
/META6.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "p6doc",
3 | "description": "Perl 6 documentation (tools and docs)",
4 | "version": "1.003",
5 | "perl": "6.*",
6 | "authors": [
7 | "perl6"
8 | ],
9 | "auth": "perl6",
10 | "depends": [
11 | "URI",
12 | "File::Temp",
13 | "JSON::Fast",
14 | "Pod::To::BigPage:ver<0.5.1+>",
15 | "Pod::To::HTML:ver<0.6.1+>",
16 | "OO::Monitors",
17 | "File::Find",
18 | "Test::META",
19 | "Perl6::TypeGraph"
20 | ],
21 | "build-depends": [
22 | "File::Find"
23 | ],
24 | "provides": {
25 | "Pod::Cache": "lib/Pod/Cache.pm6",
26 | "Pod::Convenience": "lib/Pod/Convenience.pm6",
27 | "Pod::To::SectionFilter": "lib/Pod/To/SectionFilter.pm6",
28 | "Test-Files": "lib/Test-Files.pm6"
29 | },
30 | "support": {
31 | "source": "git://github.com/perl6/doc.git"
32 | },
33 | "license": "Artistic-2.0",
34 | "tags": [
35 | "perl6",
36 | "pod6",
37 | "documentation",
38 | "reference"
39 | ],
40 | "source-url": "git://github.com/perl6/doc.git",
41 | "meta6": "0"
42 | }
--------------------------------------------------------------------------------
/app-start:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | morbo -w assets/sass -w assets/js -w html/js/search.js app.pl
3 |
4 |
--------------------------------------------------------------------------------
/cpanfile:
--------------------------------------------------------------------------------
1 | requires 'CSS::Minifier::XS' => '0.09';
2 | requires 'CSS::Sass' => '3.4.10';
3 | requires 'File::Copy' => '0';
4 | requires 'File::Temp' => '0.2304';
5 | requires 'File::Spec::Functions' => '0';
6 | requires 'IO::Socket::SSL' => '2.056';
7 | requires 'JavaScript::Minifier::XS' => '0.11';
8 | requires 'Mojo::File' => '0';
9 | requires 'Mojolicious' => '== 7.31';
10 | requires 'Mojolicious::Lite' => '0';
11 | requires 'Mojolicious::Plugin::AssetPack' => '1.42';
12 | requires 'strict' => '0';
13 | requires 'warnings' => '0';
14 |
--------------------------------------------------------------------------------
/doc/404.pod6:
--------------------------------------------------------------------------------
1 | =begin Html
2 |
3 |
4 |
5 |
404: Page Not Found
6 |
7 |
8 | We're sorry, but the page you tried to reach cannot be found.
9 |
10 | - If you got here by following
11 | a link on this site or as a result of searching on it, please report it
12 | on our GitHub repository
13 | so we can fix it!
14 | - If a search engine sent you here, the link might have disappeared due to site reorganization. We still encourage you to report it as above, but it will eventually disappear from search engines too.
15 | - If you came following a link from some site or blog, we would still want to know about that; you might want to report the blog or website author too.
16 |
17 |
18 |
19 |
20 | =end Html
21 |
22 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
23 |
--------------------------------------------------------------------------------
/doc/Native/int.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class int
4 |
5 | =SUBTITLE Native integer
6 |
7 | class int is Int { }
8 |
9 | This class is used to represent integers that are native to the compiler,
10 | operating system and architecture the interpreter is compiled in.
11 |
12 | More information in L as well as in
13 | the section on L.
14 |
15 |
16 | =end pod
17 |
18 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
19 |
--------------------------------------------------------------------------------
/doc/Programs/README.md:
--------------------------------------------------------------------------------
1 | Attention contributors
2 | ======================
3 |
4 | Files in this directory are sorted by file name to generate the index
5 | for the "Programs" tab (in contrast to the other tabs which are
6 | indexed in order by each file's "=TITLE" entry).
7 |
--------------------------------------------------------------------------------
/doc/Type/AST.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class AST
4 |
5 | =SUBTITLE Abstract representation of a piece of source code
6 |
7 | class AST { }
8 |
9 | An C or I is a partially processed representation
10 | of a program. ASTs are return values of the C quoting construct,
11 | and are typically used within macros to generate code that is inserted
12 | in the calling location of the macro.
13 |
14 | There is no API defined for ASTs yet. Hopefully that will emerge as
15 | part of the work on macros.
16 |
17 | =end pod
18 |
19 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
20 |
--------------------------------------------------------------------------------
/doc/Type/CX/Done.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Done
4 |
5 | =SUBTITLE Done control exception
6 |
7 | role CX::Done does X::Control { }
8 |
9 | A L to be used to
10 | indicate a supply block is finished by calling C.
11 |
12 | =head1 Methods
13 |
14 | =head2 method message
15 |
16 | Defined as:
17 |
18 | method message()
19 |
20 | Returns ""
21 |
22 | =end pod
23 |
--------------------------------------------------------------------------------
/doc/Type/CX/Emit.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Emit
4 |
5 | =SUBTITLE Emit control exception
6 |
7 | role CX::Emit does X::Control { }
8 |
9 | A L to be used when
10 | emit is used inside a C block.
11 |
12 | =head1 Methods
13 |
14 | =head2 method message
15 |
16 | Defined as:
17 |
18 | method message()
19 |
20 | Returns ""
21 |
22 | =end pod
23 |
--------------------------------------------------------------------------------
/doc/Type/CX/Last.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Last
4 |
5 | =SUBTITLE Last control exception
6 |
7 | role CX::Last does X::Control { }
8 |
9 | A L that is thrown
10 | when C is called.
11 |
12 | =head1 Methods
13 |
14 | =head2 method message
15 |
16 | Defined as:
17 |
18 | method message()
19 |
20 | Returns "". Since this type of exception is to be
21 | consumed by type and not really by the content of the message, this is a generic
22 | message, similar to all other C exceptions.
23 |
24 | =end pod
25 |
--------------------------------------------------------------------------------
/doc/Type/CX/Next.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Next
4 |
5 | =SUBTITLE Next control exception
6 |
7 | role CX::Next does X::Control { }
8 |
9 | A L that is triggered
10 | when C is called.
11 |
12 | =for code
13 | for ^10 {
14 | CONTROL {
15 | when CX::Next { say "We're next" };
16 | }
17 | next if $_ %% 2;
18 | say "We're in $_";
19 | }
20 |
21 | This will print:
22 |
23 | =for code :lang
24 | We're next
25 | We're in 1
26 | We're next
27 | We're in 3
28 | We're next
29 | We're in 5
30 | We're next
31 | We're in 7
32 | We're next
33 | We're in 9
34 |
35 |
36 | =head1 Methods
37 |
38 | =head2 method message
39 |
40 | Defined as:
41 |
42 | method message()
43 |
44 | Returns ""
45 |
46 | =end pod
47 |
--------------------------------------------------------------------------------
/doc/Type/CX/Proceed.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Proceed
4 |
5 | =SUBTITLE Proceed control exception
6 |
7 | role CX::Proceed does X::Control { }
8 |
9 | A L to be used when
10 | C is used within C or C blocks.
11 |
12 | =head1 Methods
13 |
14 | =head2 method message
15 |
16 | Defined as:
17 |
18 | method message()
19 |
20 | Returns ""
21 |
22 | =end pod
23 |
--------------------------------------------------------------------------------
/doc/Type/CX/Redo.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Redo
4 |
5 | =SUBTITLE Redo control exception
6 |
7 | role CX::Redo does X::Control { }
8 |
9 | A L thrown when
10 | C is called.
11 |
12 | =head1 Methods
13 |
14 | =head2 method message
15 |
16 | Defined as:
17 |
18 | method message()
19 |
20 | Returns "".
21 |
22 | =end pod
23 |
--------------------------------------------------------------------------------
/doc/Type/CX/Return.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Return
4 |
5 | =SUBTITLE Return control exception
6 |
7 | role CX::Next does X::Control { }
8 |
9 | A L to be used when
10 | return is called from within a sub.
11 |
12 | =head1 Methods
13 |
14 | =head2 method message
15 |
16 | Defined as:
17 |
18 | method message()
19 |
20 | Returns ""
21 |
22 | =end pod
23 |
--------------------------------------------------------------------------------
/doc/Type/CX/Succeed.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Succeed
4 |
5 | =SUBTITLE Succeed control exception
6 |
7 | role CX::Succeed does X::Control { }
8 |
9 | A L thrown when
10 | C is called from a C or C block.
11 |
12 | =head1 Methods
13 |
14 | =head2 method message
15 |
16 | Defined as:
17 |
18 | method message()
19 |
20 | Returns ""
21 |
22 | =end pod
23 |
--------------------------------------------------------------------------------
/doc/Type/CX/Take.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Take
4 |
5 | =SUBTITLE Take control exception
6 |
7 | role CX::Take does X::Control { }
8 |
9 | A L triggered by
10 | C.
11 |
12 | =head1 Methods
13 |
14 | =head2 method message
15 |
16 | Defined as:
17 |
18 | method message()
19 |
20 | Returns "".
21 |
22 | =end pod
23 |
--------------------------------------------------------------------------------
/doc/Type/CX/Warn.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("exception")
2 |
3 | =TITLE role CX::Warn
4 |
5 | =SUBTITLE Control exception warning
6 |
7 | role CX::Warn does X::Control { }
8 |
9 | A L triggered when C is called to warn about any
10 | incidence.
11 |
12 | =head1 Methods
13 |
14 | =head2 method new
15 |
16 | C objects are created when a warning is thrown in any block.
17 |
18 |
19 | =end pod
20 |
--------------------------------------------------------------------------------
/doc/Type/Cancellation.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("domain-specific")
2 |
3 | =TITLE class Cancellation
4 |
5 | =SUBTITLE Removal of a task from a Scheduler before normal completion
6 |
7 | my class Cancellation {}
8 |
9 | A low level part of the Raku L
10 | system. Some L objects return a C with the
11 | L<.cue|/type/Scheduler#method_cue> method which can be used to cancel the
12 | scheduled execution before normal completion. C is a
13 | boolean that is true after L<#cancel> is called.
14 |
15 | =head1 Methods
16 |
17 | =head2 method cancel
18 |
19 | Defined as:
20 |
21 | method cancel()
22 |
23 | Usage:
24 |
25 | =begin code
26 | Cancellation.cancel
27 | =end code
28 |
29 | Cancels the scheduled execution of a task before normal completion.
30 |
31 | =end pod
32 |
33 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
--------------------------------------------------------------------------------
/doc/Type/CurrentThreadScheduler.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class CurrentThreadScheduler
4 |
5 | =SUBTITLE Scheduler that synchronously executes code on the current thread
6 |
7 | =for code :skip-test
8 | class CurrentThreadScheduler does Scheduler {}
9 |
10 | C executes tasks on the current threads. This means
11 | that L blocks until the code has
12 | finished executing.
13 |
14 | =end pod
15 |
16 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
17 |
--------------------------------------------------------------------------------
/doc/Type/Distribution.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("role") :category("basic")
2 |
3 | =TITLE role Distribution
4 |
5 | =SUBTITLE Distribution
6 |
7 | role Distribution { }
8 |
9 | Interface for objects that provide API access mapping META6 data to the files
10 | its represents. Objects that fulfill the C role can be read by
11 | e.g. L. Generally a C provides
12 | read access to a set of modules and metadata. These may be backed by the
13 | filesystem (L, L) but could also read
14 | from an e.g. tar file or socket.
15 |
16 | =head1 Required Methods
17 |
18 | =head2 method meta
19 |
20 | method meta(--> Hash:D) { ... }
21 |
22 | Returns a Hash with the representation of the metadata. Please note that an
23 | actual C file does not need to exist, just a representation in that
24 | format.
25 |
26 | =head2 method content
27 |
28 | method content($name-path --> IO::Handle:D) { ... }
29 |
30 | Returns an C to the file represented by C<$name-path>. C<$name-path>
31 | is a relative path as it would be found in the metadata such as C
32 | or C.
33 |
34 | =end pod
35 |
36 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
37 |
--------------------------------------------------------------------------------
/doc/Type/Distribution/Hash.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class Distribution::Hash
4 |
5 | =SUBTITLE Distribution::Hash
6 |
7 | =for code :preamble
8 | class Distribution::Hash does Distribution::Locally { }
9 |
10 | A L implementation backed by the filesystem. It
11 | does not require a C file, essentially providing a lower level
12 | L|/type/Distribution::Path>.
13 |
14 | =head1 Methods
15 |
16 | =head2 method new
17 |
18 | method new($hash, :$prefix)
19 |
20 | Creates a new C instance from the metadata contained in
21 | C<$hash>. All paths in the metadata will be prefixed with C<:$prefix>.
22 |
23 | =head2 method meta
24 |
25 | method meta()
26 |
27 | Returns a Hash with the representation of the metadata.
28 |
29 | =head2 method content
30 |
31 | Please check
32 | L method in Distribution::Locally|/type/Distribution::Locally#method_content>.
33 |
34 | Returns an C to the file represented by C<$name-path>. C<$name-path>
35 | is a relative path as it would be found in the metadata such as C
36 | or C.
37 |
38 | =end pod
39 |
40 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
41 |
--------------------------------------------------------------------------------
/doc/Type/Distribution/Locally.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class Distribution::Locally
4 |
5 | =SUBTITLE Distribution::Locally
6 |
7 | role Distribution::Locally does Distribution { }
8 |
9 | Provides read access to specific files pointed at by a distributions metadata,
10 | providing the L
11 | method for L and
12 | L.
13 |
14 | =head1 Methods
15 |
16 | =head2 method prefix
17 |
18 | A prefix path to be used in conjuncture with the paths found in the metadata.
19 |
20 | =head2 method content
21 |
22 | Provides L
23 |
24 | Returns an C to the file represented by C<$name-path>. C<$name-path>
25 | is a relative path as it would be found in the metadata such as C
26 | or C, and these paths will be prefixed with
27 | L.
28 |
29 | =end pod
30 |
31 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
32 |
--------------------------------------------------------------------------------
/doc/Type/Distribution/Path.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class Distribution::Path
4 |
5 | =SUBTITLE Distribution::Path
6 |
7 | =for code :preamble
8 | class Distribution::Path does Distribution::Locally { }
9 |
10 | A L implementation backed by the filesystem. It requires a
11 | C file at its root.
12 |
13 | =head1 Methods
14 |
15 | =head2 method new
16 |
17 | method new(IO::Path $prefix, IO::Path :$meta-file = IO::Path)
18 |
19 | Creates a new C instance from the C file found
20 | at the given C<$prefix>, and from which all paths in the metadata will be
21 | prefixed with. C<:$meta-file> may optionally be passed if a filename other than
22 | C needs to be used.
23 |
24 | =head2 method meta
25 |
26 | method meta()
27 |
28 | Returns a Hash with the representation of the metadata.
29 |
30 | =head2 method content
31 |
32 | L
33 |
34 | Returns an C to the file represented by C<$name-path>. C<$name-path>
35 | is a relative path as it would be found in the metadata such as C
36 | or C.
37 |
38 | =end pod
39 |
40 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
41 |
--------------------------------------------------------------------------------
/doc/Type/Distro.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("domain-specific")
2 |
3 | =TITLE class Distro
4 |
5 | =SUBTITLE Distribution related information
6 |
7 | class Distro does Systemic { }
8 |
9 | Built-in class for providing distribution related information. Usually accessed
10 | through the L<$*DISTRO|/language/variables#index-entry-%24*DISTRO> dynamic
11 | variable.
12 |
13 | =head1 Methods
14 |
15 | =head2 method is-win
16 |
17 | Instance method returning a C indicating whether the distribution is a
18 | version of the Windows operating system.
19 |
20 | =head2 method path-sep
21 |
22 | Instance method returning the string that can be used to delimit elements in
23 | a path specification.
24 |
25 | =head2 method release
26 |
27 | Instance method returning the release information of the Distro object. Dies if
28 | the release information could not be established.
29 |
30 | =end pod
31 |
32 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
33 |
--------------------------------------------------------------------------------
/doc/Type/Duration.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class Duration
4 |
5 | =SUBTITLE Length of time
6 |
7 | class Duration is Cool does Real { }
8 |
9 | A C represents a length of time in atomic seconds, with
10 | fractions. Like an L, it is epoch-agnostic.
11 |
12 | Cs can be subtracted from or added to Cs to yield another,
13 | new C. Subtracting one C from another yields a C. A
14 | C can also result from mathematical operations between two
15 | Cs when it makes sense (namely, the addition, subtraction, or modulus
16 | of two Cs). It can also be added, subtracted or divided modulo L
17 | numbers.
18 |
19 | The type of object returned for other numeric operations is currently
20 | unspecified.
21 |
22 | =end pod
23 |
24 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
--------------------------------------------------------------------------------
/doc/Type/Encoding/Registry.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class Encoding::Registry
4 |
5 | =SUBTITLE Management of available encodings
6 |
7 | class Encoding::Registry {}
8 |
9 | C is initialized with a list of encoding that is
10 | available for any Raku application, namely:
11 |
12 | =item C
13 | =item C
14 | =item C
15 | =item C
16 | =item C
17 | =item C, C
18 | =item C
19 | =item C, C, C, C, C, C, C, C, C, C
20 | =item C
21 | =item C
22 | =item C
23 |
24 | =head1 Methods
25 |
26 | =head2 method name
27 |
28 | method register(Encoding $enc --> Nil)
29 |
30 | Register a new L.
31 |
32 | X<|Encoding::Encoder>
33 | X<|Encoding::Decoder>
34 | =head2 method find
35 |
36 | method find(Str() $name)
37 |
38 | Finds an encoding by its name. Returns an C or
39 | C, depending on what had been registered.
40 |
41 | =end pod
42 |
43 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
--------------------------------------------------------------------------------
/doc/Type/Endian.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("enum") :category("basic")
2 |
3 | =TITLE enum Endian
4 |
5 | =SUBTITLE Indicate endianness (6.d, 2018.12 and later)
6 |
7 | enum Endian ;
8 |
9 | X<|NativeEndian>
10 | X<|LittleEndian>
11 | X<|BigEndian>
12 | X<|Endian>
13 | An enum for indicating endianness, specifically with methods on C and
14 | C. Consists of C, C and C.
15 |
16 | =head1 Methods
17 |
18 | =head2 routine Numeric
19 |
20 | multi method Numeric(Endian:D --> Int:D)
21 |
22 | Returns the value part of the C pair.
23 |
24 | say NativeEndian.Numeric; # OUTPUT: «0»
25 | say LittleEndian.Numeric; # OUTPUT: «1»
26 | say BigEndian.Numeric; # OUTPUT: «2»
27 |
28 | Note that the actual numeric values are subject to change. So please use
29 | the named values instead.
30 |
31 | =end pod
32 |
33 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
34 |
--------------------------------------------------------------------------------
/doc/Type/FatRat.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class FatRat
4 |
5 | =SUBTITLE Rational number (arbitrary-precision)
6 |
7 | class FatRat is Cool does Rational[Int, Int] {}
8 |
9 | A C is a rational number stored with arbitrary size numerator and
10 | denominator. Arithmetic operations involving a C and optionally L
11 | or L objects return a C, avoiding loss of precision.
12 |
13 | Since, unlike L, FatRat arithmetics do not fall back L at some
14 | point, there is a risk that repeated arithmetic operations generate
15 | pathologically large numerators and denominators.
16 |
17 | There are two common ways to generate C objects: through the
18 | C constructor, which generates them from numerator and
19 | denominator, or by calling the C<.FatRat> method on an L or L
20 | object.
21 |
22 | =head1 Methods
23 |
24 | =head2 method perl
25 |
26 | multi method perl(FatRat:D: --> Str:D)
27 |
28 | Returns an implementation-specific string that produces an L object
29 | when given to L.
30 |
31 | say FatRat.new(1, 2).perl; # OUTPUT: «FatRat.new(1, 2)»
32 |
33 | =end pod
34 |
35 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
--------------------------------------------------------------------------------
/doc/Type/IO.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("role") :category("domain-specific")
2 |
3 | =TITLE role IO
4 |
5 | =SUBTITLE Input/output related routines
6 |
7 | The role provides no methods, but exists so that C coercers, which
8 | coerce to L, correctly type-check the resultant value. The
9 | role is implemented by L and
10 | L.
11 |
12 | See also the related classes L and
13 | L.
14 |
15 | =end pod
16 |
17 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
18 |
--------------------------------------------------------------------------------
/doc/Type/IO/Path/Cygwin.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("domain-specific")
2 |
3 | =TITLE class IO::Path::Cygwin
4 |
5 | =SUBTITLE IO::Path pre-loaded with IO::Spec::Cygwin
6 |
7 | class IO::Path::Cygwin is IO::Path { }
8 |
9 | This sub-class of L«C|/type/IO::Path», pre-loaded with
10 | L«C|/type/IO::Spec::Cygwin» in the C<$.SPEC> attribute.
11 |
12 | =head1 Methods
13 |
14 | =head2 method new
15 |
16 | Same as L«C|/type/IO::Path#method_new», except
17 | C<:$SPEC> cannot be set and defaults to
18 | L«C|/type/IO::Spec::Cygwin», regardless of the operating
19 | system the code is being run on.
20 |
21 | =head2 method perl
22 |
23 | Defined as:
24 |
25 | method perl(IO::Path::Cygwin:D: --> Str:D)
26 |
27 | Returns a string that, when given passed through L«C|/routine/EVAL»
28 | gives the original invocant back.
29 |
30 | IO::Path::Cygwin.new("foo/bar").perl.say;
31 | # OUTPUT: IO::Path::Cygwin.new("foo/bar", :CWD("/home/camelia"))
32 |
33 | Note that this string includes the value of the C<.CWD> attribute that is set
34 | to L«C<$*CWD>|/language/variables#Dynamic_variables» when the path
35 | object was created, by default.
36 |
37 | =end pod
38 |
39 | # vim: expandtab shiftwidth=4 ft=perl6
40 |
--------------------------------------------------------------------------------
/doc/Type/IO/Path/QNX.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("domain-specific")
2 |
3 | =TITLE class IO::Path::QNX
4 |
5 | =SUBTITLE IO::Path pre-loaded with IO::Spec::QNX
6 |
7 | class IO::Path::QNX is IO::Path { }
8 |
9 | This sub-class of L«C|/type/IO::Path», pre-loaded with
10 | L«C|/type/IO::Spec::QNX» in the C<$.SPEC> attribute.
11 |
12 | =head1 Methods
13 |
14 | =head2 method new
15 |
16 | Same as L«C|/type/IO::Path#method_new», except
17 | C<:$SPEC> cannot be set and defaults to
18 | L«C|/type/IO::Spec::QNX», regardless of the operating system
19 | the code is being run on.
20 |
21 | =head2 method perl
22 |
23 | Defined as:
24 |
25 | method perl(IO::Path::QNX:D: --> Str:D)
26 |
27 | Returns a string that, when given passed through L«C|/routine/EVAL»
28 | gives the original invocant back.
29 |
30 | IO::Path::QNX.new("foo/bar").perl.say;
31 | # OUTPUT: IO::Path::QNX.new("foo/bar", :CWD("/home/camelia"))
32 |
33 | Note that this string includes the value of the C<.CWD> attribute that is set
34 | to L«C<$*CWD>|/language/variables#Dynamic_variables» when the path
35 | object was created, by default.
36 |
37 | =end pod
38 |
39 | # vim: expandtab shiftwidth=4 ft=perl6
40 |
--------------------------------------------------------------------------------
/doc/Type/IO/Path/Unix.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("domain-specific")
2 |
3 | =TITLE class IO::Path::Unix
4 |
5 | =SUBTITLE IO::Path pre-loaded with IO::Spec::Unix
6 |
7 | class IO::Path::Unix is IO::Path { }
8 |
9 | This sub-class of L«C|/type/IO::Path», pre-loaded with
10 | L«C|/type/IO::Spec::Unix» in the C<$.SPEC> attribute.
11 |
12 | =head1 Methods
13 |
14 | =head2 method new
15 |
16 | Same as L«C|/type/IO::Path#method_new», except
17 | C<:$SPEC> cannot be set and defaults to
18 | L«C|/type/IO::Spec::Unix», regardless of the operating system
19 | the code is being run on.
20 |
21 | =head2 method perl
22 |
23 | Defined as:
24 |
25 | method perl(IO::Path::Unix:D: --> Str:D)
26 |
27 | Returns a string that, when given passed through L«C|/routine/EVAL»
28 | gives the original invocant back.
29 |
30 | IO::Path::Unix.new("foo/bar").perl.say;
31 | # OUTPUT: IO::Path::Unix.new("foo/bar", :CWD("/home/camelia"))
32 |
33 | Note that this string includes the value of the C<.CWD> attribute that is set
34 | to L«C<$*CWD>|/language/variables#Dynamic_variables» when the path
35 | object was created, by default.
36 |
37 | =end pod
38 |
39 | # vim: expandtab shiftwidth=4 ft=perl6
40 |
--------------------------------------------------------------------------------
/doc/Type/IO/Path/Win32.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("domain-specific")
2 |
3 | =TITLE class IO::Path::Win32
4 |
5 | =SUBTITLE IO::Path pre-loaded with IO::Spec::Win32
6 |
7 | class IO::Path::Win32 is IO::Path { }
8 |
9 | This sub-class of L«C|/type/IO::Path», pre-loaded with
10 | L«C|/type/IO::Spec::Win32» in the C<$.SPEC> attribute.
11 |
12 | =head1 Methods
13 |
14 | =head2 method new
15 |
16 | Same as L«C|/type/IO::Path#method_new», except
17 | C<:$SPEC> cannot be set and defaults to
18 | L«C|/type/IO::Spec::Win32», regardless of the operating system
19 | the code is being run on.
20 |
21 | =head2 method perl
22 |
23 | Defined as:
24 |
25 | method perl(IO::Path::Win32:D: --> Str:D)
26 |
27 | Returns a string that, when given passed through L«C|/routine/EVAL»
28 | gives the original invocant back.
29 |
30 | IO::Path::Win32.new("foo/bar").perl.say;
31 | # OUTPUT: IO::Path::Win32.new("foo/bar", :CWD("C:\\Users\\camelia"))
32 |
33 | Note that this string includes the value of the C<.CWD> attribute that is set
34 | to L«C<$*CWD>|/language/variables#Dynamic_variables» when the path
35 | object was created, by default.
36 |
37 | =end pod
38 |
39 | # vim: expandtab shiftwidth=4 ft=perl6
40 |
--------------------------------------------------------------------------------
/doc/Type/IO/Pipe.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("domain-specific")
2 |
3 | =TITLE class IO::Pipe
4 |
5 | =SUBTITLE Buffered inter-process string or binary stream
6 |
7 | class IO::Pipe is IO::Handle {}
8 |
9 | An C object closely corresponds to a UNIX pipe. It has one end where
10 | it consumes string or binary data, and another where it reproduces the same
11 | data. It is buffered, so that a write without a read doesn't immediately
12 | block.
13 |
14 | Pipes can be easily constructed with L.
15 |
16 | =head1 Methods
17 |
18 | =head2 method close
19 |
20 | Defined as:
21 |
22 | method close(IO::Pipe: --> Proc:D)
23 |
24 | Closes the pipe and returns L object from which the pipe originates.
25 |
26 | =head2 method IO
27 |
28 | Defined as:
29 |
30 | method IO(IO::Pipe: --> IO::Path:U)
31 |
32 | Returns an L type object.
33 |
34 | =head2 method path
35 |
36 | Defined as:
37 |
38 | method path(IO::Pipe: --> IO::Path:U)
39 |
40 | Returns an L type object.
41 |
42 | =head2 method proc
43 |
44 | Defined as:
45 |
46 | method proc(IO::Pipe: --> Proc:D)
47 |
48 | Returns the L object from which the pipe originates.
49 |
50 | =end pod
--------------------------------------------------------------------------------
/doc/Type/IO/Spec.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("domain-specific")
2 |
3 | =TITLE class IO::Spec
4 |
5 | =SUBTITLE Platform specific operations on file and directory paths
6 |
7 | class IO::Spec { }
8 |
9 | Objects of this class are not used directly but as a sub-class specific to
10 | the platform perl is running on via the C<$*SPEC> variable which will contain
11 | an object of the appropriate type.
12 |
13 | The sub-classes are documented separately, with the platform-specific
14 | differences documented in L, L,
15 | L and L.
16 |
17 | B the C classes provide low-level path operations. Unless
18 | you're creating your own high-level path manipulation routines, you don't
19 | need to use C. Use L«C|/type/IO::Path» instead.
20 |
21 | B no special validation is done by these classes (e.g. check whether
22 | path contains a null character). It is the job of higher-level classes, like
23 | L«C|/type/IO::Path», to do that.
24 |
25 | =head1 Methods
26 |
27 | =end pod
28 |
29 | # vim: expandtab shiftwidth=4 ft=perl6
30 |
--------------------------------------------------------------------------------
/doc/Type/Macro.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("basic")
2 |
3 | =TITLE class Macro
4 |
5 | =SUBTITLE Compile-time routine
6 |
7 | class Macro is Routine { }
8 |
9 | A macro is a Routine whose invocation typically happens during
10 | parsing. By returning an L, a macro can inject code into
11 | the calling location.
12 |
13 | =end pod
14 |
15 | # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
--------------------------------------------------------------------------------
/doc/Type/Metamodel/ConcreteRoleHOW.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("class") :category("metamodel")
2 |
3 | =TITLE role Metamodel::ConcreteRoleHOW
4 |
5 | =SUBTITLE Provides an implementation of a concrete instance of a role
6 |
7 | class Metamodel::ConcreteRoleHOW
8 | does Metamodel::Naming
9 | does Metamodel::Versioning
10 | does Metamodel::PrivateMethodContainer
11 | does Metamodel::MethodContainer
12 | does Metamodel::MultiMethodContainer
13 | does Metamodel::AttributeContainer
14 | does Metamodel::RoleContainer
15 | does Metamodel::MultipleInheritance
16 | does Metamodel::ArrayType
17 | does Metamodel::Concretization {}
18 |
19 | You can use this to build roles, in the same way that C can be used to
20 | build classes:
21 |
22 | =for code
23 | my $a = Metamodel::ConcreteRoleHOW.new_type(name => "Bar");
24 | $a.^compose;
25 | say $a.^roles; # OUTPUT: «(Mu)»
26 |
27 | The main difference with
28 | L|/type/Metamodel::ClassHOW#method_new_type> is that you
29 | can mix-in roles in this newly created one.
30 |
31 | This class is Rakudo specific, and provided only for completeness. Not really
32 | intended to be used by the final user.
33 |
34 | =end pod
35 |
--------------------------------------------------------------------------------
/doc/Type/Metamodel/Finalization.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("role") :category("metamodel")
2 |
3 | =TITLE role Metamodel::Finalization
4 |
5 | =SUBTITLE Metaobject supporting object finalization
6 |
7 | X<|DESTROY metamodel>
8 |
9 | role Metamodel::Finalization { ... }
10 |
11 | This role takes care that C submethods are called (if they
12 | exist) when an object is garbage-collected.
13 |
14 | =head1 Methods
15 |
16 | =head2 method setup_finalization
17 |
18 | method setup_finalization(Metamodel::Finalization:D: $obj)
19 |
20 | Collects the C submethods from this class and all its
21 | superclasses, and marks the class as needing action on garbage
22 | collection.
23 |
24 | A metamodel for a kind that implements finalization semantics must call
25 | this method at type composition time.
26 |
27 | =head2 method destroyers
28 |
29 | method destroyers(Metamodel::Finalization:D: $obj --> List:D)
30 |
31 | Returns a list of all finalization methods.
32 |
33 | =end pod
34 |
--------------------------------------------------------------------------------
/doc/Type/Metamodel/Naming.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("role") :category("metamodel")
2 |
3 | =TITLE role Metamodel::Naming
4 |
5 | =SUBTITLE Metaobject that supports named types
6 |
7 | role Metamodel::Naming { }
8 |
9 | L role for (optionally) named things, like classes,
10 | roles and enums.
11 |
12 | =head1 Methods
13 |
14 | =head2 method name
15 |
16 | method name($type)
17 |
18 | Returns the name of the metaobject, if any.
19 |
20 | say 42.^name; # OUTPUT: «Int»
21 |
22 | =head2 method set_name
23 |
24 | method set_name($type, $new_name)
25 |
26 | Sets the new name of the metaobject.
27 |
28 | =end pod
29 |
--------------------------------------------------------------------------------
/doc/Type/Metamodel/ParametricRoleGroupHOW.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("role") :category("metamodel")
2 |
3 | =TITLE role Metamodel::ParametricRoleGroupHOW
4 |
5 | =SUBTITLE Represents a group of roles with different parameterizations
6 |
7 | class Metamodel::ParametricRoleGroupHOW
8 | does Metamodel::Naming
9 | does Metamodel::Documenting
10 | does Metamodel::Stashing
11 | does Metamodel::TypePretense
12 | does Metamodel::RolePunning
13 | does Metamodel::BoolificationProtocol {}
14 |
15 | A C groups a set of C, every one of them representing a single role declaration with their own parameter sets.
16 |
17 | =for code
18 | (role Zape[::T] {}).HOW.say; # OUTPUT: «Perl6::Metamodel::ParametricRoleHOW.new»
19 | Zape.HOW.say ; # OUTPUT: «Perl6::Metamodel::ParametricRoleGroupHOW.new»
20 |
21 | Cs need to be added to this kind of group:
22 |
23 | =for code
24 | my \zape := Metamodel::ParametricRoleGroupHOW.new_type( name => "zape");
25 | my \zipi := Metamodel::ParametricRoleHOW.new_type( name => "zipi", group => zape);
26 | say zipi.HOW; # OUTPUT: «Perl6::Metamodel::ParametricRoleHOW.new»
27 |
28 |
29 | I: As most of the C classes, this class is here mainly for
30 | illustration purposes and it's not intended for the final user to instantiate.
31 |
32 | =end pod
33 |
--------------------------------------------------------------------------------
/doc/Type/Metamodel/RoleContainer.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("role") :category("metamodel")
2 |
3 | =TITLE role Metamodel::RoleContainer
4 |
5 | =SUBTITLE Metaobject that supports holding/containing roles
6 |
7 | role Metamodel::RoleContainer {}
8 |
9 | Implements the ability to hold roles to be held for composition.
10 |
11 | =for code :preamble
12 | class A does SomeRole {}
13 |
14 | roughly corresponds to
15 |
16 | =for code :preamble
17 | class A {
18 | BEGIN A.^add_role(SomeRole);
19 | }
20 |
21 | =head1 Methods
22 |
23 | =head2 method add_role
24 |
25 | method add_role(Metamodel::RoleContainer:D: $obj, Mu $role)
26 |
27 | Adds the C<$role> to the list of roles to be composed.
28 |
29 | =head2 method roles_to_compose
30 |
31 | method roles_to_compose(Metamodel::RoleContainer:D: $obj --> List:D)
32 |
33 | returns a list of roles added with C, which are to be composed
34 | at type composition time.
35 |
36 | =end pod
37 |
--------------------------------------------------------------------------------
/doc/Type/Metamodel/RolePunning.pod6:
--------------------------------------------------------------------------------
1 | =begin pod :kind("Type") :subkind("role") :category("metamodel")
2 |
3 | =TITLE role Metamodel::RolePunning
4 |
5 | =SUBTITLE Metaobject that supports I of roles.
6 |
7 | role Perl6::Metamodel::RolePunning {}
8 |
9 | Implements the ability to create objects from Cs without the intermediate
10 | need to use a class. Not intended to be used directly (will in fact error if
11 | it's C