A domain-specific language (DSL) is a programming language or executable specification language that offers, through appropriate notations and abstractions, expressive power focussed on, and usually restricted to, a particular problem domain.

Arie van Deursen, Paul Klint, and Joost Visser. Domain-Specific Languages: An Annotated Bibliography. ACM SIGPLAN Notices, 35(6):26–36, 2000.

:- op(700, xfx, are).
mammals are animals.
elephants are mammals.
tigers are mammals.
As are Cs :- Bs are Cs, As are Bs.

?- are(What, animals).
What = mammals ;
What = elephants ;
What = tigers ;
% wait forever

?- mammals are animals,
   elephants are mammals, tigers are mammals.
tigers are animals,
tigers are mammals,
elephants are animals,
elephants are mammals,
mammals are animals.

As are_somehow Bs :- As are Bs.
As are_somehow Cs :- As are Bs, Bs are_somehow Cs.

:- use_module(library(chr)).
:- chr_constraint are/2.
As are Bs, Bs are Cs ==> As are Cs.

:- table are/2.
As are Cs :- As are Bs, Bs are Cs.

As are Cs :-
  As are Bs,
  Bs are Cs.

Dicts

% Tag{ Key1: Value1, Key2: Value2, ... }
% person(1, [firstName='Alice', birth=1986]).
% person(1, _{ firstName: 'Alice', birth: 1986 }).
%
% Usage:
% - Dict.Key
% - Dict.get(Key) with +Dict.get(?Key)
% - Unification via :< (is a subset of)
% - Unification via >:< (all keys appear in both and unify)
%
% Note: breaks with classical list notation via ./2

?- p{ a: 1, b: 2 } = P{ a: A, b: B }.
P = p, A = 1, B = 2 .

?- p{ a: 1, b: 2 } = P{ a: A }.
false .

?- P{ a: A } :< p{ a: 1, b: 2 }.
P = p, A = 1 .

?- p{ a: 1, b: 2 } :< P{ a: A }.
false .

?- p{ a: 1, b: 2 } >:< P{ a: A, c: 3 }.
P = p, A = 1 .

Attributed Variables: Motivation

?- domain(Prec, [600, 601, 602], D0),
domain(D0, [603, 604], D1).
false .

?- domain(Prec, [600, 601, 602], D0),
   domain(D0, [601, 602, 603, 604], D1).
D0 = var_candidates(Prec, [600, 601, 602]),
D1 = var_candidates(Prec, [601, 602]) .
% Prec remains free as there are multiple
%   solutions in D1

?- domain(Prec, [600, 601, 602], D0),
   domain(D0, [602, 603, 604], D1).
Prec = 602,
D0 = var_candidates(602, [600, 601, 602]),
D1 = var_candidates(602, [602]) .

%% domain(+Term, +Ordset, -Domain)
domain(Prec, Ordset, var_candidates(Prec,Ordset)) :-
  var(Prec), !,
  test_for_single(Prec, Ordset).
domain(var_candidates(Prec,L0), Ordset,
    var_candidates(Prec,LN)) :-
  ord_intersection(L0, Ordset, LN),
  test_for_single(Prec, LN).

%% test_for_single(-Var, +List)
% empty list: inconsistency
test_for_single(_, []) :- !, false.
% single element: bind
test_for_single(Prec, [Prec]) :- !.
% otherwise: continue
test_for_single(_, _).

Attributed Variables

?- put_attr(X, some, 1), put_attr(X, other, 2).
put_attr(X, some, 1),
put_attr(X, other, 2) .

?- domain(Prec, [600, 601, 602]),
   domain(Prec, [601, 602, 603]).
Prec in [601, 602] . % 601..602

%% domain(+Term, +Ordset)
domain(Prec, Ordset) :-
  put_attr(Y, candidates, Ordset), Prec = Y.

attr_unify_hook(Domain, Y) :-
  ( get_attr(Y, candidates, Domain_Y) ->
    % Y is an attributed variable in the same module
    ord_intersection(Domain, Domain_Y, New_Domain),
    put_attr(Y, candidates, New_Domain),
    test_for_single(Y, New_Domain)
  ; var(Y) ->
    % Y is a variable, possibly with attributes in other modules
    put_attr(Y, candidates, Domain)
  ; otherwise ->
    % Y is not a variable
    ord_memberchk(Y, Domain) ).

:- op(500, xfy, in).
attribute_goals(X, [X in Domain|Rest], Rest) :-
  get_attr(X, candidates, Domain).

