23,404
社区成员
发帖
与我相关
我的任务
分享请发表友善的回复…
发表回复
Geforce6600 2007-10-27
- 打赏
- 举报
靠 劳资亏了6000了
hmsuccess 2007-10-27
- 打赏
- 举报
顶顶，恭喜
backtohome 2007-10-27
- 打赏
- 举报
ding
bootupnow 2007-10-27
- 打赏
- 举报
涨跌都来接分
zjf405 2007-10-27
- 打赏
- 举报
路过
zhb_821012 2007-10-26
- 打赏
- 举报
接了
purplerain521 2007-10-26
- 打赏
- 举报
xiexie
zjf405 2007-10-26
- 打赏
- 举报
同乐，接分
wanxuesi 2007-10-26
- 打赏
- 举报
jF,谢谢！呵呵呵
pwjack 2007-10-26
- 打赏
- 举报
.............
吐司vivi 2007-10-26
- 打赏
- 举报
今天小红 我的基金终于不绿了
飞鸟0922 2007-10-26
- 打赏
- 举报
晕啊，这么快就跌了？？？？
Ryo_Hazuki 2007-10-25
- 打赏
- 举报
gx.com
jf.com
jf.com
胡矣 2007-10-25
- 打赏
- 举报
jf 呵呵 做人要厚道!
karlpan01 2007-10-25
- 打赏
- 举报
今天好像又跌了呜呜呜!
cl55 2007-10-25
- 打赏
- 举报
又跌了！
cwell 2007-10-25
- 打赏
- 举报
Background
Programming languages are notations. They are used for specifying, organizing, and reasoning about computations[1,2,3]. And languages can be categorized into several paradigms: imperative, functional, object-oriented, logic and concurrent ones; each of them manifests some powers and also some pitfalls. Many efforts have been paid to combination of these paradigms in previous decades. Among them, CLOS[4] integrated functional programming with object orientation; KLND[5], FL[6,7] combined functional with logic programming. LOGRES[8] integrated the object orientation with rule-base programming. Oz[9,10] facilitated the object orientation with concurrency and mobility.
In this paper, we present a new programming language, Fuxi, which is a general-purpose, concurrent, object-oriented, declarative programming language, designed for practical use, and implemented to meet the demands of network computing and mobility; it can also serve as a vehicle for the rapid prototyping of software.
Instead of invention of new language techniques, Fuxi takes a design philosophy: to combine the best ideas found in different languages within previous decades, through selecting some compatible features among these languages and merging them into a single approach in uniformity and conventional form.
Fuxi intends to make programming an enjoyable thing. Fuxi has an interesting combination of features:
1) it takes a conventional syntactic system, that makes the programmers with some experiences of C++, JAVA, use the language without any training;
2) it provides a good balance between static and dynamic binding;
3) it merges calculation, inference and reaction into a unique setting;
4) it provides a good balance between laziness and eagerness of evaluation;
5) it collects active, remote, mobile and persistent objects in a transparent way, through some orthogonal styles;
6) logical guards attached to the fields, provide the type system with some semantic markup, which will be very useful in some web applications;
7) Separate compilation and linking to an architecture-independent object module, make it suitable for network and mobile computing.
Types: Primitive and Reference
The type system of Fuxi is very similar to that of JAVA or C#. The types can be categorized into primitive and reference. Primitive types are built-in types, and denoted by keywords; they include: integral types (byte, short, int, long, ubyte, ushort, uint, ulong, char), float-pointing types (float, double) and Boolean one (bool).
The reference types include: Object, class, array and list. Object is the base of all reference types; every reference type is, directly or indirectly, derived from Object. A class is a grouping of members, where members can be variables or methods. As an applicative language, the list, defined as a set of homogeneously typed values, plays a very important role in Fuxi; The list data structure is an extremely powerful feature of Fuxi; Arrays are special lists, with fixed number of elements.
Variables: Binding, Assignment and Unification
The variables are the fundamental constructs of a language. Fuxi is strongly typed, so every variable declared in Fuxi, must have a type. The syntax of variable declaration is very similar to that of C/C++, as follows:
<type> <identifier>[<initializer>] (1)
and <initializer> is defined as:
= <expression> (2)
:= <expression> (3)
Beneath superficial similarities to C++, Fuxi variables differ from those found in C++, JAVA, and also from those in some dynamical languages such as Dylan[11], in that Fuxi variables can be used to hold values and also can refer to values.
A variable can denote a specific value, or the value of an expression; and it can also denote a store cell, which holds an individual value. We call a specific value, or the value of an expression, as r-value, and the store cell holding an individual value as l-value.
Note here ‘=’ is a unification operator, that causes a variable associated to a r-value; and ‘:=’ is an assignment operator, that causes the value in store cell denoted by the variable changed to the value of expression.
A newly declared variable without initialization denotes nothing, and is called free. The process of giving a free variable a value (an l-value or an r-value) is called binding. The variable bound to a specific value, or r-value, is called bound variable; and the variable bound to an l-value is called reference variable. Sometimes, a variable can also be the alias of another variable (unified to another variable). We can assign an individual value, or r-value to a variable’s l-value (if it holds). A variable can be bound statically at compiling time (with initialization), or dynamically at run time (free variable case).
So, we can depict Fuxi variables as objects with 3 dimensions: types, bindings and values.
For example,
float PI = 3.14159 (4)
double Area := PI * 10 * 10 (5)
The variable ‘PI’ is statically bound to an r-value 3.14159 at compile time, and ‘PI’ is a bound variable. Variable ‘Area’ is statically bound to an l-value; that is, a store cell holding the value of expression PI * 10 * 10, at compile time, even though the storage allocation will be delayed to run time; ‘Area’ is a reference variable.
Sometimes, we need to know the state of a variable. Fuxi provides a built-in function ‘test’. We can use test function to get the state of a variable, as following:
test( <variable-name> ) (6)
The return value of test is an integer; that is, 0 denotes free, 1 denotes bound, 2 denotes reference and 3 denotes an alias. In the example above, test( PI ) will return 1, and test( Area ) will return 2.
Assignment as a Boolean Function
The assignment is subtle in Fuxi. An r-value can be assigned to a variable, if it holds an l-value, or it is free, but we cannot assign something to a variable denoting an r-value. If a variable is free, the process of an assignment will be: first bind this free variable to a store cell, then put the value into the cell. We cannot assign a value to a bound variable. In Fuxi, assignment is a Boolean function; that is, if assignment is executed successfully, a true will be returned, or a false.
Assignment, in Fuxi, takes the form:
<variable-name> := <expression> (7)
For example,
PI := 3.14 (8)
Area := PI * 20.0 * 20.0 (9)
The first assignment will return false, and PI remains to the original value; but Area’s value will be changed after assignment.
Expressions
Fuxi has no real concept of a statement, but instead a program is an evaluation of sequence of expressions. An expression is a group of variables, values, and even some other expressions, connected by operators. The syntax for an expression is usual, just as C++, JAVA, or C#. But expressions in Fuxi can terminate naturally, without any delimiters.
Sequence
Expression sequence is very similar to a block in C/C++, it contains one or more expressions enclosed between curved brackets {}. If a sequence contains only one expression, the expression can be any type, and the value of sequence is that of its element; if a sequence contains two or more expressions, all the expressions must be Boolean, and be evaluated in sequential order until ‘}’ reached, or a false expression encountered. Sequence with more than one elements is just a conjunction of element expressions, with the logic operator && omitted. So, sequence can be considered as a “syntactical sugar” in some cases.
Programming languages are notations. They are used for specifying, organizing, and reasoning about computations[1,2,3]. And languages can be categorized into several paradigms: imperative, functional, object-oriented, logic and concurrent ones; each of them manifests some powers and also some pitfalls. Many efforts have been paid to combination of these paradigms in previous decades. Among them, CLOS[4] integrated functional programming with object orientation; KLND[5], FL[6,7] combined functional with logic programming. LOGRES[8] integrated the object orientation with rule-base programming. Oz[9,10] facilitated the object orientation with concurrency and mobility.
In this paper, we present a new programming language, Fuxi, which is a general-purpose, concurrent, object-oriented, declarative programming language, designed for practical use, and implemented to meet the demands of network computing and mobility; it can also serve as a vehicle for the rapid prototyping of software.
Instead of invention of new language techniques, Fuxi takes a design philosophy: to combine the best ideas found in different languages within previous decades, through selecting some compatible features among these languages and merging them into a single approach in uniformity and conventional form.
Fuxi intends to make programming an enjoyable thing. Fuxi has an interesting combination of features:
1) it takes a conventional syntactic system, that makes the programmers with some experiences of C++, JAVA, use the language without any training;
2) it provides a good balance between static and dynamic binding;
3) it merges calculation, inference and reaction into a unique setting;
4) it provides a good balance between laziness and eagerness of evaluation;
5) it collects active, remote, mobile and persistent objects in a transparent way, through some orthogonal styles;
6) logical guards attached to the fields, provide the type system with some semantic markup, which will be very useful in some web applications;
7) Separate compilation and linking to an architecture-independent object module, make it suitable for network and mobile computing.
Types: Primitive and Reference
The type system of Fuxi is very similar to that of JAVA or C#. The types can be categorized into primitive and reference. Primitive types are built-in types, and denoted by keywords; they include: integral types (byte, short, int, long, ubyte, ushort, uint, ulong, char), float-pointing types (float, double) and Boolean one (bool).
The reference types include: Object, class, array and list. Object is the base of all reference types; every reference type is, directly or indirectly, derived from Object. A class is a grouping of members, where members can be variables or methods. As an applicative language, the list, defined as a set of homogeneously typed values, plays a very important role in Fuxi; The list data structure is an extremely powerful feature of Fuxi; Arrays are special lists, with fixed number of elements.
Variables: Binding, Assignment and Unification
The variables are the fundamental constructs of a language. Fuxi is strongly typed, so every variable declared in Fuxi, must have a type. The syntax of variable declaration is very similar to that of C/C++, as follows:
<type> <identifier>[<initializer>] (1)
and <initializer> is defined as:
= <expression> (2)
:= <expression> (3)
Beneath superficial similarities to C++, Fuxi variables differ from those found in C++, JAVA, and also from those in some dynamical languages such as Dylan[11], in that Fuxi variables can be used to hold values and also can refer to values.
A variable can denote a specific value, or the value of an expression; and it can also denote a store cell, which holds an individual value. We call a specific value, or the value of an expression, as r-value, and the store cell holding an individual value as l-value.
Note here ‘=’ is a unification operator, that causes a variable associated to a r-value; and ‘:=’ is an assignment operator, that causes the value in store cell denoted by the variable changed to the value of expression.
A newly declared variable without initialization denotes nothing, and is called free. The process of giving a free variable a value (an l-value or an r-value) is called binding. The variable bound to a specific value, or r-value, is called bound variable; and the variable bound to an l-value is called reference variable. Sometimes, a variable can also be the alias of another variable (unified to another variable). We can assign an individual value, or r-value to a variable’s l-value (if it holds). A variable can be bound statically at compiling time (with initialization), or dynamically at run time (free variable case).
So, we can depict Fuxi variables as objects with 3 dimensions: types, bindings and values.
For example,
float PI = 3.14159 (4)
double Area := PI * 10 * 10 (5)
The variable ‘PI’ is statically bound to an r-value 3.14159 at compile time, and ‘PI’ is a bound variable. Variable ‘Area’ is statically bound to an l-value; that is, a store cell holding the value of expression PI * 10 * 10, at compile time, even though the storage allocation will be delayed to run time; ‘Area’ is a reference variable.
Sometimes, we need to know the state of a variable. Fuxi provides a built-in function ‘test’. We can use test function to get the state of a variable, as following:
test( <variable-name> ) (6)
The return value of test is an integer; that is, 0 denotes free, 1 denotes bound, 2 denotes reference and 3 denotes an alias. In the example above, test( PI ) will return 1, and test( Area ) will return 2.
Assignment as a Boolean Function
The assignment is subtle in Fuxi. An r-value can be assigned to a variable, if it holds an l-value, or it is free, but we cannot assign something to a variable denoting an r-value. If a variable is free, the process of an assignment will be: first bind this free variable to a store cell, then put the value into the cell. We cannot assign a value to a bound variable. In Fuxi, assignment is a Boolean function; that is, if assignment is executed successfully, a true will be returned, or a false.
Assignment, in Fuxi, takes the form:
<variable-name> := <expression> (7)
For example,
PI := 3.14 (8)
Area := PI * 20.0 * 20.0 (9)
The first assignment will return false, and PI remains to the original value; but Area’s value will be changed after assignment.
Expressions
Fuxi has no real concept of a statement, but instead a program is an evaluation of sequence of expressions. An expression is a group of variables, values, and even some other expressions, connected by operators. The syntax for an expression is usual, just as C++, JAVA, or C#. But expressions in Fuxi can terminate naturally, without any delimiters.
Sequence
Expression sequence is very similar to a block in C/C++, it contains one or more expressions enclosed between curved brackets {}. If a sequence contains only one expression, the expression can be any type, and the value of sequence is that of its element; if a sequence contains two or more expressions, all the expressions must be Boolean, and be evaluated in sequential order until ‘}’ reached, or a false expression encountered. Sequence with more than one elements is just a conjunction of element expressions, with the logic operator && omitted. So, sequence can be considered as a “syntactical sugar” in some cases.
Hello worldcwell 2007-10-25
- 打赏
- 举报
做人要厚道,老子一股亏20.
一九清风 2007-10-25
- 打赏
- 举报
注意股市风险
linjy222 2007-10-25
- 打赏
- 举报
还有分吗？
加载更多回复（14）
