Main /
LearnPhixInYMinutesCategories: documentation Learn Phix in Y Minutes Author: _tom Date: 24 Feb 2021 Draft of "Learn Phix in Y Minutes" in the style of https://learnxinyminutes.com/ Phix, because simpler is better.
Once you learn to use the ##sequence## data-type and you can program anything... -- 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 // 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 // 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)", { 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)", { 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 private 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 private 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; private 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.
|