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.