# 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.