ParScript

ParScript is an esoteric programming language designed for the purpose of code golf. An interpreter is in the process of being made.

Description
ParScript is a simple stack-based language that enables writing of concise (and unreadable) code. It has a wide selection of library functions for manipulation of data. A notable feature is that arithmetic operations work on scalars as well as lists (like in APL).

Syntax
Here is a simplified (BNF-like) syntax. Prog ::= Exp* Exp  ::= Lit | Id | Sp Lit   ::= Num | Str | Blk | Sym Str  ::= "(" .* ")" with match parens Sym  ::= "'". Blk  ::= "[" Prog "]" Num  ::= Digit+ ["." Digit+] ["e" ["+"|"-"] Digit+] Id   ::= Alpha+ ["+"|"*"|"'"] Sp   ::= regex \s+ Digit ::= regex \d Alpha ::= regex [a-zA-Z]

Example programs
A few example programs are given below.

Hello world program
(Hello, world! )p

(or, if you wish, you can use the library function)` H

nCr program
(usage: N1 N2 ncr; assume N1,N2 >0) (The ncr function is given as the number of ways to select r objects from a set of n unique objects if order is not  important. It is given as ncr(n,r)=n!/r!(n-r)! where ! is  the factorial function.)` (The factorial function is not defined in the standard library, though it is easily defined as [i f*].)`

(ncr1)[\\-i@i@i@&/f*]d (ncr2)[\i@\~-i~i&/f*]d

Library functions
A list of library functions is given below. This is by no means an exhaustive list.

Stack manipulation
` pop     ( a -- )           ~  swap      ( a b -- b a ) $ dup     ( a -- a a )       \  over      ( a b -- a b a ) @ rot     ( a b c -- c a b ) :  nil       ( -- : )

List manipulation
. cons    ( y x -- x:y)     ,  uncons    ( x:y -- y x ) & append  ( l1 l2 -- l3 )    #  index     ( l n -- x ) { begin   ( -- { )           }  end       ( { ... -- l ) S sort    ( l -- l )         J  jumble    ( l -- l ) l length  ( l -- n )

Control flow
? ifthen  ( c f1 f2 -- )     I  if        ( c f1 -- ) w while   ( c f -- )         ! call/eval ( x -- ??? )

Higher-order functions
m map     ( l f -- l' )      g  grep      ( l f -- l' ) f fold    ( l x f -- x' )    A  all       ( l f -- b  ) O any     ( l f -- b )

Arithmetic
Arithmetic functions are versatile, they either work on pairs of numbers (the usual interpretation), on one number and one list (a map) or two lists (a zipWith). For example: 1 2 *             ==> 2 1 {2 3 4}*         ==> {2 3 4} {1 2 3} 4*         ==> {4 8 12} {1 2 3} {4 5 6}*   ==> {4 10 18} {1 2}   {4 5 6}*   ==> {4 10}   (truncated due to lack of elements) The arithmetic functions are: + add      ( a b -- a+b )     -  subtract  ( a b -- a-b ) * multiply ( a b -- a*b )     /  divide    ( a b -- a/b ) ^ power    ( a b -- a^b )     %  mod       ( a b -- a%b ) _ negate   ( a   -- -a  )

Turing-completeness
The author suspects that this language can be Turing-complete by reduction from Brainfuck, but has not yet come up with a suitable reduction.