10-if.pnx

use io
word sign (n int gives str) n 0 lt if "negative" else n 0 eq if "zero" else "positive" end end end
-5 sign io.println
0 sign io.println
word warn (n int) n 100 gt if "big" io.println end end      rem no else: the branch leaves the stack as it was
500 warn

출력

$ pnx 10-if.pnx
negative
zero
big

10-loop.pnx

use io
use str
word digits (n int gives int)            rem how many decimal digits
  1 to count_
  loop
    n 10 div to n
    n 0 eq until
    count_ 1 add to count_
  end
  count_
end
12345 digits str.to_str io.println
word first_square_over (limit int gives int)
  1 to i
  loop
    i i mul limit gt if break end
    i 1 add to i
  end
  i
end
50 first_square_over str.to_str io.println

출력

$ pnx 10-loop.pnx
5
8

10-loop-named.pnx

use io
use str
word find_pair (target int gives str)      rem the first a, b in 1..9 with a*b = target
  1 to a
  0 to b
  loop (rows)
    1 to b
    loop
      a b mul target eq until (rows)       rem leaves both loops at once
      b 1 add to b
      b 9 gt until
    end
    a 1 add to a
    a 9 gt if "none" return end
  end
  cat (a, " x ", b)
end
42 find_pair io.println

출력

$ pnx 10-loop-named.pnx
6 x 7

10-forever.pnx

use io
use str
word first_multiple (n int, k int gives int)     rem a loop with no exit counts as leaving
  loop
    n k mod 0 eq if n return end
    n 1 add to n
  end
end
100 7 first_multiple str.to_str io.println

출력

$ pnx 10-forever.pnx
105

10-case.pnx

use io
const quit_code 9
word describe (cmd str gives str)
  cmd case
    "add" of "adds a line" end
    ("rm", "del") of "deletes a line" end
    otherwise "unknown command" end
  end
end
word level (n int gives str)
  n case
    0 of "off" end
    1 of "low" end
    quit_code of "quit" end
    otherwise "high" end
  end
end
"del" describe io.println
"mv" describe io.println
9 level io.println

출력

$ pnx 10-case.pnx
deletes a line
unknown command
quit

10-inline-locals.pnx

use io
use str
word total_over (limit int gives int)
  0 to acc
  1 10 range do (i int) i limit gt if acc i add to acc end end each   rem the block sees acc and limit
  acc
end
5 total_over str.to_str io.println

출력

$ pnx 10-inline-locals.pnx
30

10-value-block.pnx

use io
use str
word twice (n int, f word (int gives int) gives int) n f call f call end
5 do (x int gives int) x 3 mul end twice str.to_str io.println
word add_one (int gives int) 1 add end
word demo (gives int)
  do (x int gives int) x add_one end to step     rem a block value in a local
  41 step call
end
demo str.to_str io.println

출력

$ pnx 10-value-block.pnx
45
42

10-word-value.pnx

use io
use str
word by_len (a str, b str gives bool) a str.len b str.len lt end
word shorter (f word (str, str gives bool), a str, b str gives str) a b f call if a else b end end
word demo ()
  do by_len end to order                          rem the word by_len itself: word (str, str gives bool)
  cat ("shorter: ", order "pear" "fig" shorter) io.println
  do (str, str gives bool) str.starts_with end to starts    rem a word of the language, with its signature
  "banana" "ban" starts call if "starts with ban" io.println end
end
demo

출력

$ pnx 10-word-value.pnx
shorter: fig
starts with ban

10-combinators.pnx

use io
use str
array scores int 6
assign scores (72, 95, 88, 61, 90, 79)
scores sum str.to_str io.println
scores do (s int gives bool) s 90 ge end count str.to_str io.println
scores do (s int gives bool) s 60 lt end any if "someone failed" else "all passed" end io.println
0 scores do (acc int, s int gives int) acc s max end fold str.to_str io.println
scores do (s int, i int) i 2 lt if cat ("#", i, " ", s) io.println end end each_index
1 5 range do (i int) i str.to_str io.print end each
"" io.println
3 do "x" io.print end times
"" io.println

출력

$ pnx 10-combinators.pnx
485
2
all passed
95
#0 72
#1 95
1234
xxx

10-first.pnx

use io
use str
array xs int 5
assign xs (3, 8, 12, 5, 20)
xs do (x int gives bool) x 10 gt end first or_else (e) -1 end str.to_str io.println
xs do (x int gives bool) x 100 gt end first or_else (e) -1 end str.to_str io.println
xs minimum or_else (e) 0 end str.to_str io.println

출력

$ pnx 10-first.pnx
12
-1
3

10-map-into.pnx

use io
use str
array xs int 4
assign xs (1, 2, 3, 4)
list squares int 4
array evens int 4
word go (or fail)
  xs do (x int gives int) x x mul end squares map_into or_fail
  xs do (x int gives bool) x 2 mod 0 eq end evens filter_into or_fail to n
  cat ("squares ", 3 squares idx, ", evens written ", n) io.println
end
go or_else (e) e err_text io.println end

출력

$ pnx 10-map-into.pnx
squares 16, evens written 2

10-leave-each.pnx

use io
use str
word until_blank (s str)
  s str.lines do (line str)
    line str.len 0 eq if break end
    cat ("> ", line) io.println
  end each
  "done" io.println
end
"first\nsecond\n\nnot read" until_blank

출력

$ pnx 10-leave-each.pnx
> first
> second
done

10-defer.pnx

use io
use str
buffer trace 256
word say (s str) s trace append or_else (e) end end
rem Every way out of a block runs its defers, the last written first.
word step (n int or fail)
  "open " say
  defer "close " say end
  defer "flush " say end
  n 0 lt if err.range fail end
  "work " say
end
1 step or_else (e) end
-1 step or_else (e) "(failed) " say end
trace contents str.trim io.println

출력

$ pnx 10-defer.pnx
open work flush close open flush close (failed)

10-defer-owned.pnx

use io
use str
buffer report 4096
rem A mark taken back at the end of every turn, also when append fails.
word build (or fail)
  1 50 range do (i int)
    mark to m
    defer m release end
    cat ("row ", i, ": ", i i mul, "\n") report append or_fail
  end each
end
build or_else (e) cat ("full: ", e err_text) io.println end
cat ("report: ", report len, " bytes") io.println

출력

$ pnx 10-defer-owned.pnx
report: 585 bytes

10-statements.pnx

use io
word show (n int)
  cat ("square: ", n n mul) io.println .
end
"start" io.println ,
3 show ,
4 show .

출력

$ pnx 10-statements.pnx
start
square: 9
square: 16