Constraint Logic Programming over Finite Domains (CLPFD)

?- use_module(library(clpfd)). % load CLP(FD)
true .

?- 601 #=< Prec, Prec #=< 603.
Prec in 601..603 .

?- 601 #=< Prec, Prec #=< 603, label([Prec]).
Prec = 601 ;
Prec = 602 ;
Prec = 603 .

arg --> { P #< 1000 }, term(P).

• Library dcg4pt

DCG Extension...

• Library dcg4pt

Library dcg4pt's Internals

• Library dcg4pt

Sequences and Optionals in Library dcg4pt

Program Transformations via Term Expansions

1. Handling of conditional compilation directives.

   :- if(Goal).
   % platform dependent code
   :- endif.

2. Execution of user-defined term expansions.

   % term_expansion(+Term1,-Term2)

3. Call expansion for DCGs.
4. Execution of goal expansions in all rule bodies.

   % goal_expansion(+Term1,-Term2)

Quasi-Quotations

% {|Tag||Content|}
:- use_module(library(quasi_quotations)).
:- quasi_quotation_syntax(TagName).
TagName(+ContentHandle,+SyntaxArgs,+Vars,-Result) :- % ...
  % ... user-defined processing of the content to create Result
  % usually based on a grammar, for instance DCGs
  %
  % - Tag =.. [TagName|SyntaxArgs], length(SyntaxArgs, TagArity)
  % - ContentHandle is an opaque term that carries the content of the
  %   quasi-quoted text and position information about the source code and its layout
  % - Vars provides access to variables of the quasi-quotation's outside-world context.
  %
  % phrase_from_quasi_quotation/2
  %
  % {|html(doc)||<p>Hello, Name!</p>|} becomes
  % html('<p>Hello, Name!</p>', [doc], ['Name' := 'Alice'], Result)

• Library plammar
• Parse Tree Example
• AST Example

%% append(?List1, ?List2, ?List1_then_List2)
append([], Y, Y).
append([E|X], Y, [E|Z]) :-
  append(X, Y, Z).

• Library plammar
• Tokenisation Example
• AST Example

%% append(?List1, ?List2, ?List1_then_List2)
append([], Y, Y).
append([E|X], Y, [E|Z]) :-
  append(X, Y, Z).

• Library plammar
• Tokenisation Example
• Parse Tree Example

%% append(?List1, ?List2, ?List1_then_List2)
append([], Y, Y).
append([E|X], Y, [E|Z]) :-
  append(X, Y, Z).

• Library plammar

• Paper
• Results Community Analysis

Implemented Covington Rules

• Paper

Community Evaluation of Adherence to Covington

Community Evaluation of Adherence to Covington (cont.)

Example II: infer_operators

plammar's Options

• ops: [op(...), ...]
• infer_operators: possibly open list
• All language extensions, e.g. allow_unicode
• targets: [iso, swi, swi(8), swi(7), swi(6), swi(5)]
• style:
  • indent
  • max_rule_lines
  • max_subgoals
  • max_line_length
  • All allow_* language extensions, e.g. digit_groups

Integration of plammar into AST Explorer

• Library plammar
• Tokenisation Example
• Parse Tree Example

plammar's Finite-State Machine for Numbers

• Context in Plammar

Reasons for plammar's Finite-State Machine

Context Matters: Conditions in ISO

%% "A token shall not be followed by characters such that
%%   concatenating the characters of the token with these
%%   characters forms a valid token as specified by the above
%%   Syntax." (6.4)
token(In, Out) :-
  token_(In, Out),
  ( % empty rest list
    Out = []
  ; Out = [_One_More_Element|Rests],
    % consuming one element does not succeed
    \+ token_(In, Rests) ).

Achieving Logical Purity in plammar

%% call_sequence_ground(DCGBody, Ref, Rest, PTs, A, Z)
:- meta_predicate call_sequence_ground(//, ?, ?, ?, ?, ?).
call_sequence_ground(DCGBody, V, V1, V0, A, Z) :-
  nonvar(V0), !, % parse tree bound
  append(V, V1, V0),
  phrase(DCGBody, A, Z).
call_sequence_ground(DCGBody, V, V1, V0, A, Z) :-
  ( nonvar(A) % difference list bound
  ; attvar(A), get_attr(A, pure_input, _PIO)), !, % or lazy list
  phrase(DCGBody, A, Z),
  append(V, V1, V0).

Language Extensions: Examples

:- set_prolog_flag(
     allow_variable_name_as_functor, true).
:- op(1000, xfy, ∧).
:- op(1100, xfy, ∨).
:- op(1200, xfx, ←).

Path(a, c) ← Edge(a, c) ∨ Edge(a, b) ∧ Path(b, c).

:- set_prolog_flag(
     allow_variable_name_as_functor, true).
:- op(100, xf, {}).
:- op(100, xf, []).
:- op(500, xf, ;).
:- op(600, xfx, ∈).
:- op(600, fx, while)
:- op(500, fx, function).

function print_list_of_lists() {
  while (X ∈ [[a, b], [1, 2, 3]]) {
    writeln(LENGTH(X));
    writeln(X[0]);
  }
}.

Language Extensions: Tokenisation Level

Language Extensions: Parsing Level

• allow_infix_and_postfix_op
• allow_compounds_with_zero_arguments: a()
• allow_empty_atom: ()
• allow_curly_block_op: a { b }
• allow_square_block_op: a [ b ]
• dicts: some{ key: value }
• allow_operator_as_operand
• allow_arg_precedence_geq_1000
• allow_variable_name_as_functor: Hello(World)
• allow_unquoted_comma: a(,, ,)
• allow_dot_in_atom: tigers are.somehow animals
• allow_implicit_end

GraphQL: Query Example

GraphQL: Type Definitions

type Query {
  person(name: String!): Person,
  book(title: String!): Book,
  books(filter: String): [Book]
}

type Book {
  title:   String!,
  authors: [Person]
}

type Person {
  name: String!,
  age: Integer,
  friends: [Person],
  books(favourite: Boolean): [Book]
}

:- use_module(library(quasi_quotations)).
:- quasi_quotation_syntax(type).
type(ContentHandle, _SyntaxArgs, Vars, Res) :-
  phrase_from_quasi_quotation(gql_type(Vars, Res), ContentHandle).

gql_type(Env, Type) -->
  #, type_definitions(Env, Definitions), #,
  { Type = object{}.put(description, _).put(fields, Definitions) }.

type_definitions(Env, Definitions) --> % base case
  type_definition(Env, Name, Type),
  { Definitions = _{}.put(Name, Type) }.
            

• 50 nonterminals to parse queries
• Entire DCG more than 600 LOC

GraphQL: Prolog Resolvers

?- Person = {|type|| friends: [Person], ... |}.
Person = object{
  fields: _{
    name: field{ type: string, nonNull: true, resolve: _ },
    age: field{ type: integer, resolve: _ },
    friends: list{ kind: field{ type: Person }, resolve: _ },
    books: list{
             arguments: _{ favourite: field{ type: boolean } },
             kind: field{ type: Book }, resolve: _ },
  },
  resolve: _ % not yet bound
}

GraphQL as an Internal DSL

:- set_prolog_flag(var_prefix, true).
:- op(100, fx, type), op(600, xfy, :).
:- op(500, xf, !).   % allow_operator_as_operand
:- op(400, xfy, {}). % allow_curly_block_op
:- op(200, xf, {}).  % allow_infix_and_postfix_op
schema(_schema) :- _schema =
    type Query {
      person(name: String!): Person,
      book(title: String!):  Book,
      books(filter: String): [Book]
    }
    type Book {
      title:   String!,
      authors: [Person]
    }
    type Person {
      name:    String!,
      age:     Integer,
      books(favourite: Boolean): [Book],
      friends: [Person]
    }.

?- schema(_s), write_canonical(_s).
{}({ ','(:(person(:(name, !(String))), Person),
','(:(book(:(title, !(String))), Book), ...

Vanilla Meta-Interpreter

%% mi(:Goal)
mi(true).                    % for facts
mi((A , B)) :- mi(A), mi(B). % conjunction
mi(A ; B) :- mi(A) ; mi(B).  % disjunction
mi(A = B) :- A = B.          % unification
mi(A) :-
  A \= true, A \= (_ , _), A \=
  clause(A, B),
  mi(B).

Meta-Interpreter for If-then-Rules

%% mi(:Goal)
mi(true).                    % for facts
mi(A and B) :- mi(A), mi(B). % conjunction
mi(A or B) :- mi(A) ; mi(B). % disjunction
mi(A = B) :- A = B.          % unification
mi(A) :-
  A \= true, A \= (_ = _),
  ( clause(A, B)      % there is a Prolog clause A :- B
  ; (if B then A) ),  % or there is a fact then(if(B),A)
  mi(B).