<nowiki>

<h2> PISC in Y minutes </h2>
    <pre class="prettyprint">
# PISC has 2 types of comments: line comments like this one, and
/*
Block comments like this.
*/

"Hello, world!" println
# PISC is a stack based language, which means that PISC generally
# works rather like Reverse Polish Notation (RPN)
# This means that the arguments for a command come before the command itself.
# And that commands generally run backwards commpared to most languages

# So if we have this stack, what can we do with it?
1 2 swap    # Stack: 2 1
dup         # Stack: 2 1 1
drop        # Stack: 2 1
2dup        # Stack: 2 1 2 1
nip         # Stack 2 1 1 ( Get rid of the second )

# And we'll clear the stack for further examples
drop drop drop

# Basic math looks like this:
1 2 + # Stack: 3
# If you're running PISC on your local machine, you'll notice that after each
# line of input, it shows you the stack, and the types of the variables on the stack.

drop        # We're done with that 3 for now.


# PISC currently has two types of numbers: Integers and Double Precision floating point numbers.
1 2.0 +     # 3 <Double>
# And when a Double and int mix, the int is converted into a double
3.2 *       # 9.600000000000001 <Double>
drop


# Booleans are also handled in an RPN fashion, true and false are represented by `t` and `f`
t f and     # f <Boolean>
t or        # t <Boolean> No surprises here

# clear-stack will get rid of anything left on the stack
clear-stack

# In PISC, since all words take arguments off the stack,
# control flow tends to work in a bit of a backwards way

# This is an if statement.
# the bits with `[` and `]` are called quotations, and they are kinda special
# This puts a boolean value and 2 quotations on the stack, and the checks the
# the boolean value to decide which quotation to execute
t [ "true" println ] [ "false" println ] if

# Note also that you can use the stack to send
# Information to another command
# This will print "Different"
2 1 = [ "The same" ] [ "Different" ] if println

# They are how you pass code to words that can be executed at a later time
# If you want to execute a quotation, you use the `call` word
[ "This is a quotation" ] [ "But this is the one that will be called" ] call

# Quotations live on the stack before they are used, so you'll seem them printed out
# For example you could type the above example in this fashion:
[ "This is a quotation" ]
[ "But this is the one that will be called" ] call
# And if you do that, you'll see the stack get built up for each quotation.
clear-stack

# Now that we have quoations a little explained we can cover vectors, which are PISC's array-like collections
# The basic syntax for them is:
{ 1 2 3 }       # Stack: [1 2 3] <Vector>
dup 0 vec-at    # stack: [1 2 3] <Vector>, 1 <Integer>

# One thing to note about { } syntax for vectors is that the words inside the { } are treated as code
# Such that the words are executed, and then anything they put on the stack is sliced into vector.
{ 10 [ 1 ] times }
# Stack: [1 1 1 1 1 1 1 1 1 1] <Vector>


# Those are some of the stack shufflers. If you want to build your own stack shufflers
# run `"pick" help` to look at how my current set is built.

# Though some stack-based languages make them hard to use, PISC has decently fully featured local variables
# so that you don't have to track way too many stack entries in your head when dealing with larger code.
# You use `:varname` to take 1 value from the stack and store it in a local variable.
:name 3 :num
# Is the same as:
3 :num :name
# Though I do not recommend using the second style

# $varname places the value from varname onto the stack
$name println     # Prints

{ $name $num }  # Stack: 3] <Vector>
clear-stack


# There are roughly two ways to define words (what most langauges call functions) in PISC:
# The most bang/buck is to use a `:` `;` combo
# Words defined this way have the rough syntax of `: name ( invals -- outvals )  definition ;`
# You need every part, though the stack effect comment (From `(` to `)`) isn't currently checked.
: sum-vec ( vector -- result ) 0 swap [ + ] vec-each ;

# Each time you define a word like this, it recieves its own locals frame.
# (Which means that it has it's own set of local variables)

# This doesn't apply to the second way to define a word:
[ 0 swap [ + ] vec-each ] :sum-vec
# If a quotation is stored into a local variable,
# you can now use the name of the local variable as a word
{ 1 2 3 4 } sum-vec
# Stack: 10 <Integer>

# Loops
# Right now PISC has 3 main types of loops
# 1) Counted loops based on the `times` word
0 :i
4 [ $i print ++i ] times
# This prints
# 0
# 1
# 2
# 3

# 2) Condition based loops, using the `while` word
[ $i 0 = not ] [ $i print --i ] while
# Prints:
# 4
# 3
# 2
# 1


# 3) Each collection type, Vectors, Dictionaries and Strings currently several words that iterate over them
{ 1 2 3 4 } [ println ] vec-each
# Prints
# 1
# 2
# 3
# 4

"abcd" [ println ] each-char
/* Prints
a
b
c
d
*/

# Dictionaries use strings for keys, and anything for values
<dict> dup :funnyNumbers
    # value <<-key
    # <<- takes the value, stores it at "key" in the dict, and leaves the dict on the stack
    "42" <<-answertolife
    "1337" <<-leet
    # <- works similarly to <<-, but doesn't leave the dict on the stack
    "DEADBEEF" <-debug

# $dict ->key
# takes the value at "key" from $dict, and puts it on the stack
$funnyNumbers ->leet println
# Prints

# $dict ->>key
# Takes the value at key, puts it on the stack,
# and leaves the dictionary at the top of the stack
#
# $dict ->key
# Same as ->>, but does not leave the dictionary
# at the top of the stack.
${ $funnyNumbers ->>answertolife ->debug } println

# Prints:
# "42DEADBEEF"


# TODO: More examples
</pre>
</nowiki>