-
Notifications
You must be signed in to change notification settings - Fork 22
/
README
177 lines (134 loc) · 6.23 KB
/
README
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
The Fancy Programming Language
(C) 2010, 2011 Christopher Bertels <chris@fancy-lang.org>
http://www.fancy-lang.org
----------------------------------------------------------------------
Fancy is a dynamic, object-oriented programming language heavily
inspired by Smalltalk, Ruby and Erlang. It supports dynamic code
evaluation (as in Ruby & Smalltalk), class-based mixins, (simple)
pattern matching, runtime introspection & reflection, "monkey
patching" and much more. It runs on Rubinius, the Ruby VM, and thus
has first-class integration with Ruby's core library and any
additional Ruby libraries that run on Rubinius, including most
C-extensions.
It will support concurrency via the actor-model, including first-class
futures and async operation semantics built into the language.
For a quick feature overview, have a look at doc/features.md
There's also a work-in-progress tutorial/book on Fancy here:
https://github.com/fancy-lang/infancy
----------------------------------------------------------------------
It’s still in development, the implementation has evolved from an
interpreter written in C++ to a fully bootstrapped bytecode compiler
for the Rubinius VM (http://www.rubini.us).
You can see the self-hosted compiler implementation in lib/compiler/.
If you want to help out, feel free to contact us:
http://github.com/bakkdoor/fancy/wiki/Get-in-touch
For some example code have a look at the examples/ directory.
There's also lots of test coverage code. Have a look at the tests/
directory for these. The tests are written in FancySpec, a simple
testing library (somewhat similar to Ruby's RSpec). FancySpec's
implementation can be viewed in lib/fancy_spec.fy.
----------------------------------------------------------------------
Compiling / Installing from source:
------------------------------------
Dependencies:
------------------------
- Rubinius.
You'll need at least version 1.2.1 for Fancy to work as expected.
See http://rubini.us/releases/1.2.1/ for more information.
If you want to take advantage of the latest VM improvements, we
suggest using rvm and installing rbx-head.
See http://rvm.beginrescueend.com/ for more information.
- Rake.
- GNU Bison ( version 2.4 and higher otherwise you will get a Segmentation fault ).
- GNU Flex.
Given the tools & libraries mentioned above, Fancy _should_ build without problems
on most *nix systems. We successfully have built Fancy on Debian & Ubuntu, OpenSuSE
and Mac OS X 10.5 and 10.6.
Standard building procedure:
------------------------
Building Fancy is just that easy:
$ cd <fancy_source_path>
$ rake
This should go pretty fast. It actually compiles Fancy's standard
library and compiler several times. Once via the bootstrap compiler
written in Ruby (see boot/rbx-compiler), and then via the self-hosted
compiler (see lib/compiler/) itself.
Once the bootstrapping process is done, you can run the hello world example:
$ ./bin/fancy examples/hello_world.fy
----------------------------
Some technical information:
----------------------------
As the language is running on the Rubinius VM, Fancy shares the same
runtime with Ruby. All of Fancy is built upon Ruby objects, so for
example when you open the String class in Fancy, it's just Ruby's
String class.
Because of this, and because in Fancy's standard library (lib/*.fy) we
can define methods with the same name as they're defined in Ruby (but
taking no arguments), we have decided not to overwrite the Ruby
methods.
This ensures that all Ruby libraries for example can use Ruby's
Kernel#print or any other method in Ruby's kernel and work seamlessly.
Here's an example:
class Object {
def print {
"Print itself to the Console."
Console print: self
}
}
To meet this goal, the Fancy compiler renames Fancy methods taking no
arguments (like the previous "print" example) to a method named
":print". Using explicit parens syntax will allow you to invoke any
Ruby method.
someObject print # Will actually invoke the Fancy ":print" method.
someObject print() # With explicit parens invokes the Ruby method.
Ruby method invocation supports passing a block variable to Ruby as a proc.
class Something {
def open: block {
someRubyMethod(arg0, arg1, &block)
}
}
Something new open: |s| { s work }
# with this syntax, calling ruby's inject is just as easy.
# This example will print the number 6
[1, 2, 3] inject(0) |sum, num| { sum + num } println
What's already working?
------------------------
- Class definitions
(including nested classes that work like modules / namespaces)
- Instance & class method definitions
- Default arguments
- Literal syntax for:
- Strings, Symbols, Integers, Floats, Arrays, Hashes (HashMaps), Blocks (closures),
Ranges, Tuples, Regular Expressions
- Method & Operator calls
- Instance & class variable access
- Dynamic getter and setter method definitions (similar to Ruby's attr_acessor)
- Loops
- Support for closures via Blocks
- Local & non-local returns from Blocks & Methods
- File reading and writing
- Class-Mixins (including methods of one class into another)
- Exception handling (try, catch, finally & retry)
- Simple pattern matching (work-in-progress)
- Calling, using and extending arbitrary Ruby classes and methods
(including C-extensions), as well as passing blocks and splat
arguments to Ruby methods.
What's still missing?
----------------------
- Concurrency stuff (Actor-model based concurrency, Futures etc)
- Some more advanced stuff, e.g. runtime inspection of method calls
via MethodContext etc. (saved for later)
How is it implemented?
-----------------------
- The lexer & parser are built with GNU Flex & GNU Bison.
And used as a Ruby c-extension from Rubinius.
The parser simply invokes methods on Fancy::Parser to build the AST.
See: rbx/parser/parser.y & rbx/parser/parser.rb
- Once the AST is built, we use Rubinius' excellent compiler chain
to compile it to bytecode.
- The bin/fancy file is simply a Rubinius code loader for .fy files.
----------------------------------------------------------------------
Copyright:
-----------
Fancy is licensed under the terms of the BSD license. For more
information on licensing issues have a look at the LICENSE file.