Announcing Picat, the next scripting language after Python

[neng.zhou at gmail.com]

We are pleased to announce the launch of the Picat system on

             picat-lang.org. 

Picat is a simple, and yet powerful, logic-based multi-paradigm
programming language aimed for general-purpose applications. Picat is
a rule-based language, in which predicates, functions, and actors are
defined with pattern-matching rules. Picat incorporates many
declarative language features for better productivity of software
development, including explicit non-determinism, explicit
unification, functions, list comprehensions, constraints, and
tabling. Picat also provides imperative language constructs, such as
assignments and loops, for programming everyday things. The Picat
implementation, which is based on a well-designed virtual machine and
incorporates a memory manager that garbage-collects and expands the
stacks and data areas when needed, is efficient and scalable. Picat
can be used for not only symbolic computations, which is a
traditional application domain of declarative languages, but also for
scripting and modeling tasks. 

Example 1: The following predicate, input_data(Tri), reads rows of
integers from the text file "triangle.txt" into an array. This is the
first part of a Picat solution for the Euler Project, problem #67
(picat-lang.org/projects.html).

import util.

input_data(Tri) => 
    Lines = read_file_lines("triangle.txt"),
    Tri = new_array(Lines.length),
    I = 1,
    foreach(Line in Lines)
        Tri[I] = Line.split().map(to_integer).to_array(),
	I := I+1
    end.

The function read_file_lines/1, which is imported by default from the
io module, reads all of the lines from a file as a list of strings.
For each Line in Lines, the foreach loop splits Line into tokens
(using the function split/1, which is imported from the util module),
maps the tokens to integers (map(to_integer)), and converts the list
to an array (to_array). As illustrated in this example, Picat, as a
scripting language, is as powerful as Python and Ruby.

Example 2: Given a triangle stored in an array, the following tabled
predicate finds the maximum total sum from top to bottom. This is the
second part of the Picat solution for the Euler Project, problem #67.

table (+,+,max,nt) 
path(Row,Col,Sum,Tri),Row==Tri.length => Sum=Tri[Row,Col].
path(Row,Col,Sum,Tri) ?=> 
    path(Row+1,Col,Sum1,Tri),
    Sum = Sum1+Tri[Row,Col].
path(Row,Col,Sum,Tri) => 
    path(Row+1,Col+1,Sum1,Tri),
    Sum = Sum1+Tri[Row,Col].    
    Sum = Sum1+Tri[Row,Col].    

The first line is a table mode declaration that instructs the system
about how to table the calls and answers: '+' means that the argument
is tabled, 'max' means that the argument should be maximized, and
'nt' means that the argument is not tabled. This predicate searches
for a path with the maximum total sum. If the current row is at the
bottom of the triangle, then the leaf value is returned. Otherwise,
it makes a non-deterministic choice between two branches, one going
straight down and the other going down to the adjacent number. This
program is not only compact, but also runs fast. For the 100-row
triangle that is provided by the Euler project, this program finds
the answer in only 0.01 second.

Example 3: The following example models the N-queens problem by using
three all_different constraints. 

import cp.

queens3(N, Q) =>
    Q = new_list(N),
    Q in 1..N,
    all_different(Q),
    all_different([$Q[I]-I : I in 1..N]),
    all_different([$Q[I]+I : I in 1..N]),
    solve([ff],Q).

List comprehensions are used to specify lists. The expressions that
are preceded with a dollar sign denote terms rather than function
calls. This program uses the CP solver. If the sat module is imported
instead of cp, then the SAT solver will be used (and the ff option
will be ignored).

As demonstrated by the three examples, Picat offers many advantages
over other languages. Compared with functional and scripting
languages, the support of explicit unification, explicit
non-determinism, tabling, and constraints makes Picat more suitable
for symbolic computations. Compared with Prolog, Picat is arguably
more expressive and scalable: it is not rare to find problems for
which Picat requires an order of magnitude fewer lines of code to
describe than Prolog and Picat can be significantly faster than
Prolog because pattern-matching facilitates indexing of rules. 

Picat can be used for any fair purpose, including commercial
applications. The C source code will be made available to registered
developers and users free of charge. Please keep tuned.

Sincerely,

Neng-Fa Zhou
Jonathan Fruhman
Hakan Kjellerstrand