Hop Documentation Center

APICoreJavaScriptLibrariesWiki syntaxWebletsTutorialsIndexSearch

Access Control	MD5 checksum
Advanced Encryption Standard (AES)	MULTIMEDIA library
Audio	MathML support
BASE64 encoding/decoding	Notepad widget
CGI arguments parsing	Outer Windows
Canvas support	Output
Cascading style sheet (HSS)	Pan widget
Charset	Parameters and Preferences
Colorchooser widget	RSS 2.0 markups
Conditional Compilation	Regular Expressions
Cookies	SHA1 checksum
Delayed executions	SQLITE library
Document Object Model (DOM)	SVG support
Editor widget	Server Filters
Events	Server Hooks
Exceptions	Server Services
File chooser	Server caching facilities
Folding lists	Server class for HTTP messages
Font facilities	Server parsing source code
Gauge widget	Server requests
HEAD and FOOT markups	Server responses
HOP server configuration	Slider widget
HOP server runtime command files	Spage widget
HOP server settings	SpinButton widget
HTML markups	Symbols (aka, special characters)
HTTP remote requests	Tabslider
History (aka, "back button" support)	Timeout on client side
IMG markup	Tree widget
INLINE markup	URL processing
INPUT markup	Video
Interactive "sortable" tables	WebDAV
JavaScript compatibility	Wiki facilities
LabelFrame widget	XML
Login panel

HOP core language

Presentation
Syntax
Definitions
Basic constructions
Conditional compilation
Modules
- Module Access File
- Mixer server and client modules
Server Side core language
- Classes and Objects
Character set

Presentation

This document presents the core constructions of the HOP programming language. It does not present the APIs which are already presented in the API tab.

HOP is functional expression based programming language. That is:

All HOP expression as a value.
Functions are first class values. They can be passed as argument, returned as result, or stored in data structure.

HOP uses a lexical scoping discipline, that is the functions capture their definition environment for their free variables.

HOP is safe because it checks types and array bounds. Contrary to languages such as ML, HOP checks types at runtime.

Syntax

In this text we use the classical conventions. The sign + denotes a non empty repetition. The sign * denotes a possibly empty repetition. The sign ? denotes an optional occurrence. The sign | denotes the alternative.

HOP expressions are either atoms, quotes, or lists.

<expression> := <atom> 
   | <text>
   | <quote>
   | <list>

An atom is a syntactic elements described by the following grammar:

<atom> := <number>
   | <ident>
   | <keyword>
   | <string>
   | <boolean>
   | <character>
   | #unspecified
  
<ident> := [a-zA-Z<>/?|!@%^&*-_=+][a-zA-Z0-9<>/?|!@%^&*-_=+]*

<keyword> := :<ident>

<string> := " <char>+ "

