Operator 0.1.7

A simple Javascript transpiler program to code in a functional language looking like another famous functional programming language (beginning with an H.)

Each translation can be integrated in your web page via a single javascript script, provided you also installed jqMath (http://mathscribe.com/author/jqmath.html) -- with jQuery -- and Numeric Javascript (http://www.numericjs.com).

Like H., Operator

* is functional

* is little verbose

* understands binary operation's infix notation

Unlike H., Operator

* is not lazy in essence but infinite structures (lists, trees...) can be implemented

* is untyped

* doesn't understand sections with binary operators (you have to (\x->x+1) if you want to (+1)) but understands sections otherwise

* doesn't have a lower/upper cases distinction

* doesn't assume any priority for binary operations

* doesn't regard ' (simple quote) as a valid syntactic symbol

* is at a very early stage

Regarding purity, Operator works most of the time with immutable variables and structures but occasionnally (after the interact keyword) some states can be modified (content of an HTML document for example, see Demos).

PRIMITIVE BUILT INS:

Only +,-,*,/,%,==,<,>,substring,length are kept literally from javascript with the same meaning they have in javascript (+ is polymorphic for example). They are now regarded as functions of 2 arguments (except unary length and ternary substring).

The get method has become the ! function

Eg: var val=obj['black']+xs[0]; becomes val = (obj!"black")+(xs!0)

A javascript Array is called a List in Operator

Eg: var xs=[1,2]; becomes xs = List () 1 2 ()

A javascript Object is called a Map in Operator

Eg: var obj={'red':0,'black':1}; becomes obj = Map () "red" 0 "black" 1 ()

These are designed to be immutable and, as functions, the following is valid:

beg = List () 1 2 3

next = beg 4 5

xs = next 6 ()

, the last () giving the end of the structure (the first one creates an new instance). It would then be reckless to defined ys = next 7 () for the (impredictible) order in which xs and ys are processed would influence the result of xs!5 (which could give 6 or 7 accordingly). Instead, define a new immutable List: ys = List () 1 2 3 4 5 7 ()

Several useful document manipulation fonctions are available also:

:=, ::=, newline, value, math, input, button, interact (see Demos)

Several useful general fonctions are available also:

hex2char, dec2hex, hex2dec

The other javascript components can be accessed by the javascript keyword (see below).

And thats'all for the primitive built-ins!

FOREIGN BUILT-INS:

Foreign JAVASCRIPT:

Operator only knows a very small set of primitive keywords and operators but all the javascript functions can be accessed with the javascript keyword. Eg:

sqrt x = javascript (("Math.sqrt("+x) + ")")

or, better,

sqrt = javascript "var fun=function(x){return Math.sqrt(x);};fun"

or simply

sqrt = javascript "Math.sqrt"

Foreign JQMATH:

If the result of a computation satisfies the jqMath format (http://mathscribe.com/author/jqmath.html), it will be displayed as a mathematical formula. For example

main = "$355/113$"

will display a nice fraction on the screen, and on your web page if you install the script (sent by the "Send javascript" menu) and the jqMath script.

Foreign NUMERIC JAVASCRIPT:

All the numericjs functions (http://www.numericjs.com) can be used. For example

m=List () row1 row2 ()

row1=List () 2 5 ()

row2=List () 6 3 ()

determinant = javascript "numeric.det"

main=determinant m

will return -24. Note that there is no shortcut (as in sqrt above) for the definitions of the numeric functions of 2 or more variables. For example, with the first four lines above and

main = determinant (product m m)

you should define

product = javascript "var fun=function(x){return function(y){return numeric.dot(x,y);};};fun"

in order to get 576.