++ed by:
Steven Haryanto

NAME

Language::Expr::Manual::Syntax - Description of the Language::Expr language

VERSION

This document describes version 0.23 of module Language::Expr::Manual::Syntax (in distribution Language-Expr), released on 2014-05-01.

OVERVIEW

Language::Expr language is very simple. It has just enough features to support mathematical/logical/string operations, arrays, hashes, variables, and function calls.

Language::Expr is (intentionally) not Turing-complete (lacks assignment and loops).

Language::Expr is a lot like Perl. Differences from Perl, if any, are given after each section.

It should be trivial to implement an interpreter or code generator from the parser. In fact, Language::Expr is meant to be easily convertible to Perl, PHP, and Javascript (among others like Python and Ruby).

LITERALS

Undefined value

 undef

Boolean

 true
 false

Differences from Perl: Perl doesn't support native booleans, but there are modules like boolean which practically make Perl behaves like it does.

Number

 1
 -2.3
 inf
 nan
 0x1f    # hexadecimal, = 31 in decimal
 0o17    # octal, = 15 in decimal
 0b100   # binary, = 4 in decimal

Differences from Perl: octal literals in Expr are written using the less error-prone 0o123 syntax, which is also adopted by Python.

String

Single-quoted strings, e.g. 'single quoted'. Supported escape sequences:

 \'    literal single quote
 \\    literal backslash

Double-quoted strings, e.g. "double quoted". Supported escape sequences:

 \'    literal single quote
 \"    literal double quote
 \\    literal backslash
 \$    prevent variable interpolation
 \t    tab
 \n    newline
 \r    linefeed
 \f    formfeed
 \b    backspace
 \a    bell
 \e    escape

 \0 or \03 or \033    octal char
 \x7 or \x7B          hex char
 \x{263a}             wide hex char

Double-quoted strings will also interpolate variables, e.g.:

 "I have $num apples"
 "This is Foo::Bar version ${perl:/Foo/Bar/VERSION}"

Differences from Perl: Perl supports a few other escape sequences, but they are not commonly found in other scripting languages (e.g.: named Unicode character or the \l, \L, et al), so they are not included.

Array

 []
 [1, 2, "str"]

Differences from Perl: dangling comma at the end is not allowed in Expr.

Hash

 {}
 {a => 1, "b c" => 2+3}

Differences from Perl: in Expr you must always use "=>" to separate key and value, not comma. Dangling comma at the end is not allowed.

OPERATORS

Many operators are taken from Perl, along with their precedence levels and associativity, but here are the differences:

  • No assigment operators.

    Because assignment is deliberately not supported.

  • No smart-match "~~" operator or the other more esoteric or Perl-specific operators.

    These include Perl's "..", "...", "->", etc.

  • Currently no "and", "or", "not" operators.

    Use &&, ||, ! instead. Perl supports an extra, low-precedence set of logical operators mostly to separate statements, which we do not have anyway.

  • "xor" becomes "^^" (to be consistent with "^" as bitwise-xor).

  • Hash value is accessed using [] instead of {}, and barewords (e.g. $hash[key] instead of $hash["key"]) are not allowed.

    Which, BTW, is also the way it is done in Python, Ruby, and PHP.

  • Comparison operators can be chained (except <=> and cmp).

    Example:

     1 < 2 < 3       # true
     2 == (1+1) != 2 # false

Below is list of supported operators, ordered from lowest precedence, along with their associativity.

 left     =>
 left     || // ^^
 right    ?:
 left     &&
 left     | ^
 left     &
 left     == != <=> cmp eq ne < > <= >= ge gt le lt
 nonassoc <=> cmp
 left     << >>
 left     + - .
 left     * / % x
 right    ! ~ unary+ unary-
 right    **
 left     subscript (hash[s], array[i])
 left     term (variable, str/num literals, (paren), func())

Pair

 left     =>

Logical or, defined-or, logical xor

 left     || // ^^

Ternary operator

 right    ?:

Logical and

 left     &&

Bitwise or, bitwise xor

 left     | ^

Bitwise and

 left     &

Comparison operators

 left     == != <=> cmp eq ne < > <= >= ge gt le lt

Tri-valued comparison

 nonassoc <=> cmp

Bitwise shift left & right

 left     << >>

Numeric addition, subtraction, string concatenation

 left     + - .

Numeric multiplication, division, modulus, string repetition

 left     * / % x

Logical not, bitwise not, unary plus, unary minus (numeric negation)

 right    ! ~ unary+ unary-

Numeric power

 right    **

Hash and array subscript

 left     subscript (hash[s], array[i])

Term

 left     term (variable, str/num literals, (paren), func())

VARIABLES

There are two syntax for variables:

 $alphanum123 (including $_)
 $package::separated::var

and:

 ${anything goes except closing curly brace}

Differences from Perl: In Expr there is just $scalar, no @array or %hash or others. There are no special variables with funny names ($., $$, etc), but if they are enclosed with curly braces they are allowed (e.g. ${.}, ${name/contains/slashes}). In fact, the curly braces syntax allows the compiler/interpreter a greater freedom of defining the namespace scheme aside from the Perl-like double-colon syntax, e.g.:

 # Unix-path-like
 ${../foo}
 ${/foo/bar/baz}

 # volume:path (or URL-like)
 ${schema:/foo/bar/baz}
 ${data:../../baz}

FUNCTIONS

Examples:

 rand()
 length("foo")

Differences from Perl: parentheses are required in Expr.

The language define just a few functions:

map({ EXPR }, ARRAY) -> RESULT_ARRAY

This is similar to Perl's map() (but notice the required parentheses), it will form a new array composed from the result of EXPR. EXPR will be evaluated for each element of ARRAY (stored in $_). The original value of $_ will be restored after EXPR completes.

grep({ EXPR }, ARRAY) -> RESULT_ARRAY

This is similar to Perl's grep() (but notice the required parentheses), it will form a new array composed from the elements of ARRAY when EXPR evaluates to true (like in Perl, empty string '', the number 0, boolean false, undef are considered false). EXPR will be evaluated for each element of ARRAY (stored in $_). The original value of $_ will be restored after EXPR completes.

usort({ EXPR }, ARRAY) -> RESULT_ARRAY

This is similar to Perl's sort() (but notice the required parentheses), it will return the ARRAY sorted using comparison in EXPR. EXPR will be evaluated for each element of ARRAY ($a and $b will be set with two values to be compared). The original value of $a and $b will be restored after EXPR completes.

HOMEPAGE

Please visit the project's homepage at https://metacpan.org/release/Language-Expr.

SOURCE

Source repository is at https://github.com/sharyanto/perl-Language-Expr.

BUGS

Please report any bugs or feature requests on the bugtracker website https://rt.cpan.org/Public/Dist/Display.html?Name=Language-Expr

When submitting a bug or request, please include a test-file or a patch to an existing test-file that illustrates the bug or desired feature.

AUTHOR

Steven Haryanto <stevenharyanto@gmail.com>

COPYRIGHT AND LICENSE

This software is copyright (c) 2014 by Steven Haryanto.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.




Hosting generously
sponsored by Bytemark