Category:Fexl: Difference between revisions

Official website
See Also:	Fexl on the HOPL; ;

Content added Content deleted

Inline

Latest revision as of 23:45, 4 August 2014

Fexl is a functional programming language designed to be compact, efficient, and customizable in embedded environments. Its implementation aims to be the thinnest possible functional programming layer built on top of C.

Fexl has no keywords, so whenever you see a symbol in a Fexl program, that symbol always refers to a function.

A symbol may be defined within a Fexl program, or its definition may be left entirely open. The definitions of all open symbols are supplied by a context. A context is a function which supplies definitions for symbols. A context function is itself written in Fexl.

A Fexl program may therefore be resolved inside an arbitrary context, giving whatever meanings you like to all its open symbols. This makes it easy to wrap a Fexl program in an enhanced or restricted context. For example, in a web context you probably don't want "delete_file" to be defined at all, at least not in its normal sense. So you would resolve the program in a highly restricted context which only provides a handful of safe functions, omitting all the dangerous ones.

Pages in category "Fexl"

The following 6 pages are in this category, out of 6 total.

9

99 bottles of beer

F

H

Hello world/Text

S

Sorting algorithms/Quicksort

@@ Line 1: / Line 1: @@
-{{language}}
+{{language
+|site=http://fexl.com}}
-[http://fexl.com Fexl] is a [[functional programming]] language designed to be compact, efficient, and customizable in embedded environments.  It has no keywords, so whenever you see a symbol in a Fexl program, that symbol always refers to a function.
+[http://fexl.com Fexl] is a [[functional programming]] language designed to be compact, efficient, and customizable in embedded environments.  Its implementation aims to be the thinnest possible functional programming layer built on top of [[C]].
+Fexl has no keywords, so whenever you see a symbol in a Fexl program, that symbol always refers to a function.
-A symbol may be defined within a Fexl program, or its definition may be left entirely open.  The definitions of all open symbols are supplied by a ''context''.  A context is a function which supplies definitions for symbols.  A context function itself is written in Fexl.
+A symbol may be defined within a Fexl program, or its definition may be left entirely open.  The definitions of all open symbols are supplied by a ''context''.  A context is a function which supplies definitions for symbols.  A context function is itself written in Fexl.
-A Fexl program may therefore be resolved inside an arbitrary context, giving whatever meanings you like to all its open symbols.  This makes it easy to wrap a Fexl program in an enhanced or restricted context.  For example, in a web context you probably don't want "delete_file" to be defined at all, at least not in its normal sense.  So you would you would resolve the program in a highly restricted context which only provides a handful of highly safe functions, omitting all the dangerous ones.
+A Fexl program may therefore be resolved inside an arbitrary context, giving whatever meanings you like to all its open symbols.  This makes it easy to wrap a Fexl program in an enhanced or restricted context.  For example, in a web context you probably don't want "delete_file" to be defined at all, at least not in its normal sense.  So you would resolve the program in a highly restricted context which only provides a handful of safe functions, omitting all the dangerous ones.
-Ultimately the core functions of Fexl are written in the [[C]] programming language.  To write a new core function named "X" within Fexl, you simply create an appropriate C routine named "fexl_X".  It automatically becomes available as a built-in Fexl function.
-For example, here is the C routine which implements the classic '''S''' combinator (fusion), where (S x y z) = (x z) (y z):
-<lang C>
-value fexl_S(value f)
-    {
-    if (!f->L->L || !f->L->L->L) return f;
-    return A( A(f->L->L->R, f->R), A(f->L->R, f->R) );
-    }
-</lang>
-Fexl functions may have side effects -- after all, '''somebody's''' gotta do it.  For example here's the implementation of the char_put function, called as (char_put ch next), which prints the single character ch to stdout and then continues with next:
-<lang C>
-value fexl_char_put(value f)
-    {
-    if (!f->L->L) return f;
-    value x = f->L->R;
-    if (!arg(type_long,x)) return f;
-    putchar(get_long(x));
-    return f->R;
-    }
-</lang>
-Fexl is very free-wheeling about side effects, because of course they must happen '''somewhere'''.  But you the Fexl programmer can easily isolate and confine side effects as diligently as you like, factoring them out systematically, applying monadic techniques, or whatever.
-Fexl has no built-in type inference system.  You can check types at run-time however you like.  Fexl also has reflective features which allow you to examine types and the internal data structures at run-time.