<char> := "any character but " and \"
   | \ [\"tnr]

<character> := # \ "a character"
   | #\Newline
   | #\Space
   | #\Return
   | #\Tab

<boolean> := #t | #f

Hop supports texts. A text is made of a list of strings. A text is actually a syntactic shorthand for building list of strings.

<text> := <square-text>
   | <curly-text>

<square-text> := [ ... ]

<curly-text> := { ... }

Inside <square-text> all characters are left as is with two exceptions:

the character ] must escaped as \],
the sequence ,( is an escape operator. It introduce an Hop expression inside a text.

Inside <curly-text> all characters are left as is with two exceptions:

the characters { and } that are included in the text but must be balanced. The text is ended when the parse reads a closing bracket matching the one that has opened the text construction.
the character $ is an escape operator. It introduces an Hop expression inside a text. The sequence $$ introduces a single $ sign in the text construction.

Quotes are:

<quote> := '<ident>
   | <literal-vector>

<literal-vector> := '#(<expression>*>)

Lists are:

<list> := (<expression>*)

In addition to these syntactic elements, server-side expressions may use client-side embedding:

<server-expression> := <expression>
   | ~<client-expression>

Symmetrically, client-side expressions may use server-side embedding:

<client-expression> := <expression>
   | $<server-expression>

Definitions

HOP supports definitions of variables, functions, and services:

<definition> := <define-variable>
   | <define-function>
   | <define-service>

<definition-variable> := (define <ident> <expression>)

<definition-function> := (define (<ident> <ident>*) <expression>)

<definition-service> := (define-service (<ident> <ident>*) <expression>)

Basic constructions

The sequence of HOP expressions is:

<sequence> := (begin <expression> ...)

The alternative is:

<alternative> := (if <expression> <expression> <expression>?)

HOP supports derivative conditional constructions:

<alternative-cond> := (cond ((<expression> <expression>)+))
<alternative-case> := (case <expression> ((<atom>+ <expression>)+))

Local variables are introduced with the let constructions:

<local-var> := <let> | <let*> | <letrec>

<let> := (let (<bindings>*) <expression>)
<let*> := (let* (<bindings>*) <expression>)
<letrec> := (letrec (<bindings>*) <expression>)

<binding> := <symbol>
   | (<symbol> <expression>)

The let construction binds independent variable. The let* is equivalent to a cascade of nested lets. The letrec allows recursive definitions of lexical variables. Anonymous functions are introduced by lambda expression:

<lambda> := (lambda (<ident>*) <expression>)

Loops are either defined with named let or anonymous functions:

<named-let> := (let <symbol> (<binding>*) <expression>)

Function applications are defined as:

<funcall> := (<expression> <expression>*)

Anonymous services are introduced by the service form:

<service> := (service [:ttl <integer>] [:timeout <integer>] [:url <string>] 
                (<ident>*) <expression>)

Conditional compilation

Conditional compilation are managed in HOP by the cond-expand form:

<cond-expand> := (cond-expand (<cond-expand-set> <expression>)+)
<cond-expand-set> := else
  | <cond-expand-feature>
  | (not <cond-expand-set>)
  | (or <cond-expand-set>+)
  | (and <cond-expand-set>+)
<cond-expand-feature> := symbol

Hop defines the following features:

bigloo
hop
hop-<version> (i.e., hop-2.0.0)
hop-<branch> (i.e., hop-2.0.x)

In addition, client-side defines additional features that allows source code to behave differently on the server and on the client:

scheme2js

See Conditional Compilation for additional details.

Modules

Modules structure HOP weblet. Server and client codes may use modules. A module export variables, functions, and classes. A module might import another module. In that case, it may access to the imported variables, functions, and classes.

The syntactic structure of a module is as follows:

(module <ident> <clause>+ ...)

<expression>*

A single file cannot contain more than one module. The syntax for the clauses is:

<clause> := <import>
   | <client-import>
   | <server-import>
   | <library>
   | <export>
   | <static>

<import> := (import <import-module>+)
   | <client-import>
   | <server-import>

<import-module> := <ident>
   | (<ident> <string>)

<client-import> := ~(import <ident>+) can only be used by server code

<server-import> := $(import <ident>+) can only be used by client code

<library> := (library <ident>+)

<export> := (export <class-or-binding>+)
<class-or-binding> := <variable>
   | <function>
   | <class>

<variable> := <ident>
<function> := (<ident>+)
   | (generic <ident>+)

<class> := (class <ident> <class-field>)
<class-field> := <ident>
   | (<ident> <class-attribute>+)
<class-attribute> := read-only
   | (default <expression>)

Here is an example of a module named foo that uses the library ssl, that imports the module named bar, and that exports the function fun-foo, the variable var-foo, and the class class-foo.

(module foo
   (library ssl)
   (import bar)
   (export (fun-foo x)
           var-foo
           (class class-foo
              (name read-only)
              (x (default 0))
              (y (default 0)))))

Module Access File

Hop is different from languages such as C where a module is defined by a file. For Hop, the module name is not necessarily the name of the file where the text of the module is written and modules can even be split across several files.

Since modules are defined independently of files, it is necessary to make a link between a module and its files and there are two ways of doing this. Choosing an import clause where the file-names are specified or creating a module access file. Such a file must contain only one list, each element of the list being of the form:

(module-name "file-name" ... "file-name")

By default Hop checks if a file named .afile exists. If it exists it is loaded as a module access file.

Note: The Bigloo distribution contains a tool, bglafile, that can automatically build a module access file. See the manpage for bglafile for details.

Mixer server and client modules

Since Hop-2.0.x, servers and clients may mutually import modules. That is, server modules may import client modules to access to client functions and variables when producing a HTML tree. Respectively, client modules may import server modules, for instance, for accessing services from client code. The following example illustrate this mutual imports.

The following server module defines a weblet drawing chart:

(module foo-server
   (import (gchart "http://localhost:8080/hop/weblets/download?weblet=gchart-api-1.0.0.hz"))
   (export img pre)
   ~(import foo-client))

(define types '(bhs bvs bhg bvg p p3 pc chp v s r rs))
(define tnum 0)

(define (new-url)
  (let ((len (length types)))
        (set! tnum (+fx tnum 1))
        (if (>=fx tnum len) (set! tnum 0))
    (google-chart
       :colors '("a25cff" "f72f2b" 
                 "253c81" "c62f6d"
                 "522e81" "f79326"
                 "f7d93a" "aef742"
                 "69f7ab" "3df7ec")
       :type (list-ref types tnum)
       :data (map (lambda (l) (cons (symbol->string l) (random 100)))
                  types))))

(define url (new-url))
(define img (<IMG> :id "img" :src url :title "An image"))
(define pre (<PRE> :id "pre" :style "font-size: 70%" url))

(define-service (foo)
   (<HTML>
      (<HEAD> :jscript (service-resource foo "foo.scm"))
      (<BODY>
       (<BUTTON> :onclick ~(with-hop ($(service () (new-url))) update)
            "New barchart")
         (<DIV> :style "margin-top: 2ex"
            img
            pre))))

The server modules imports the client module named client defined as:

(module foo-client
   $(import foo-server)
   (export (update)))

(define (update src)
   (innerHTML-set! $pre src)
   (set! $img.src src))

These modules assume a module access file the .afile defined as:

(
  (server "foo.hop")
  (client "foo.scm")
)

Server Side core language

This section presents the HOP constructions that are only applicable to server-side programming.

Classes and Objects

The server side HOP object model is inspired by the Common Lisp Object System. Contrary to languages such as SmallTalk or Java, in that model, methods are not attached to classes but to generic functions. This enables code to add new functionalities to pre-existing data structures (objects). The HOP declination uses single inheritance and single dispatch. That is, a class may inherit from exactly one class and only the first argument of method explored to resolve the late binding.

Server side classes are defined in the module declaration. A class may either be exported in which case all the weblet might create objects of class, declare subclasses, generic functions, and methods.

For the sake of the example, here is a simple source code that defines two classes:

(module example
   (static (class point x y))
   (export (class point3d::point z))
   (export (generic to-string ::object)))

(define-generic (to-string obj)
   (with-output-to-string (lambda () (display obj))))

(define-method (to-string obj::point)
   (with-access::point obj (x y)
      (format "point:~a-~a" x y)))

(define-method (to-string obj::point3d)
   (with-access::point3d obj (z)
      (format "~a-~a" (call-next-method) z)))

The form define-generic defines a new generic function. The form define-method adds a method to a generic function. The generic function must be visible by the module declaring the method. The form with-access opens an object up. Objects are creates with the instantiate form. Here is an expression creating an instance of the point3d:

(instantiate::point3d
   (z 10)
   (x 0)
   (y 5))

Class fields that are provided with a default value are not required by instantiate.

Character set

The character set (charset) used for denoting strings of characters varies depending on the execution context and the configuration parameters. On the client-side, the charset used is the one of the hosting platform. Since HOP client-side expressions are designed to be strictly compatible with JavaScript, these expressions adopt the JavScript charset which is UCS-2.

The communications between the client and the server can be changed but by default UTF-8 is used.

The charset of the server depends on two parameters: hop-locale and hop-charset. The first one specifies the charset of the native environment hosting the server (i.e., the charset of the operating that is running the server). The latter specifies how HOP internally represents character strings. Hence, if hop-locale differs from hop-charset a translation mechanism is involved when expressions are read. Several functions (charset-convert, iso-latin->utf8, or ucs2-string->utf8-string) can be used for converting strings from one charset into another.

HOP JavaScript interface

Presentation
JavaScript Objects
Implicit Import
the JS clause
Qualified JavaScript Access
Scheme2Js Pragmas
Blending Hop and JavaScript

Presentation

This document describes the HOP - JavaScript interface. It explains how to interface HOP's client-side code with existing JavaScript code.

HOP's JavaScript interface is complete. Any program that could be written in JavaScript can be written with HOP. However it is often necessary (or simply convenient) to interface with existing JavaScript code. HOP provides some facilities to ease such an integration.

JavaScript Objects

HOP provides several means to use JavaScript objects efficiently inside HOP code. The whole list of functions is described in JavaScript API page.

HOP provides dot-access for JavaScript objects. One can thus simply write o.x to access the property (field) x of object o. This dot-access is a shortcut for (js-property o x). The latter form could be convenient when the property-name is not known at compile-time. In a similar vein there exist the functions js-property-set!, js-property-delete!, js-method-call, and js-new.

(define (foo) (set! this.x 42) #unspecified)
(let ((o (js-new foo)))
  (alert o.x) ;; => 42
  (js-property-delete! o "x")
  (alert o.x) ;; => undefined
  (js-property-set! o "x" 3.1415)
  (alert o.x) ;; => 3.1415
  (set! o.f (lambda () (alert this.x)))
  (o.f) ;; => 3.1415
  (js-method-call o "f")) ;; => 3.1415

Remark: for most DOM-manipulations there exist library-functions. So you should not need to manipulate DOM properties this way. I.e. instead of writing (set! x.innerHTML ...) one should rather use (innerHTML-set! x ...); or instead of (node.replaceChild n r) rather use (dom-replace-child node n r).

Note that functions that are used as constructors (i.e. with js-new) must pay attention not to return an object. Indeed, the JavaScript specification states that in such a case the returned object is used.

(define (bar) (set! this.x '#(1 2)))
(let ((o (js-new bar)))
   (alert o)) ;; => #(1 2) and not [object Object]

(define (correct-bar) (set! this.x '#(1 2)) #unspecified)

In order to avoid this mistake it is best to declare classes using the following macro:

(define-macro (define-class sig . Lbody)
  `(define ,sig ,@(append Lbody '(#unspecified))))

(define-class (bar) (set! this.x '#(1 2)))
(let ((o (js-new bar)))
   (alert o)) ;; => [object Object]

Another macro is convenient for named JavaScript function calls. A common idiom is to pass arguments inside an object:

openTip({ color: "blue", position: "top", length: 3 });

The following macro creates a wrapper-function that can then be used with keywords. It is not very sophisticated but might serve as a good starting-point for more involved macros:

(define-macro (keywordify scm-name js-name)
   `(define (,scm-name . orig-args)
       (define (empty-object) #unspecified)
       (let ((o (js-new empty-object)))
	    (let loop ((args orig-args))
	       (cond
		  ((null? args) (,js-name o))
                ((or (null? (cdr args))
		       (not (keyword? (car args))))
		      (error named-args
			     bad argument-list
			     orig-args))
		  (else
		     (js-property-set! o (keyword->string (car args)) (cadr args))
		     (loop (cddr args))))))))

(keywordify open-tip openTip)

(open-tip :color "blue" :position "top" :length 3)

Implicit Import

JavaScript variables are implicitly imported for every HOP expression that is not inside a module. These are the tilde (~) expressions as well as separate files without a module clause:

;; contents of file bar.scm
(alert bar)

In the first case foo is unbound and thus assumed to be a JavaScript variable. Similarly, in the latter case bar is unbound and thus sought for in the JavaScript namespace.

Note that HOP expressions might define JavaScript variables by themselves. For instance the expression ~(define foo 5) will define the JavaScript variable foo.

HOP will mangle all unbound variables that are invalid JavaScript identifiers. This mangling is deterministic and as a consequence different HOP parts might communicate through such JavaScript variables:

~(define invalid+js-id 3)
~(alert invalid+js-id)

If these variables should be accessible by JavaScript code, then valid JS-identifiers should be used instead.

;; in HOP:
~(define valid_js_id 5)

// in JavaScript
alert(valid_js_id);

It is clear that not all valid JavaScript identifiers can be defined this way. For instance the JavaScript identifier begin or lambda can not be defined as this would yield a syntax error. In the following sections different ways of interfacing will be described that allow to use these identifiers as well.

the `JS` clause

The JS clause is an easy way of importing JavaScript variables into HOP. Its syntax is

<js-clause> := (JS <js-field>+)
<js-field>  := <string>)
              | <symbol>
              | (<symbol> <symbol>
              | (<symbol> <string>

When <js-field> is a

string, then the JavaScript variable is imported as is. For instance the clause (JS foo_bar) will import the JavaScript variable foo_bar under the name of foo_bar.
symbol, then the JavaScript variable is assumed to have been created in tilde code (or separate code without the module clause). (JS foo-bar) will import the mangled foo-bar variable under the name foo-bar.
pair (with the cadr either a symbol or a string) will import the variable under the specified name. The clause (JS (color-set! setColor)) will import the JavaScript variable setColor under the name of color-set!.

JS clauses may be in two locations:

Inside a module-clause of a separate HOP client module, or

inside a server module-clause prefixed by a tilde.

;; separate HOP client file
(module client-module
  (JS (color-set! "setColor")))

(color-set! ...)

;; server HOP module
(define server-module
  ~(JS (foo-bar? "is_foo_bar")))

(define-service (foo)
(<HTML> ... ~(alert (foo-bar? ...)) ...))

Qualified JavaScript Access

HOP allows direct access to JavaScript identifiers using a qualified access with _ as module identifier:

~(alert (@ js_identifier _))

Scheme2Js Pragmas

Scheme2Js pragmas are the most involved form of adding information to exported variables. They not only allow to define its identifier but also other properties (like a function's arity).

<js2scheme-pragma> := (scheme2js-pragma <pragma-clause>+)
<pragma-clause> := <js-pragma-clause>
                   | <type-clause>
                   | <constant-clause>
                   | <arity-clause>
                   | ...
<js-pragma-clause> := (JS <string>) | (JS <symbol>)
<type-clause>       := (type <symbol>)
<constant-clause>  := (constant? <bool>)
<arity-clause>      := (arity <int>)

One typically uses this form when creating dedicated interface modules that serve as JavaScript library facades. That is, if one has a JavaScript library then one typically writes a module (which can then later be imported by other HOP modules) containing the JS clauses and maybe some wrapper functions.

;; interface with some library
(module some
  (export foo bar ...)
  (js2scheme-pragma
     (foo (constant #t) (JS js_foo) (arity -2))
     (bar (constant #f) (JS js_bar))))

The <js-pragma-clause> allows to fix a variable's JavaScript identifier. If a symbol is given HOP will simply invoke symbol->string on the identifier. It will _not_ mangle the symbol.

The <arity-clause> exports a function's arity. If the given number is negative then it is of variable arity. For instance, the procedure (define (foo (x . L) ...)) has arity -2.

Have a look at HOP's runtime module clause (share-directory/hop-runtime.sch) for examples of pragma clauses.

;; example copied from hop-runtime.sch
(js2scheme-pragma
  (dom-has-child-nodes?
    (constant? #t)
    (JS dom_has_child_nodes)
    (arity 1)
    (type bool)
    (peephole (postfix ".hasChildNodes()"))))

Blending Hop and JavaScript

HOP and JavaScript can easily interact. HOP can call JavaScript functions and use JavaScript variables and vice versa. Hence, a HOP program can simultaneously use HOP and JavaScript.

HOP and JavaScript may exchange values (read and write) without restriction. Each language can also set the global variable of the other language.

HOP client-side expression are introduced by the ~ character. JavaScript expressions are enclosed in angle brackets ({...}).

(<DIV>
  (<SCRIPT> { function js_foo( x ) { alert( "x=" + hop_bar( x ) ); } })
  ~(define (hop_bar x) (+ 1 x))
  (<BUTTON> :onclick ~(js_foo 1) "A HOP client expression")
  (<BUTTON> :onclick {js_foo( 1 )} "A JavaScript client expression"))

HOP has a special form which allows the inclusion of JavaScript text into the produced code. Its syntax is as follows:

<pragma> := (pragma <string> <expression> <expression> ...)

This force HOP to include string in the produced JavaScript code as a regular JavaScript fragment of code. This form must not be used without an in depth understanding of HOP JavaScript code production; with unskilled use, the produced incorrect JavaScript files.

Values can be passed to a pragma form, being referenced in string by expressions of the form number. Such expression are replaced by the corresponding values, the number of referenced values in string being exactly the number of values provided. Here is an example of pragma usage:

@smalllisp (define (fibo x)

 (pragma "alert( \"fib(\" + $1 + \"):\" + $2 )" x (fib x)))
@end smalllisp

HOP Wiki syntax

Basic Text Formatting
Links and Anchors
Images
Sectioning
Text Layout
Embedding HOP
Inclusion
Syntax Plugins
Playground
Credits

This page describes the external syntax (the user visual syntax) used by the HOP wiki parser (see Wiki facilities).

This documentation presents the wiki syntax forms by examples. That is, each forms is presented as an example whose source code and layout are presented side-by-side.

Basic Text Formatting

Bold, Italic, and Underline

HOP wiki supports bold, italic, and underline. These can be combined anyhow.

HOP wiki supports **bold**, //italic//, and __underline__. These can
be **__combined__** **//anyhow//**.

Mono Space

It supports two sorts of mono space layout. By default the two sorts look the same. But they can be customized to use different rendering.

It supports two sorts of ++mono space++ layout. By default the two
%%sorts%% look the same. But they can be customized to use different 
rendering.

Quotation, Strike, and Note

Hop Wiki supports expression quotations. By default, it generates a <Q> HTML expression but as all wiki syntax constructor, this can be changed by creating and using a personal wiki wiki-syntax object.

The Wiki syntax also supports strike and notes.

Hop Wiki supports "expression quotations". By default, it generates
a "++<Q>++" HTML expression but as all wiki syntax constructor,
this can be changed by creating and using a personal wiki
++wiki-syntax++ object.

~~ The Wiki syntax also supports --strike-- and <<notes>>.

Misc

HOP Wiki also supports ~~deleted~~ texts. It also supports ^superscript and _subscript.

HOP Wiki also supports <del>deleted</del> texts. It also supports
<sup>superscript</sup> and <sub>subscript</sub>.

Links and Anchors

HOP Wiki only supports innter and external links. No effort is made to automatically recognize links in a regular text. Links are enclosed inside double angle parenthesis. Anchors are introduced by the double sharp constructor. Links may only not only refer to a URL such as http://www.inria.fr. They may also specify a text to be displayed instead of the url such as: Inria. The text denoting a link may use all the wiki syntax such as: The French national institute for research in computer science and control. This is an . A text may refer to that anchor. As links, a user defined expression may be attached to an anchor.

Links may only not only refer to a URL such as [[http://www.inria.fr]]. 
They may also specify a text to be displayed instead of the url such as:
[[http://www.inria.fr|Inria]]. The text denoting a link may use all the wiki
syntax such as: [[http://www.inria.fr|The //French// national institute for
__research__ in **computer science** and **control**]].

This is an ##anchor##. A text may refer to that [[anchor]]. As links, 
a user defined ##anchor2|expression## may be attached to an anchor.

Images

Images are embedded inside angle brackets ({{...}}). Images may have a title. Image title shares its syntax with links text. It is specified after a pipe character | in the definition of the image. For instance, this is an image

Images are embedded inside angle brackets (,(<TT> "{{...}}")). Images
may have a title. Image title shares its syntax with links text.
It is specified after a pipe character ,(<TT> "|") in the definition
of the image. For instance, this is an image
{{,(make-file-path (hop-share-directory) "icons" "hop" "hop-16x16.png")|this is a logo}}.

Sectioning

HOP supports 5 section levels. They starts by a double equal sign at the beginning of line.

Head level 4

Head level 5a

Head level 5b

===== Head level 4 =====
====== Head level 5a ======
====== Head level 5b ======
=======

More than 5 consecutive equal signs at the beginning of a line, introduce an horizontal rule. HOP, does not automatically compute table of contents but it supports facilities for producing such tables.

Text Layout

Paragraph

The sequence ~~ located at the beginning of a line starts a new paragraph.

This is

an example of paragraph.

This is
~~ an example of paragraph.

Verbatim

Non parsed, pre-formated blocks are introduced by indenting lines with two space characters.

This blocks can be
   used for representing
   computer programs
     or anything else that needs
     pre-formated indentations.

These blocks end with two consecutive empty lines.

Lists

HOP Wiki supports order and unorder lists. They are created by lines indent with at least two space character and followed by a - character for ordered lists and by a * character for unordered ones.

one
two
- three
- four
  1. un
  2. deux
    1. trois
    2. quatre
  3. cinq
- five
six

  * one
  * two
    * three
    * four
      - un
      - deux
        - trois
        - quatre
      - cinq
    * five
  *six

Tables

Tables starts by the character ^ (for a header) or | (for a regular data) in column 1. A table ends with two consecutive blank lines. Table cells may be centered (if they start and end with two space characters). They may be left aligned (if they end with two space characters) or right aligned (if they start with two space characters). A cell may span over several columns (when it is followed by one or several empty cells).

Programming languages
name	family	type system
Scheme	functional	dynamic
JavaScript	functional/object	dynamic
ML	functional	static
SmallTalk	object	dynamic
C	imperative	unsafe

^                  Programming languages               ^^^
^  name           ^       family         ^  type system  ^
| **Scheme**      |  functional          |  dynamic      |
| **JavaScript**  |  functional/object   |  dynamic      |
| **ML**          |  functional          |  static       |
| **SmallTalk**   |  object              |  dynamic      |
| **C**           |  imperative          |  __unsafe__   |

Math

If you browser supports MathML, the Hop Wiki parser let you embed mathematical formulas inside documents.

he more general way of embedding MathML inside Wiki document consists in using the markup. Users accustomed to LaTeX can also use direct embedding of formulas inside wiki documents by the means of the $$ syntax such as: This shows various examples of LaTeX embedding inside Hop Wiki document:

$\sqrt{y} \sqrt[n]{y}$
$\prod_{n}^{m} lim_{n \to \infty} x = 0$
$\overset{⏞}{{\overline{x}}^{2} + 1}$
$10^{10} 2^{n + 1} (n + 1)^{2} \sqrt{1 - x^{2}} \overline{w + \overline{z}} p_{1}^{e_{1}} a_{b_{c_{d_{e}}}} \sqrt[3]{{h''}_{n} (α x)}$
${a, b, c} {1, 2, \dots, n} {red, white, blue} {x ∣ x > 5} {x : x > 5}$

This shows various examples of LaTeX embedding inside Hop Wiki document:

  - $$\sqrt{y} \sqrt[n]{y}$$
  - $$\prod_n^m \lim_{n \rightarrow \infty} x = 0$$
  - $$\overbrace{\overline{x}^{2} + 1}$$
  - $$10^{10}\quad 2^{n+1}\quad (n+1)^2\quad \sqrt{1-x^2}\quad
\overline{w+\bar z}\quad p^{e_1}_1\quad a_{b_{c_{d_e}}}\quad
\root 3 \of {h''_n(\alpha x)$$
  - $$\{a,b,c\} \qquad
\{1,2,\ldots,n\} \qquad
{\{\rm red,white,blue\}} \qquad
\{\,x\mid x > 5\,\} \qquad
\{\,x:x > 5\,\}
}
{
\bigl\{\,\bigl(x,f(x)\bigr)\bigm| x\in D\,\bigr\} \qquad
\bigl\{\,x^3\bigm| h(x)\in\{-1,0,+1\}\,\bigr\}
}$$

Embedding HOP

HOP wiki syntax supports embedded HOP expressions. An HOP expressions starts with the sequence comma and parenthesis (i.e., ,() and its ends with a closing parenthesis.

The full power of HOP is available inside HOP wiki.

This example builds a multiplication tables.

	1	2	3	4	5	6	7	8	9
1	1	2	3	4	5	6	7	8	9
2	2	4	6	8	10	12	14	16	18
3	3	6	9	12	15	18	21	24	27
4	4	8	12	16	20	24	28	32	36
5	5	10	15	20	25	30	35	40	45
6	6	12	18	24	30	36	42	48	54
7	7	14	21	28	35	42	49	56	63
8	8	16	24	32	40	48	56	64	72
9	9	18	27	36	45	54	63	72	81

The second example reverses a given word: airnI.

This example builds a multiplication tables.

,(let ((enum (iota 9 1)))
    (<TABLE>
       (<TR> (<TD>) (map <TH> enum))
       (map (lambda (v1)
	       (<TR>
		  (cons (<TH> v1)
			(map (lambda (v2)
				(<TD> (* v1 v2)))
			     enum))))
	    enum)))

The second example reverses a given word:
,(list->string (reverse (string->list "Inria"))).

Inclusion

HOP wiki syntax supports two forms of inclusion. The first one allows a wiki source to include other sources. The second one allows a wiki source to include a pre-formatted text.

An include form is introduced by the special include keyword, such as: This example builds a multiplication tables.

	1	2	3	4	5	6	7	8	9
1	1	2	3	4	5	6	7	8	9
2	2	4	6	8	10	12	14	16	18
3	3	6	9	12	15	18	21	24	27
4	4	8	12	16	20	24	28	32	36
5	5	10	15	20	25	30	35	40	45
6	6	12	18	24	30	36	42	48	54
7	7	14	21	28	35	42	49	56	63
8	8	16	24	32	40	48	56	64	72
9	9	18	27	36	45	54	63	72	81

The second example reverses a given word: airnI. . Pre-formatted texts are included using the include-pre keyword:

This example builds a multiplication tables.

,(let ((enum (iota 9 1)))
    (<TABLE>
       (<TR> (<TD>) (map <TH> enum))
       (map (lambda (v1)
	       (<TR>
		  (cons (<TH> v1)
			(map (lambda (v2)
				(<TD> (* v1 v2)))
			     enum))))
	    enum)))

The second example reverses a given word:
,(list->string (reverse (string->list "Inria"))).

An include form is introduced by the special ++include++ keyword,
such as: <include>hop.wiki</include>.

Pre-formatted texts are included using the ++include-pre++ keyword:
<include-pre>hop.wiki</include-pre>

Syntax Plugins

HOP wiki supports plugins. A plugin invocation starts with an opening markup (i.e., a word starting with a < character and ending with a > character) at the beginning of a line. The invocation ends with a closing markup (i.e., a word starting with the sequence < and ending with a > character). The closing markup must either be on the same line as the opening markup or at the beginning of a line. All characters following a closing markup are ignored.

A plugin is implemented by the means of a function accepting three parameters.

an input port
a title
a body

The title is composed of all the characters following the opening markup up to the end of line or up to the closing markup for one-line plugins. The body of the plugin is composed of the characters composing the lines in between the opening and closing markups. The body and the title may use the wiki the syntax.

This example illustrates how to use a plugin inside a wiki document. This particular plugin does not use its title. It only uses its body.

<center>
This example illustrates how to use a plugin
inside a wiki document. This particular plugin
does not use its title. It only uses its body.
</center>

The developer documentation for the Wiki library shows how to implement Wiki plugins.

Playground

Credits

HOP borrows its wiki syntax from several projects. The three mains are:

HOP global index

?	dom-node-document-fragment?	http-request	removeChild
%http-message	dom-node-document?	http-request-cgi-args	replaceChild
%http-response	dom-node-element?	http-response-abort	replay-history
%http-response-local	dom-node-eval	http-response-authentication	rgb->hsl
A	dom-node-name	http-response-cgi	rgb->hsv
<A>	dom-node-text?	http-response-error	<RSS>
<ABBR>	dom-node-type	http-response-file	S
<ACRONYM>	dom-normalize!	http-response-filter	<S>
add-event-listener!	dom-owner-document	http-response-hop	<SAMP>
add-user!	dom-parent-node	http-response-persistent	<SCRIPT>
<ADDRESS>	dom-previous-sibling	http-response-procedure	<SELECT>
aes-ctr-decrypt	dom-remove-attribute!	http-response-put	service
aes-ctr-decrypt-string	dom-remove-child!	http-response-raw	service-base-url
aes-ctr-encrypt	dom-remove-class!	http-response-remote	service-resource
aes-ctr-encrypt-string	dom-replace-child!	http-response-shoutcast	setAttribute
after	dom-set-attribute!	http-response-string	sha1sum
appendChild	dom-set-child-node!	http-response-xml	sha1sum-string
<APPLET>	<DT>	http-send-request	slider-onchange
<AREA>	E	http-server-request	slider-onchange-set!
audio-backend	<EDITOR>	I	slider-value
audio-backend-set!	<EM>	<I>	slider-value-set!
audio-close	error	id3	<SLIDER>
audio-current-time	event-key-code	iframe-scroll-height	<SMALL>
audio-duration	event-mouse-button	<IFRAME>	<SORTTABLE>
audio-load	event-mouse-x	img-base64-encode	soundcard
audio-metadata	event-mouse-y	<IMG>	<SOURCE>
audio-mute	event-response-text	<INLINE>	spage-selection
audio-pan	event-value	innerHTML-set!	<SPAGE>
audio-pan-set!	exif	<INPUT>	<SPAN>
audio-pause	F	<INS>	<SPHEAD>
audio-play	feed-parse	insertBefore	spinbutton-value
audio-playlist	<FIELDSET>	<ISINDEX>	spinbutton-value-set!
audio-playlist-index	<FILECHOOSER>	iso-latin->utf8	<SPINBUTTON>
audio-playlist-next	find-authenticated-user	iso-latin->utf8!	<SPTAB>
audio-playlist-play	find-hopaccess	J	<SPTABHEAD>
audio-playlist-prev	find-user	jpeg-exif	sqlite
audio-playlist-set!	find-user/encrypt	jpeg-exif-comment-set!	sqlite-close
audio-seek	firstChild	js-for	sqlite-eval
audio-server	<FL>	js-in?	sqlite-exec
audio-state	<FLHEAD>	js-instanceof?	sqlite-format
audio-stop	<FLITEM>	js-method-call	sqlite-last-insert-rowid
audio-volume	font-exists?	js-new	sqlite-map
audio-volume-set!	<FONT>	js-property	sqlite-name-of-tables
<AUDIO>	<FOOT-BUTTON>	js-property-delete!	sqltiny
authentication-encrypt	<FOOT>	js-property-set!	stop-event-propagation
authorized-path?	<FORM>	K	<STRIKE>
authorized-service?	format	<KBD>	<STRONG>
B	<FRAME>	L	<STYLE>
<B>	<FRAMESET>	<LABEL>	<SUB>
base64-decode	G	lastChild	<SUP>
base64-encode	gauge-max	<LEGEND>	<SVG:CIRCLE>
<BASE>	gauge-max-set!	<LFLABEL>	<SVG:DEFS>
<BASEFONT>	gauge-min	<LFRAME>	<SVG:ELLIPSE>
basename	gauge-min-set!	<LI>	<SVG:FECOLORMATRIX>
basic-password-encrypt	gauge-text	<LINK>	<SVG:FEGAUSSIANBLUR>
<BDO>	gauge-text-set!	login-panel	<SVG:FILTER>
<BIG>	gauge-value	M	<SVG:FOREIGNOBJECT>
<BLOCKQUOTE>	gauge-value-set!	main-window-height	<SVG:G>
<BODY>	<GAUGE>	main-window-width	<SVG:IMG>
bounding-box->list	get-selection	make-history	<SVG:LINE>
bounding-box-x	getAttribute	make-hop-url-name	<SVG:POLYGON>
bounding-box-y	getAttributes	<MAP>	<SVG:POLYLINE>
<BR>	getElementById	<MARQUEE>	<SVG:RECT>
<BUTTON>	getElementsByClass	<MATH:MFRAC>	<SVG:TEXT>
C	getElementsByTagName	<MATH:MI>	<SVG:TEXTPATH>
cache	H	<MATH:MN>	<SVG:TREF>
cache->list	h0password	<MATH:MO>	<SVG:TSPAN>
cache-clear	<H1>	<MATH:MOVER>	<SVG>
cache-disk	<H2>	<MATH:MROOT>	<SYM>
cache-entry	<H3>	<MATH:MROW>	T
cache-get	<H4>	<MATH:MSQRT>	tab-open
cache-memory	<H5>	<MATH:MSTYLE>	<TABLE>
cache-put!	<H6>	<MATH:MSUB>	tabslider-select
canvas-add-color-stop	hasAttribute	<MATH:MSUBSUP>	<TABSLIDER>
canvas-arc	hasAttributes	<MATH:MSUP>	<TBODY>
canvas-arc-to	hasChildNodes	<MATH:MTEXT>	<TD>
canvas-arrow-to	<HEAD>	<MATH:MUNDER>	<TEXTAREA>
canvas-begin-path	history-add!	<MATH:MUNDEROVER>	<TFOOT>
canvas-bezier-curve	hmac-md5sum-string	<MATH:TEX>	<TH>
canvas-bezier-curve-to	hop-autoload-directories	<MATH>	the-loading-dir
canvas-clear-rect	hop-autoload-directories-set!	md5sum	the-loading-file
canvas-clip	hop-autoload-directory-add!	md5sum-string	<THEAD>
canvas-close-path	hop-bin-directory	<MENU>	timeout
canvas-create-linear-gradient	hop-charset	<META>	<TITLE>
canvas-create-pattern	hop-charset-set!	mixer	tprint
canvas-create-radial-gradient	hop-contribs-directory	mixer-close	<TR>
canvas-draw-image	hop-debug	mixer-volume-get	trace
canvas-fill	hop-debug-set!	mixer-volume-set!	<TRBODY>
canvas-fill-rect	hop-enable-proxy-sniffer	mp3-id3	tree-close
canvas-fill-text	hop-enable-proxy-sniffer-set!	mpc	tree-open
canvas-get-context	hop-enable-proxying	mpd	tree-reset!
canvas-get-image-data	hop-enable-proxying-set!	mpd-database	tree-select-all!
canvas-line	hop-enable-webdav	mplayer	tree-select-next!
canvas-line-to	hop-enable-webdav-set!	music	tree-select-previous!
canvas-measure-text	hop-etc-directory	music-close	tree-selection
canvas-move-to	hop-event-broadcast!	music-closed?	tree-toggle
canvas-path-text	hop-event-signal!	music-crossfade	<TREE>
canvas-properties	hop-filter-add!	music-event-loop	<TRHEAD>
canvas-properties-set!	hop-filter-add-always-first!	music-meta	<TRLEAF>
canvas-put-image-data	hop-filter-add-always-last!	music-next	<TSHEAD>
canvas-quadratic-arrow-to	hop-filter-remove!	music-pause	<TSPAN>
canvas-quadratic-curve	hop-filters	music-play	<TT>
canvas-quadratic-curve-to	hop-filters-set!	music-playlist-add!	typeof
canvas-restore	hop-http-authentication	music-playlist-clear!	U
canvas-rotate	hop-http-authentication-set!	music-playlist-delete!	<U>
canvas-save	hop-http-response-proxy-hook-add!	music-playlist-get	ucs2-string->utf8-string
canvas-scale	hop-http-response-proxy-hook-remove!	music-prev	<UL>
canvas-set-transform	hop-http-response-proxy-hooks	music-random-set!	unregister-cache!
canvas-shadow-rect	hop-http-response-proxy-hooks-set!	music-repeat-set!	url-decode
canvas-stroke	hop-http-response-server-hook-add!	music-reset!	url-decode!
canvas-stroke-rect	hop-http-response-server-hook-remove!	music-reset-error!	url-encode
canvas-stroke-text	hop-http-response-server-hooks	music-seek	url-parse
canvas-text-along-path	hop-http-response-server-hooks-set!	music-song	url-path-encode
canvas-transform	hop-hz-repositories	music-songpos	user-access-denied
canvas-translate	hop-hz-repositories-add!	music-status	user-authorized-path?
<CANVAS>	hop-hz-repositories-set!	music-stop	user-authorized-request?
<CAPTION>	hop-ip-blacklist	music-update-status!	user-authorized-service?
<CENTER>	hop-ip-blacklist-set!	music-volume-get	user-exists?
cgi-args->list	hop-lib-directory	music-volume-set!	user-preference-get
cgi-fetch-arg	hop-load	musicproc	user-preference-set!
cgi-multipart->list	hop-load-hss	musicstatus	user-preference-store!
cgi-post-arg-field	hop-load-modified	N	user-preference-update!
charset-convert	hop-load-once	nextSibling	user-write-preferences
charset-converter	hop-load-once-unmark!	node-bounding-box	utf8->iso-latin
charset-converter!	hop-locale	node-bounding-box-x	utf8->iso-latin!
childNodes	hop-locale-set!	node-bounding-box-y	utf8->iso-latin-15
<CITE>	hop-mime-types-file	node-style-get	utf8->iso-latin-15!
cloneNode	hop-name	node-style-set!	utf8-string->ucs2-string
<CODE>	hop-path-access-control	nodeName	V
<COL>	hop-path-access-control-set!	nodeType	<VAR>
<COLGROUP>	hop-proxy-allow-remote-client	<NOFRAMES>	<VIDEO>
colorchooser-opactity	hop-proxy-allow-remote-client-set!	<NOSCRIPT>	W
colorchooser-opactity-set!	hop-proxy-authentication	notepad-select	webdav->list
colorchooser-value	hop-proxy-authentication-set!	notepad-selection	webdav->path-list
colorchooser-value-set!	hop-proxy-ip-mask	<NOTEPAD>	webdav-copy-file
<COLORCHOOSER>	hop-proxy-ip-mask-set!	<NPHEAD>	webdav-delete-directory
cond-expand	hop-proxy-remote-authentication	<NPTAB>	webdav-delete-file
cookie-get	hop-proxy-remote-authentication-set!	<NPTABHEAD>	webdav-directory?
cookie-remove!	hop-proxy-sniffer	O	webdav-file-exists?
cookie-set!	hop-proxy-sniffer-add!	<OBJECT>	webdav-file-modification-time
css-add-style!	hop-proxy-sniffer-set!	<OL>	webdav-file-size
current-history	hop-rc-directory	<OPTGROUP>	webdav-make-directories
current-request	hop-rc-directory-set!	<OPTION>	webdav-make-directory
D	hop-rc-file	ownerDocument	webdav-put-file
<DD>	hop-rc-file-set!	P	webdav-rename-file
define-hss-function	hop-read	<P>	wiki-file->hop
define-hss-property	hop-read-hss	<PAN>	wiki-input-port->hop
define-hss-type	hop-realm	paned-fraction	wiki-string->hop
define-lazy-parameter	hop-realm-set!	paned-fraction-set!	wiki-syntax
define-parameter	hop-script-file	paned-onresize	<WIKI>
define-preferences	hop-script-file-set!	paned-onresize-set!	window-close
define-service	hop-service-access-control	<PANED>	window-height
<DEL>	hop-service-access-control-set!	<PARAM>	window-height-set!
<DELAY>	hop-service-base	parentNode	window-iconify
<DFN>	hop-session	<PR>	window-maximize
digest-password-encrypt	hop-session-set!	<PRE>	window-open
<DIR>	hop-share-directory	preference-get	window-raise
dirname	hop-symbol-alist	preference-set!	window-resize
<DIV>	hop-uptime	preference-store!	window-title
<DL>	hop-use-proxy	preference-update!	window-title-set!
dom-add-class!	hop-use-proxy-set!	<PREFS>	window-width
dom-append-child!	hop-user	pregexp	window-width-set!
dom-child-nodes	hop-user-set!	pregexp-match	window-x
dom-clone-node	hop-verbose	pregexp-replace	window-x-set!
dom-first-child	hop-verbose-set!	pregexp-replace*	window-y
dom-get-attribute	hop-version	pregexp-split	window-y-set!
dom-get-attributes	hop-weblets-directory	previousSibling	with-handler
dom-get-element-by-id	hop-wiki->toc	<PRLABEL>	with-history
dom-get-elements-by-class	hop-xml-backend	procedure->service	with-hop
dom-get-elements-by-tag-name	hop-xml-backend-set!	<PRSEP>	with-hop-default-anim
dom-has-attribute?	<HR>	Q	with-hop-default-anim-set!
dom-has-attributes?	hsl->rgb	<Q>	with-url
dom-has-child-nodes?	hsv->rgb	R	write-m3u
dom-insert-before!	html-parse	raise	X
dom-last-child	html-string-decode	read-m3u	xml-parse
dom-next-sibling	html-string-encode	registered-caches	xml-string-decode
dom-node-attr?	<HTML>	remove-event-listener!	xml-string-decode!
dom-node-comment?	http-cookie-get	removeAttribute	xml-string-encode

Presentation

Syntax

Definitions

Basic constructions

Conditional compilation

Modules

Module Access File

Mixer server and client modules

Server Side core language

Classes and Objects

Character set

Presentation

JavaScript Objects

Implicit Import

the JS clause

Qualified JavaScript Access

Scheme2Js Pragmas

Blending Hop and JavaScript

Basic Text Formatting

Bold, Italic, and Underline

Mono Space

Quotation, Strike, and Note

Misc

Links and Anchors

Images

Sectioning

Head level 4

Head level 5a

Head level 5b

Text Layout

Paragraph

Verbatim

Lists

Tables

Math

Embedding HOP

Inclusion

Syntax Plugins

Playground

Credits

the `JS` clause