diff options
Diffstat (limited to 'phix.html.markdown')
| -rw-r--r-- | phix.html.markdown | 451 |
1 files changed, 451 insertions, 0 deletions
diff --git a/phix.html.markdown b/phix.html.markdown new file mode 100644 index 00000000..2a199edd --- /dev/null +++ b/phix.html.markdown @@ -0,0 +1,451 @@ +--- +language: Phix +contributors: + - ["pxtom", "https://gitgub.com/pxtom"] +filename: learnphix.exw +--- + +``` + -- single line comment + + // single line comment + + /* multi- + line comment */ + +// Start programming immediately + + -- write using UTF8; save as: hello.ex + -- use ? for output + + ? "😍 hello , 😎 world!" + ? sqrt(2+2) + +// Interpret your program + /* + p hello */ + +// Compile your program + /* + p -c hello */ + +// Coding mistakes receive gentle help messages + /* + string line + line = 5 + ^ type error (storing atom in string) */ + +// Every literal value, constant, and variable is an ''object'' + + -- a literal object + ? "hello" + ? PI + ? { "hello", PI } + + -- a named variable object + object X + X = "hello" + X = PI + X = { "hello", PI } + + -- a named constant object + constant myPI = 22/7 + +// Everything is an ''object'', just two fundemental kinds + /* + ┌────────────────────▄ + ┌─┤ object █─┐ + │ └─▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ │ + │ │ + "atom" "container" */ + + number x = 3.14159 sequence s = { "hello", PI } + integer y = 3 string txt = "hello" + + -- simplify, + -- and use only two primitives + number x1=3.14156, y1=3 + sequence s1={"hello",PI}, txt1="hello" + + -- simplify even more, + -- and use just one primitive + object x2=3.14156, y2=3, s2={"hello",PI}, txt2="hello" + +// Elegant data-type design + + -- invent your own "type" + -- organize with "struct" or "class" + /* + ╔═══════════════════════════════╗ + ║ ┌─────────────────────────┐ ║ + ║ │ ┌───────────▄ │ ║ + ║ │ ┌─┤ object █─┐ │ ║ + ║ │ │ └─▄▄▄▄▄▄▄▄▄▄█ │ │ ║ + ║ │ │ │ │ ║ + ║ │ number sequence │ ║ + ║ │ │ │ │ ║ + ║ │ integer string │ ║ + ║ └──────── type ───────────┘ ║ + ║ ║ + ╚════════ struct ║ + class ════════════════╝ + */ + +// Syntax is consistant: "keyword...end keyword" + + -- no invisible syntax or extra rules needed. + + // loop + -- while ... end while + + integer index = 1 + while index <= 5 do + ? index + index += 1 + end while + + // loop + -- for ... end for + + for i=5 to 1 by -1 do + ? i + end for + + // conditional + -- if ... end if + + number p = 4 + if p < 1 then + ? "p is a small number" + elsif p > 10 then + ? "p is a large number" + else + ? "p is inbetween" + end if + + // conditional + -- switch ... end switch + + object ch = prompt_string("enter one character: " ) + switch ch + case "a": ? "ch is a" + case "b": ? "ch is b" + case "c": ? "ch is c" + default: ? "ch is something else" + end switch + +// Operators are always consistant; never overloaded. + + -- the + operator ''always adds'' + ? 2+7 + ? 'A' + 32 + + -- the & operator ''always concatenates'' + ? 2 & 7 --> {2,7} + ? "cat" & " " & "dog" --> "cat dog" + ? {1,2,3} & "fish" --> {1,2,3} & "fish" + pp( {1,2,3} & "fish" ) --> {1,2,3,102'f',105'i',115's',104'h'} + +// Use ''sq_'' functions to span entire containers. + + ? sq_add( {1,2,3}, 10 ) --> {11,12,13} + ? sq_sqrt( {4,9,16} ) --> {2,3,4} + +// Functions must return a value + + function add2( number x, number y ) + number sum = x + y + return sum + end function + ? add2( 4, 9 ) + +// Procedures do not return a value + + procedure sum_all( sequence lst ) + number sum = 0 + for i=1 to length(lst) do + sum += lst[i] + end for + ? sum + end procedure + sum_all( {1,3,9,11} ) + +// Recursion and mutal recursion are permitted + + function factorial(number n) + if n == 0 then + return 1 + end if + if n<0 then + return "error, no negative numbers for factorials" + end if + return n * factorial(n - 1) + end function + ? factorial(5) + +// User defined data-types + + -- defined like a function: type ... end type + -- they are fully programmable; add your own features + + type positive( number x ) + if not integer(x) then + ? "use integers for factorials" + return False + end if + if x < 0 then + ? "error, no negative numbers for factorials" + return False + end if + return True + end type + + -- use them to declare variables and parameters + + function factorial2( positive n ) + if n == 0 then return 1 end if + return n * factorial2(n-1) + end function + ? factorial(5) + + -- to catch errors, and recover, use: try ... end try + + try + ? factorial2( -5 ) + catch e + ? "that was a mistake" + end try + +// Sequences are versatile + + -- multiple assignment + number a, b, c + {a,b,c} = { -100, -200/-2, -300*3 } + ? a --> -100 + ? b --> 100 + ? c --> -900 + + -- swapping values + ? a --> -100 + ? c --> -900 + {a,c} = {c,a} + ? a --> -900 + ? c --> -100 + + +// Symmetrical one-based indexing does it all + + -- both sequence and string are mutable and work alike + + -- 1 2 3 4 5 -- index head to tail + s = { 10, 20, 30, 40, 50 } + -- -5 -4 -3 -2 -1 -- index tail to head + + // one item + ? s[ 2] + ? s[-4] + -- output for both is: + -----> 20 + + // slice with one item + ? s[ 2.. 2] + ? s[-4..-4] + -- output for both is: + -----> {20} + + // inclusive slice + ? s[ 2.. 4] + ? s[-4..-2] + -- output for both is: + -----> {20,30,40} + + // empty sequence + ? s[3 .. 2] + ? s[-3..-4] + -- output for both is: + -----> {} + + // insert + s[3..2] = {99} + ? s + -----> {10,20,99,30,40,50} + + // prepend and append + s = { 10,20,30,40,50 } + + s[ 1..0] = {0} -- prepend + s[$+1..$] = {6} -- append + + ? s + -----> {0,10,20,99,30,40,50,6} + + s[0..-1] = {9999} -- append + + ? s + -----> {0,10,20,99,30,40,50,6,9999} + + // delete + s = { 10,20,30,40,50 } + + s[2..2] = {} -- item deleted + ? s + -----> {10,30,40,50} + + s[2..3] = {} -- slice deleted + ? s + -----> {10,50} + +// Learn and reuse; you keep what you learn. + + s = { 1,3,5,7 } + txt = "jello" + + -- "find" locates one item in either a sequence or a string + ? find( 3, s ) --> 2 + ? find( 'e', txt ) --> 2 + + -- "match" locates a slice in either a sequence or a string + ? match( {5,7}, s ) -- > 3 + ? match( "ll", txt ) --> 3 + +// Look back at the examples, Phix is generic! + +// Batteries are installed + + ? sort( {2, 54,6,4, 0} ) + ? upper( "cat" ) + ? log( 10.4 ) + ? trunc(1.4) -- 1 + ? floor(1.4) -- 1 + ? trunc(-1.4) -- -1 + ? floor(-1.4) -- -2 + +// Batteries are included + + include builtins/regex.e + + string str = "say hello and smile" + str = gsub( `s...e`, str, "😍" ) + ? str --> "say hello and 😍" + +// Yes, sequences are "powerful" + + function odd(integer a) return remainder(a,2)=1 end function + function even(integer a) return remainder(a,2)=0 end function + + ? tagset(10) --> {1,2,3,4,5,6,7,8,9,10} + ? filter(tagset(10),odd) --> {1,3,5,7,9} + ? filter(tagset(10),even) --> {2,4,6,8,10} + +// A ''struct'' provides named fields, type-checking, and dot notation + + struct point + number x = 0 + number y = 0 + end struct + + procedure show( point q ) + printf(1, "(%g,%g)", { q.x, q.y } ) + end procedure + + point p1 = new() + show(p1) + --> (0,0) + + p1.x = 3 + p1.y = 5 + show( p1 ) + --> (3,5) + +// A ''class'' adds methods and scope control + + class pair + public number x = 0 + public number y = 0 + + procedure show( ) + printf(1, "(%g,%g)", { this.x, this.y } ) + end procedure + end class + + pair p2 = new() + p2.show() + --> (0,0) + + p2.x = 3 + p2.y = 5 + p2.show() + --> (3,5) + +// Inherit and compose + + class Pair -- any 2 objects + public sequence xy + public integer x,y + function get_x() + return xy[1] + end function + + function get_y() + return xy[2] + end function + end class + + type pos_seq(sequence x) + return min(x) >= 0 + end type + + class Point extends Pair + public pos_seq loc -- any two numbers >= 0 + + procedure set_loc(object x) + this.xy = {x[1],x[2]} + end procedure + end class + + class Rectangle extends Point + public Point tlc,brc --top_left, bottom_right corners; + public sequence size + + function get_size() + this.size = {brc.x-tlc.x , brc.y-tlc.y} + return this.size + end function + end class + + Point p1a = new() p1a.loc = {50,10} + Point p2a = new() p2a.loc = {300,200} + + Rectangle r = new() + r.tlc = p1a + r.brc = p2a + ? r -- {"struct","Rectangle",4,1} + ? r.tlc -- {"struct","Point",3,3} + + ? r.size --> {250,190} + ? r.get_size() --> {250,190} +``` + +Phix does not (although most can be emulated) directly support +operator|builtin|function overloading, lambda expressions, closures, +currying, eval, partial function application, function composition, +function prototyping, monads, generators, anonymous recursion, +the Y combinator, aspect oriented programming, interfaces, delegates, +first class environments, implicit type conversion +(of the destructive kind), interactive programming, inverted syntax, +list comprehensions, metaprogramming, pointers +(other than to raw allocated memory), topic variables, +enforced singletons, safe mode, s-expressions, +or formal proof construction. + +The author wryly comments: + +''That should both scare off and attract the right people''. + + +## References + +* [http://phix.x10.mx](http://phix.x10.mx) +* [Source code](https://github.com/petelomax/Phix) +* [Forum](https://openeuphoria.org/forum/index.wc) +* [Rosetta Code](https://rosettacode.org/wiki/Category:Phix) |