1 ! Copyright (C) 2022 Raghu Ranganathan and Andrea Ferreti.
2 ! See https://factorcode.org/license.txt for BSD license.
3 USING: alien.c-types arrays assocs command-line continuations
4 editors help help.markup help.syntax help.vocabs inspector io
5 io.directories io.files io.files.types kernel lexer math
6 math.factorials math.functions math.primes memory namespaces
7 parser prettyprint ranges see sequences stack-checker strings
8 threads tools.crossref tools.test tools.time ui.gadgets.panes
9 ui.tools.deploy vocabs vocabs.loader vocabs.refresh words
10 io.servers http io.sockets io.launcher channels
11 concurrency.distributed channels.remote help.cookbook
15 ARTICLE: "tour-concatenative" "Concatenative Languages"
16 Factor is a { $emphasis concatenative } programming language in the spirit of Forth. What is a concatenative language?
18 To understand concatenative programming, imagine a world where every value is a function, and the only operation
19 allowed is function composition. Since function composition is so pervasive, it is implicit, and functions can be
20 juxtaposed in order to compose them. So if { $snippet "f" } and { $snippet "g" } are two functions, their composition is just { $snippet "f g" } (unlike in
21 mathematical notation, functions are read from left to right, so this means first execute { $snippet "f" } , then execute { $snippet "g" } ).
23 This requires some explanation, since we know functions often have multiple inputs and outputs, and it is not always
24 the case that the output of { $snippet "f" } matches the input of { $snippet "g" } . For instance, { $snippet "g" } may need access to values computed by earlier
25 functions. But the only thing that { $snippet "g" } can see is the output of { $snippet "f" } , so the output of { $snippet "f" } is the whole state of the
26 world as far as { $snippet "g" } is concerned. To make this work, functions have to thread the global state, passing it to each other.
28 There are various ways this global state can be encoded. The most naive would use a hashmap that maps variable names
29 to their values. This turns out to be too flexible: if every function can access any piece of global state, there is
30 little control on what functions can do, little encapsulation, and ultimately programs become an unstructured mess of
31 routines mutating global variables.
33 It works well in practice to represent the state of the world as a stack. Functions can only refer to the topmost
34 element of the stack, so that elements below it are effectively out of scope. If a few primitives are given to manipulate a
35 few elements on the stack (e.g., { $link swap } , that exchanges the top two elements on the stack), then it becomes possible to
36 refer to values down the stack, but the farther the value is down the stack, the harder it becomes to refer to it.
38 So, functions are encouraged to stay small and only refer to the top two or three elements on the stack. In a sense,
39 there is no distinction between local and global variables, but values can be more or less local depending on their
40 distance from the top of the stack.
42 Notice that if every function takes the state of the whole world and returns the next state, its input is never used
43 anymore. So, even though it is convenient to think of pure functions as receiving a stack as input and outputting a stack,
44 the semantics of the language can be implemented more efficiently by mutating a single stack.
47 ARTICLE: "tour-stack" "Playing with the stack"
49 Let us start looking what Factor actually feels like. Our first words will be literals, like { $snippet "3" } , { $snippet "12.58" } or
50 { $snippet "\"Chuck Norris\"" } . Literals can be thought as functions that push themselves on the stack. Try writing { $snippet "5" } in the listener and
51 then press enter to confirm. You will see that the stack, initially empty, now looks like
55 You can enter more than one number, separated by spaces, like { $snippet "7 3 1" } , and get
63 (the interface shows the top of the stack on the bottom). What about operations? If you write { $snippet "+" } , you will run the
64 { $snippet "+" } function, which pops the two topmost elements and pushes their sum, leaving us with
71 You can put additional inputs in a single line, so for instance { $snippet "- *" } will leave the single number { $snippet "15" } on the stack (do you see why?).
73 You may end up pushing many values to the stack, or end up with an incorrect result. You can then clear the stack with the
74 keystroke { $snippet "Alt+Shift+K" } .
76 The function { $snippet "." } (a period or a dot) prints the item at the top of the stack, while popping it out of the stack, leaving the stack empty.
78 If we write everything on one line, our program so far looks like
80 { $code "5 7 3 1 + - * ." }
82 which shows Factor's peculiar way of doing arithmetic by putting the arguments first and the operator last - a
83 convention which is called Reverse Polish Notation (RPN). Notice that
84 RPN requires no parenthesis, unlike the polish notation of Lisps where
85 the operator comes first, and RPN requires no precedence rules, unlike the infix notation
86 used in most programming languages and in everyday arithmetic. For instance in any Lisp, the same
87 computation would be written as
89 { $code "(* 5 (- 7 (+ 3 1)))" }
91 and in familiar infix notation
93 { $code "(7 - (3 + 1)) * 5" }
95 Also notice that we have been able to split our computation onto many lines or combine it onto fewer lines rather arbitrarily, and that each line made sense in itself.
98 ARTICLE: "tour-first-word" "Defining our first word"
100 We will now define our first function. Factor has slightly odd naming of functions: since functions are read from left
101 to right, they are simply called { $strong "words" } , and this is what we'll call them from now on. Modules in Factor define
102 words in terms of previous words and these sets of words are then called { $strong "vocabularies" } .
104 Suppose we want to compute the factorial. To start with a concrete example, we'll compute the factorial of { $snippet "10" }
105 , so we start by writing { $snippet "10" } on the stack. Now, the factorial is the product of the numbers from {
106 $snippet "1" } to { $snippet "10" } , so we should produce such a list of numbers first.
108 The word to produce a range is called { $link [a..b] } (tokenization is trivial in Factor because words are
109 always separated by spaces, so this allows you to use any combination of non-whitespace characters as the name of a word;
110 there are no semantics to the { $snippet "[" } , the { $snippet ".." } and the { $snippet "]" } in { $link [a..b] }
111 since it is just a token like { $snippet "foo" } or { $snippet "bar" } ).
113 The range we want starts with { $snippet "1" } , so we can use the simpler word { $link [1..b] } that assumes the
114 range starts at { $snippet "1" } and only expects the value at the top of the range to be on the stack. If you write {
115 $link [1..b] } in the listener, Factor will prompt you with a choice, because the word { $link [1..b] } is
116 not imported by default. Factor is able to suggest you import the { $vocab-link "ranges" } vocabulary, so choose that
119 You should now have on your stack a rather opaque structure which looks like
121 { $code "T{ range f 1 10 1 }" }
123 This is because our range functions are lazy and only create the range when we attempt to use it. To confirm that we
124 actually created the list of numbers from { $snippet "1" } to { $snippet "10" } , we convert the lazy response on the
125 stack into an array using the word { $link >array } . Enter that word and your stack should now look like
127 { $code "{ 1 2 3 4 5 6 7 8 9 10 }" }
131 Next, we want to take the product of those numbers. In many functional languages, this could be done with a function
132 called reduce or fold. Let's look for one. Pressing { $snippet "F1" } in the listener will open a contextual help system
133 , where you can search for { $link reduce } . It turns out that { $link reduce } is actually the word we are
134 looking for, but at this point it may not be obvious how to use it.
136 Try writing { $snippet "1 [ * ] reduce" } and look at the output: it is indeed the factorial of { $snippet "10" } .
137 Now, { $link reduce } usually takes three arguments: a sequence (and we had one on the stack), a starting value i
138 (this is the { $snippet "1" } we put on the stack next) and a binary operation. This must certainly be the { $link * }
139 , but what about those square brackets around the { $link * } ?
141 If we had written just { $link * } , Factor would have tried to apply multiplication to the topmost two elements
142 on the stack, which is not what we wanted. What we need is a way to get a word onto the stack without applying it.
143 Keeping to our textual metaphor, this mechanism is called a { $strong "quotation" } . To quote one or more words, you just surround them
144 with { $link POSTPONE: [ } and { $link POSTPONE: ] } (leaving spaces!). What you get is an anonymous function, which can be
145 shuffled around, manipulated and called.
147 Let's type the word { $link drop } into the listener to empty the stack, and try writing what we have done so
148 far in a single line: { $snippet "10 [1..b] 1 [ * ] reduce" } . This will leave { $snippet "3628800" } on the stack as
151 We now want to define a word for factorial that can be used whenever we want a factorial. We will call our word { $snippet "fact" }
152 "(" although { $snippet "!" } is customarily used as the symbol for factorial, in Factor { $snippet "!" }
153 is the word used for comments ")" . To define it, we first need to use the word { $link POSTPONE: : } . Then we put the name of
154 the word being defined, then the { $strong "stack effects" } and finally the body, ending with the { $link POSTPONE: ; } word:
156 { $code ": fact ( n -- n! ) [1..b] 1 [ * ] reduce ;" }
158 What is a stack effect? In our case it is { $snippet "( n -- n! )" } . Stack effects are how you document the
159 inputs from the stack and outputs to the stack for your word. You can use any identifier to name the stack elements, here we
160 use { $snippet "n" } . Factor will perform a consistency check that the number of inputs and outputs you specify agrees
161 with what the body does.
165 { $code ": fact ( m n -- ..b ) [1..b] 1 [ * ] reduce ;" }
167 Factor will signal an error that the 2 inputs { $snippet "m" } and { $snippet "n" } are not consistent with the
168 body of the word. To restore the previous correct definition press { $snippet "Ctrl+P" } two times to get back to the
169 previous input and then enter it.
171 The stack effects in definitions act both as a documentation tool and as a very simple type system, which helps to catch a few errors.
173 In any case, you have succesfully defined your first word: if you write { $snippet "10 fact" } in the listener you
176 Notice that the { $snippet "1 [ * ] reduce" } part of the definition sort of makes sense on its own, being the product of a sequence. The nice thing about a concatenative language is that we can just factor this part out and write
178 { $code ": prod ( {x1,...,xn} -- x1*...*xn ) 1 [ * ] reduce ;
180 : fact ( n -- n! ) [1..b] prod ;" }
182 Our definitions have become simpler and there was no need to pass parameters, rename local variables, or do anything
183 else that would have been necessary to refactor our function in most languages.
185 Of course, Factor already has a word for calculating factorial (there is a whole { $vocab-link "math.factorials" }
186 vocabulary, including many variants of the usual factorial) and a word for calculating product "(" { $link product } in the
187 { $vocab-link "sequences" } vocabulary), but as it often happens, introductory examples overlap with the standard library.
190 ARTICLE: "tour-parsing-words" "Parsing Words"
191 If you've been paying close attention so far, you will realize that you have been lied to. { $emphasis "Most" } words act on the stack in order
192 , but there a few words like { $link POSTPONE: [ } , { $link POSTPONE: ] } , { $link POSTPONE: : } and { $link POSTPONE: ; } that don't seem to follow this rule.
194 These are { $strong "parsing words" } and they behave differently from ordinary words like { $snippet "5" } , { $link [1..b] } or { $link drop } . We will cover
195 these in more detail when we talk about metaprogramming, but for now it is enough to know that parsing words are special.
197 They are not defined using the { $link POSTPONE: : } word, but with the word { $link POSTPONE: SYNTAX: } instead. When a parsing words is encountered, it
198 can interact with the parser using a well-defined API to influence how successive words are parsed. For instance { $link POSTPONE: : }
199 asks for the next token from the parser until { $link POSTPONE: ; } is found and tries to compile that stream of tokens into a word
202 A common use of parsing words is to define literals. For instance { $link POSTPONE: { } is a parsing word that starts an array
203 definition and is terminated by { $link POSTPONE: } } . Everything in-between is part of the array. An example of array that we have seen before is
204 { $snippet "{ 1 2 3 4 5 6 7 8 9 10 } " } .
206 There are also literals for hashmaps, { $snippet "H{ { \"Perl\" \"Larry Wall\" } { \"Factor\" \"Slava Pestov\" } { \"Scala\" \"Martin Odersky\" } } " }
207 , and byte arrays, { $snippet "B{ 1 14 18 23 } " } .
209 Other uses of parsing words include the module system, the object-oriented features of Factor, enums, memoized functions
210 , privacy modifiers and more. In theory, even { $link POSTPONE: SYNTAX: } can be defined in terms of itself, but the
211 system has to be bootstrapped somehow.
215 ARTICLE: "tour-stack-shuffling" "Stack Shuffling"
216 Now that you know the basics of Factor, you may want to start assembling more complex words. This may sometimes
217 require you to use variables that are not on top of the stack, or to use variables more than once. There are a few words that
218 can be used to help with this. I mention them now since you need to be aware of them, but I warn you that using too many
219 of these words to manipulate the stack will cause your code to quickly become harder to read and write. Stack shuffling
220 requires mentally simulating moving values on a stack, which is not a natural way to program. In the next section we'll
221 see a much more effective way to handle most needs.
223 Here is a list of the most common shuffling words together with their effect on the stack. Try them in the listener to
224 get a feel for how they manipulate the stack.
238 For a deeper look at stack shuffling, see the { $link "cookbook-colon-defs" } .
241 ARTICLE: "tour-combinators" "Combinators"
243 Although the words mentioned in the previous paragraph are occasionally useful (especially the simpler { $link dup } , { $link drop }
244 and { $link swap } ), you should write code that does as little stack shuffling as possible. This requires practice getting the
245 function arguments in the right order. Nevertheless, there are certain common patterns of needed stack manipulation that
246 are better abstracted away into their own words.
248 Suppose we want to define a word to determine whether a given number { $snippet "n" } is prime. A simple algorithm is to test each
249 number from { $snippet "2" } to the square root of { $snippet "n" } and see whether it is a divisor of { $snippet "n" } . In this case, { $snippet "n" } is used in two places: as an upper bound for the sequence, and as the number to test for divisibility.
251 The word { $link bi } applies two different quotations to the single element on the stack above them, and this is precisely
252 what we need. For instance { $snippet "5 [ 2 * ] [ 3 + ] bi" } yields
258 { $link bi } applies the quotation { $snippet "[ 2 * ]" } to the value { $snippet "5" } and then the quotation { $snippet "[ 3 + ]" } to the value { $snippet "5" } leaving us
259 with { $snippet "10" } and then { $snippet "8" } on the stack. Without { $link bi } , we would have to first { $link dup } { $snippet "5" } , then multiply, and then { $link swap } the
260 result of the multiplication with the second { $snippet "5" } , so we could do the addition
265 You can see that { $link bi } replaces a common pattern of { $link dup } , then calculate, then { $link swap } and calculate again.
267 To continue our prime example, we need a way to make a range starting from { $snippet "2" } . We can define our own word for this { $snippet "[2..b]" } , using the { $link [a..b] } word:
269 : [2..b] ( n -- {2,...,n} ) 2 swap [a..b] ; inline
272 What's up with that { $snippet "inline" } word? This is one of the modifiers we can use after defining a word, another one being
273 { $snippet "recursive" } . This will allow us to have the definition of a short word inlined wherever it is used, rather than incurring
276 Try our new { $snippet "[2..b]" } word and see that it works:
281 Using { $snippet "[2..b]" } to produce the range of numbers from { $snippet "2" } to the square root of an { $snippet "n" } that is already on the stack is
282 easy: { $snippet "sqrt floor [2..b]" } (technically { $link floor } isn't necessary here, as { $link [a..b] } works for non-integer bounds). Let's try
285 16 sqrt [2..b] >array .
288 Now, we need a word to test for divisibility. A quick search in the online help shows that { $link divisor? } is the word we
289 want. It will help to have the arguments for testing divisibility in the other direction, so we define { $snippet "multiple?" } ":"
291 : multiple? ( a b -- ? ) swap divisor? ; inline
293 We can verify that both of these return { $link t } .
299 Since we're going to use { $link bi } in our { $snippet "prime?" } definition, we need a second quotation. Our second
300 quotation needs to test for a value in the range being a divisor of { $snippet "n" } - in other words we need to partially apply the word { $snippet "multiple?" } . This can be done with the word { $link curry } , like this: { $snippet "[ multiple? ] curry" } .
302 Finally, once we have the range of potential divisors and the test function on the stack, we can test whether any
303 element satisfied divisibility with { $link any? } and then negate that answer with { $link not } . Our full definition of { $snippet "prime" } looks like
305 : prime? ( n -- ? ) [ sqrt [2..b] ] [ [ multiple? ] curry ] bi any? not ;
307 Altough the definition of { $snippet "prime" } is complicated, the stack shuffling is minimal and is only used in the small helper
308 functions, which are simpler to reason about than { $snippet "prime?" } .
310 Notice that { $snippet "prime?" } uses two levels of quotation nesting since { $link bi } operates on two quotations, and our second
311 quotation contains the word { $link curry } , which also operates on a quotation. In general, Factor words tend to be rather shallow,
312 using one level of nesting for each higher-order function, unlike Lisps or more generally languages based on the lambda
313 calculus, which use one level of nesting for each function, higher-order or not.
315 { $link bi } and its relative { $link tri } are a small subset of the shuffle words you will use in Factor. You ahouls also become familiar with
316 { $link bi } , { $link tri } , and { $link bi@ } by reading about them in the online help and trying them out in the listener.
320 ARTICLE: "tour-vocabularies" "Vocabularies"
322 It is now time to start writing your functions in files and learn how to import them in the listener. Factor organizes
323 words into nested namespaces called { $strong "vocabularies" } . You can import all names from a vocabulary with the word { $link POSTPONE: USE: } .
324 In fact, you may have seen something like
326 { $code "USE: ranges" }
328 when you asked the listener to import the word { $link [1..b] } for you. You can also use more than one vocabulary at a time
329 with the word { $link POSTPONE: USING: } , which is followed by a list of vocabularies and terminated by { $link POSTPONE: ; } , like
331 { $code "USING: ranges sequences ;" }
333 Finally, you define the vocabulary where your definitions are stored with the word { $link POSTPONE: IN: } . If you search the online
334 help for a word you have defined so far, like { $link prime? } , you will see that your definitions have been grouped under the
335 default { $vocab-link "scratchpad" } vocabulary. By the way, this shows that the online help automatically collects information about your
336 own words, which is a very useful feature.
338 There are a few more words, like { $link POSTPONE: QUALIFIED: } , { $link POSTPONE: FROM: } , { $link POSTPONE: EXCLUDE: } and { $link POSTPONE: RENAME: } , that allow more fine-grained control
339 over the imports, but { $link POSTPONE: USING: } is the most common.
341 On disk, vocabularies are stored under a few root directories, much like with the classpath in JVM languages. By
342 default, the system starts looking up into the directories { $snippet "basis" } , { $snippet "core" } , { $snippet "extra" } , { $snippet "work" } under the Factor home. You can
343 add more, both at runtime with the word { $link add-vocab-root } , and by creating a configuration file { $snippet ".factor-rc" } , but for now
344 we will store our vocabularies under the { $snippet "work" } directory, which is reserved for the user.
346 Generate a template for a vocabulary writing
348 { $code "USE: tools.scaffold
349 \"github.tutorial\" scaffold-work" }
351 You will find a file { $snippet "work/github/tutorial/tutorial.factor" } containing an empty vocabulary. Factor integrates with
352 many editors, so you can try { $snippet "\"github.tutorial\" edit" } ":" this will prompt you to choose your favourite editor, and use that
353 editor to open the newly created vocabulary.
355 You can add the definitions of the previous paragraph, so that it looks like
358 ! Copyright (C) 2014 Andrea Ferretti.
359 ! See https://factorcode.org/license.txt for BSD license.
363 : [2..b] ( n -- {2,...,n} ) 2 swap [a..b] ; inline
365 : multiple? ( a b -- ? ) swap divisor? ; inline
367 : prime? ( n -- ? ) [ sqrt [2..b] ] [ [ multiple? ] curry ] bi any? not ;
369 Since the vocabulary was already loaded when you scaffolded it, we need a way to refresh it from disk. You can do this
370 with { $snippet "\"github.tutorial\" refresh" } . There is also a { $link refresh-all } word, with a shortcut { $snippet "F2" } .
372 You will be prompted a few times to use vocabularies, since your { $link POSTPONE: USING: } statement is empty. After having accepted
373 all of them, Factor suggests you a new header with all the needed imports:
375 USING: kernel math.functions ranges sequences ;
378 Now that you have some words in your vocabulary, you can edit, say, the { $snippet "multiple?" } word with { $snippet "\\ multiple? edit" } . You
379 will find your editor open on the relevant line of the right file. This also works for words in the Factor distribution,
380 although it may be a bad idea to modify them.
382 This { $link POSTPONE: \ } word requires a little explanation. It works like a sort of escape, allowing us to put a reference to the
383 next word on the stack, without executing it. This is exactly what we need, because { $link edit } is a word that takes words
384 themselves as arguments. This mechanism is similar to quotations, but while a quotation creates a new anonymous function,
385 here we are directly refering to the word { $snippet "multiple?" } .
387 Back to our task, you may notice that the words { $snippet "[2..b]" } and { $snippet "multiple?" } are just helper functions that you may not
388 want to expose directly. To hide them from view, you can wrap them in a private block like this
393 : [2..b] ( n -- {2,...,n} ) 2 swap [a..b] ; inline
395 : multiple? ( a b -- ? ) swap divisor? ; inline
400 After making this change and refreshed the vocabulary, you will see that the listener is not able to refer to words
401 like { $snippet "[2..b]" } anymore. The { $link POSTPONE: <PRIVATE } word works by putting all definitions in the private block under a different
402 vocabulary, in our case { $snippet "github.tutorial.private" } .
404 You can have more than one { $link POSTPONE: <PRIVATE } block in a vocabulary, so feel free to organize them as you find necessary.
406 It is still possible to refer to words in private vocabularies, as you can confirm by searching for { $snippet "[2..b]" } in the
407 browser, but of course this is discouraged, since people do not guarantee any API stability for private words. Words
408 under { $snippet "github.tutorial" } can refer to words in { $snippet "github.tutorial.private" } directly, like { $link prime? } does.
412 ARTICLE: "tour-tests-docs" "Tests and Documentation"
414 This is a good time to start writing some unit tests. You can create a skeleton with
416 \"github.tutorial\" scaffold-tests
418 You will find a generated file under { $snippet "work/github/tutorial/tutorial-tests.factor" } , that you can open with
419 { $snippet "\"github.tutorial\" edit-tests" } . Notice the line
422 USING: tools.test github.tutorial ;
424 that imports the unit testing module as well as your own. We will only test the public { $snippet "prime?" } function.
426 Tests are written using the { $link POSTPONE: unit-test } word, which expects two quotations: the first one containing the expected
427 outputs, and the second one containing the words to run in order to get that output. Add these lines to
428 { $snippet "github.tutorial-tests" } ":"
431 { t } [ 2 prime? ] unit-test
432 { t } [ 13 prime? ] unit-test
433 { t } [ 29 prime? ] unit-test
434 { f } [ 15 prime? ] unit-test
435 { f } [ 377 prime? ] unit-test
436 { f } [ 1 prime? ] unit-test
437 { t } [ 20750750228539 prime? ] unit-test
440 You can now run the tests with { $snippet "\"github.tutorial\" test" } . You will see that we have actually made a mistake, and
441 pressing { $snippet "F3" } will show more details. It seems that our assertions fails for { $snippet "2" } .
443 In fact, if you manually try to run our functions for { $snippet "2" } , you will see that our definition of { $snippet "[2..b]" } returns { $snippet "{ 2 }" }
444 for { $snippet "2 sqrt" } , due to the fact that the square root of two is less than two, so we get a descending interval. Try making a
445 fix so that the tests now pass.
447 There are a few more words to test errors and inference of stack effects. Using { $link POSTPONE: unit-test } suffices for now, but later on
448 you may want to check the main documentation on { $link "tools.test" } .
450 We can also add some documentation to our vocabulary. Autogenerated documentation is always available for user-defined
451 words (even in the listener), but we can write some useful comments manually, or even add custom articles that will
452 appear in the online help. Predictably, we start with { $snippet "\"github.tutorial\" scaffold-docs" } and
453 { $snippet "\"github.tutorial\" edit-docs" } .
455 The generated file { $snippet "work/github/tutorial-docs.factor" } imports { $vocab-link "help.markup" } and { $vocab-link "help.syntax" } . These two vocabularies
456 define words to generate documentation. The actual help page is generated by the { $link POSTPONE: HELP: } parsing word.
458 The arguments to { $link POSTPONE: HELP: } are nested array of the form { $snippet "{ $directive content... }" } . In particular, you see here the
459 directives { $link $values } and { $link $description } , but a few more exist, such as { $link $errors } , { $link $examples } and { $link $see-also } .
461 Notice that the type of the output { $snippet "?" } has been inferred to be boolean. Change the first lines to look like
464 USING: help.markup help.syntax kernel math ;
472 { $description \"Tests if n is prime. n is assumed to be a positive integer.\" } ;
474 and refresh the { $snippet "github.tutorial" } vocabulary. If you now look at the help for { $snippet "prime?" } , for instance with
475 { $snippet "\\ prime? help" } , you will see the updated documentation.
477 You can also render the directives in the listener for quicker feedback. For instance, try writing
485 The help markup contains a lot of possible directives, and you can use them to write stand-alone articles in the help
486 system. Have a look at some more with { $snippet "\"element-types\" help" } .
489 ARTICLE: "tour-objects" "The Object System"
491 Although it is not apparent from what we have said so far, Factor has object-oriented features, and many core words
492 are actually method invocations. To better understand how objects behave in Factor, a quote is in order:
494 { $emphasis "\"I invented the term Object-Oriented and I can tell you I did not have C++ in mind.\"
497 The term object-oriented has as many different meanings as people using it. One point of view - which was actually
498 central to the work of Alan Kay - is that it is about late binding of function names. In Smalltalk, the language where this
499 concept was born, people do not talk about calling a method, but rather sending a message to an object. It is up to the
500 object to decide how to respond to this message, and the caller should not know about the implementation. For instance,
501 one can send the message { $link map } both to an array and a linked list, but internally the iteration will be handled
504 The binding of the message name to the method implementation is dynamic, and this is regarded as the core strength of
505 objects. As a result, fairly complex systems can evolve from the cooperation of independent objects that do not mess with
506 each other's internals.
508 To be fair, Factor is very different from Smalltalk, but still there is the concept of classes, and generic words can
509 defined having different implementations on different classes.
511 Some classes are builtin in Factor, such as { $link string } , { $link boolean } , { $link fixnum } or { $link word } . Next, the most common way to
512 define a class is as a { $strong "tuple" } . Tuples are defined with the { $link POSTPONE: TUPLE: } parsing word, followed by the tuple name and the
513 fields of the class that we want to define, which are called { $strong "slots" } in Factor parlance.
515 Let us define a class for movies:
518 TUPLE: movie title director actors ;
520 This also generates setters { $snippet ">>title" } , { $snippet ">>director" } and { $snippet ">>actors" } and getters { $snippet "title>>" } , { $snippet "director>>" } and { $snippet "actors>>" } .
521 For instance, we can create a new movie with
525 \"The prestige\" >>title
526 \"Christopher Nolan\" >>director
527 { \"Hugh Jackman\" \"Christian Bale\" \"Scarlett Johansson\" } >>actors
529 We can also shorten this to
532 \"The prestige\" \"Christopher Nolan\"
533 { \"Hugh Jackman\" \"Christian Bale\" \"Scarlett Johansson\" }
537 The word { $link boa } stands for 'by-order-of-arguments'. It is a constructor that fills the slots of the tuple with the
538 items on the stack in order. { $snippet "movie boa" } is called a { $strong "boa constructor" } , a pun on the Boa Constrictor. It is customary to
539 define a most common constructor called { $snippet "<movie>" } , which in our case could be simply
542 : <movie> ( title director actors -- movie ) movie boa ;
544 In fact, boa constructor are so common, that the above line can be shortened to
549 In other cases, you may want to use some defaults, or compute some fields.
551 The functional minded will be worried about the mutability of tuples. Actually, slots can be declared to be "read-only"
552 with { $snippet "{ slot-name read-only } " } . In this case, the field setter will not be generated, and the value must be set a the
553 beginning with a boa constructor. Other valid slot modifiers are { $link POSTPONE: initial: } - to declare a default value - and a class word
554 , such as { $snippet "integer" } , to restrict the values that can be inserted.
556 As an example, we define another tuple class for rock bands
560 { keyboards string read-only }
561 { guitar string read-only }
562 { bass string read-only }
563 { drums string read-only } ;
565 : <band> ( keyboards guitar bass drums -- band ) band boa ;
567 together with one instance
570 \"Richard Wright\" \"David Gilmour\" \"Roger Waters\" \"Nick Mason\" <band>
572 Now, of course everyone knows that the star in a movie is the first actor, while in a rock band it is the bass player.
573 To encode this, we first define a { $strong "generic word" }
576 GENERIC: star ( item -- star )
578 As you can see, it is declared with the parsing word { $link POSTPONE: GENERIC: } and declares its stack effects but it has no
579 implementation right now, hence no need for the closing { $link POSTPONE: ; } . Generic words are used to perform dynamic dispatch. We can define
580 implementations for various classes using the word { $link POSTPONE: M: }
583 M: movie star actors>> first ;
585 M: band star bass>> ;
587 If you write { $snippet "star ." } two times, you can see the different effect of calling a generic word on instances of different
590 Builtin and tuple classes are not all that there is to the object system: more classes can be defined with set
591 operations like { $link POSTPONE: UNION: } and { $link POSTPONE: INTERSECTION: } . Another way to define a class is as a { $strong "mixin" } .
593 Mixins are defined with the { $link POSTPONE: MIXIN: } word, and existing classes can be added to the mixin like so:
596 INSTANCE: class mixin
598 Methods defined on the mixin will then be available on all classes that belong to the mixin. If you are familiar with
599 Haskell typeclasses, you will recognize a resemblance, although Haskell enforces at compile time that instance of
600 typeclasses implement certain functions, while in Factor this is informally specified in documentation.
602 Two important examples of mixins are { $link sequence } and { $link assoc } . The former defines a protocol that is available to all
603 concrete sequences, such as strings, linked lists or arrays, while the latter defines a protocol for associative arrays,
604 such as hashtables or association lists.
606 This enables all sequences in Factor to be acted upon with a common set of words, while differing in implementation
607 and minimizing code repetition (because only few primitives are needed, and other operations are defined for the { $link sequence }
608 class). The most common operations you will use on sequences are { $link map } , { $link filter } and { $link reduce } , but there are many more
609 - as you can see with { $snippet "\"sequences\" help" } .
612 ARTICLE: "tour-tools" "Learning the Tools"
614 A big part of the productivity of Factor comes from the deep integration of the language and libraries with the tools around
615 them, which are embodied in the listener. Many functions of the listener can be used programmatically, and vice versa.
616 You have seen some examples of this:
619 { " The help is navigable online, but you can also invoke it with " { $link help } " and print help items with " { $link print-content } " ; " }
620 { " The " { $snippet "F2" } " shortcut or the words " { $link refresh } " and " { $link refresh-all } " can be used to refresh vocabularies from disk while continuing working in the listener; " }
621 { " The " { $link edit } " word gives you editor integration, but you can also click on file names in the help pages for vocabularies to open them. " }
624 The refresh is an efficient mechanism. Whenever a word is redefined, words that depend on it are recompiled against the new
625 defition. You can check by yourself doing
628 : inc ( x -- y ) 1 + ;
629 : inc-print ( x -- ) inc . ;
636 : inc ( x -- y ) 2 + ;
640 This allows you to keep a listener open, improve your definitions, periodically save your definitions to a file
641 and refresh to view your changes, without ever having to reload Factor.
643 You can also save the state of your current session with the word { $link save-image } and later restore it by starting Factor with
646 ./factor -i=path-to-image
648 In fact, Factor is image-based and only uses files when loading and refreshing vocabularies.
650 The power of the listener does not end here. Elements of the stack can be inspected by clicking on them, or by calling the
651 word { $link inspector } . For instance try writing
654 TUPLE: trilogy first second third ;
656 : <trilogy> ( first second third -- trilogy ) trilogy boa ;
658 \"A new hope\" \"The Empire strikes back\" \"Return of the Jedi\" <trilogy>
659 \"George Lucas\" 2array
661 You will get an item that looks like
664 { ~trilogy~ \"George Lucas\" }
666 on the stack. Try clicking on it: you will be able to see the slots of the array. You can inspect a slot shown in the inspector by double clicking on it. This is extremely useful for interactive prototyping. Special objects can customize the inspector
667 by implementing the { $link content-gadget } method.
669 There is another inspector for errors. Whenever an error arises, it can be inspected with { $snippet "F3" } . This allows you to investigate
670 exceptions, bad stack effect declarations and so on. The debugger allows you to step into code, both forwards and
671 backwards, and you should take a moment to get some familiarity with it. You can also trigger the debugger manually, by
672 entering some code in the listener and pressing { $snippet "Ctrl+w" } .
674 The listener has provisions for benchmarking code. As an example, here is an intentionally inefficient Fibonacci:
678 : fib ( n -- f(n) ) dup 2 < [ ] [ fib-rec ] if ;
679 : fib-rec ( n -- f(n) ) [ 1 - fib ] [ 2 - fib ] bi + ;
681 (notice the use of { $link POSTPONE: DEFER: } to define two mutually "recursive" words). You can benchmark the running time writing { $snippet "40 fib" }
682 and then pressing Ctrl+t instead of Enter. You will get timing information, as well as other statistics. Programmatically
683 , you can use the { $link time } word on a quotation to do the same.
685 You can also add watches on words, to print inputs and outputs on entry and exit. Try writing
690 and then run { $snippet "10 fib" } to see what happens. You can then remove the watch with { $snippet "\\ fib reset" } .
692 Another useful tool is the { $vocab-link "lint" } vocabulary. This scans word definitions to find duplicated code that can be factored
693 out. As an example, let us define a word to check if a string starts with another one. Create a test vocabulary
696 \"lintme\" scaffold-work
698 and add the following definition:
701 USING: kernel sequences ;
704 : startswith? ( str sub -- ? ) dup length swapd head = ;
706 Load the lint tool with { $snippet "USE: lint" } and write { $snippet "\"lintme\" lint-vocab" } . You will get a report mentioning that the word sequence
707 { $snippet "length swapd" } is already used in the word { $link (split) } of { $vocab-link "splitting.private" } , hence it could be factored out.
709 Modifying the source of a word in the standard library is unadvisable - let alone a private one - but
710 in more complex cases the lint tool can help you prevent code duplication. It is not unusual that Factor has a word that does exactly what you want, owing to its massive standard library. It is a good idea to lint your vocabularies from
711 time to time, to avoid code duplication and as a good way to discover library words that you may have accidentally redefined
714 Finally, there are a few utilities to inspect words. You can see the definition of a word in the help tool, but a quicker
715 way can be { $link see } . Or, vice versa, you may use { $link usage. } to inspect the callers of a given word. Try { $snippet "\\ reverse see" } and
716 { $snippet "\\ reverse usage." } .
719 ARTICLE: "tour-metaprogramming" "Metaprogramming"
721 We now venture into the metaprogramming world, and write our first parsing word. By now, you have seen a lot of
722 parsing words, such as { $link POSTPONE: [ } . { $link POSTPONE: { } , { $link POSTPONE: H{ } , { $link POSTPONE: USE: } , { $link POSTPONE: IN: } , { $link POSTPONE: <PRIVATE } , { $link POSTPONE: GENERIC: } and so on. Each of those is defined with the
723 parsing word { $link POSTPONE: SYNTAX: } and interacts with Factor's parser.
725 The parser accumulates tokens onto an accumulator vector, unless it finds a parsing word, which is executed immediately.
726 Since parsing words execute at compile time, they cannot interact with the stack, but they have access to the
727 accumulator vector. Their stack effect must be { $snippet "( accum -- accum )" } . Usually what they do is ask the parser for some more tokens,
728 do something with them, and finally push a result on the accumulator vector with the word { $snippet "suffix!" } .
730 As an example, we will define a literal for DNA sequences. A DNA sequence is a sequence of one of the bases cytosine,
731 guanine, adenine and thymine, which we will denote by the letters c, g, a, t. Since there are four possible bases, we
732 can encode each with two bits. Let use define a word that operates on characters:
735 : dna>bits ( token -- bits ) {
736 { CHAR: a [ { f f } ] }
737 { CHAR: c [ { t t } ] }
738 { CHAR: g [ { f t } ] }
739 { CHAR: t [ { t f } ] }
742 where the first bit represents whether the basis is a purine or a pyrimidine, and the second one identifies bases that
745 Our aim is to read a sequence of letters a, c, g, "t" - possibly with spaces - and convert them to a bit array. Factor
746 supports bit arrays, and literal bit arrays look like { $snippet "?{ f f t }" } .
748 Our syntax for DNA will start with { $snippet "DNA{" } and get all tokens until the closing token { $snippet "}" } is found. The intermediate
749 tokens will be put into a string, and using our function { $snippet "dna>bits" } we will map this string into a bit array. To read
750 tokens, we will use the word { $link parse-tokens } . There are a few higher-level words to interact with the parser, such as { $link parse-until }
751 and { $link parse-literal } , but we cannot apply them in our case, since the tokens we will find are just sequences of a
752 c g t, instead of valid Factor words. Let us start with a simple approximation that just reads tokens between our
753 delimiters and outputs the string obtained by concatenation
756 SYNTAX: DNA{ \"}\" parse-tokens concat suffix! ;
758 You can test the effect by doing { $snippet "DNA{ a ccg t a g }" } , which should output { $snippet "\"accgtag\"" } . As a second approximation, we
759 transform each letter into a boolean pair:
762 SYNTAX: DNA{ \"}\" parse-tokens concat
763 [ dna>bits ] { } map-as suffix! ;
765 Notice the use of { $link map-as } instead of { $link map } . Since the target collection is not a string, we did not use { $link map } , which
766 preserves the type, but { $link map-as } , which take as an additional argument an examplar of the target collection - here { $snippet "{ }" } .
767 Our "final" version flattens the array of pairs with { $link concat } and finally makes into a bit array:
770 SYNTAX: DNA{ \"}\" parse-tokens concat
771 [ dna>bits ] { } map-as
772 concat >bit-array suffix! ;
774 If you try it with { $snippet "DNA{ a ccg t a g }" } you should get
777 { $snippet \"?{ f f t t t t f t t f f f f t }\" }
780 Let us try an example from the { $url
781 "https://re-factor.blogspot.com/2014/06/swift-ranges.html" "Re: Factor" } blog,
782 which adds infix syntax for ranges. Until now, we have used { $link [a..b] } to create a range. We can make a
783 syntax that is friendlier to people coming from other languages using { $snippet "..." } as an infix word.
785 We can use { $link scan-object } to ask the parser for the next parsed object, and { $link unclip-last } to get the top element from
786 the accumulator vector. This way, we can define { $snippet "..." } simply with
789 SYNTAX: ... unclip-last scan-object [a..b] suffix! ;
791 You can try it with { $snippet "12 ... 18 >array" } .
793 We only scratched the surface of parsing words; in general, they allow you to perform arbitrary computations at
794 compile time, enabling powerful forms of metaprogramming.
796 In a sense, Factor syntax is completely flat, and parsing words allow you to introduce syntaxes more complex than a
797 stream of tokens to be used locally. This lets any programmer expand the language by adding these syntactic features in libraries
798 . In principle, it would even be possible to have an external language compile to Factor -- say JavaScript -- and embed it
799 as a domain-specific language in the boundaries of a { $snippet "<JS ... JS>" } parsing word. Some taste is needed not to abuse too much of
800 this to introduce styles that are much too alien in the concatenative world.
803 ARTICLE: "tour-stack-ne" "When the stack is not enough"
805 Until now we have cheated a bit, and tried to avoid writing examples that would have been too complex to write in
806 concatenative style. Truth is, you { $emphasis "will" } find occasions where this is too restrictive. Parsing words can ease some of these restrictions, and Factor comes with a few to handle the most common annoyances.
808 One thing you may want to do is to actually name local variables. The { $link POSTPONE: :: } word works like { $link POSTPONE: : } , but allows you to
809 actually bind the name of stack parameters to variables, so that you can use them multiple times, in the order you want. For
810 instance, let us define a word to solve quadratic equations. I will spare you the purely stack-based version, and
811 present you a version with locals (this will require the { $vocab-link "locals" } vocabulary):
814 :: solveq ( a b c -- x )
816 b b * 4 a c * * - sqrt
819 In this case we have chosen the + sign, but we can do better and output both solutions:
822 :: solveq ( a b c -- x1 x2 )
824 b b * 4 a c * * - sqrt
827 You can check that this definition works with something like { $snippet "2 -16 30 solveq" } , which should output both { $snippet "3.0" } and { $snippet "5.0" } .
828 Apart from being written in RPN style, our first version of { $snippet "solveq" } looks exactly the same it would in a language
829 with local variables. For the second definition, we apply both the { $link + } and { $link - } operations to -b and delta, using the
830 combinator { $link 2bi } , and then divide both results by 2a using { $link bi@ } .
832 There is also support for locals in quotations - using { $link POSTPONE: [| } - and methods - using { $link POSTPONE: M:: } - and one can also create a
833 scope where to bind local variables outside definitions using { $link POSTPONE: [let } . Of course, all of these are actually compiled to
834 concatenative code with some stack shuffling. I encourage you to browse examples for these words, but bear in mind that
835 their usage in practice is actually much less prominent than one would expect - about 1% of Factor's own codebase.
837 Another common case happens when you need to add values to a quotation in specific places. You can partially apply a quotation using { $link curry } . This assumes that the value you are
838 applying should appear leftmost in the quotation; in the other cases you need some stack shuffling. The word { $link with } is a
839 sort of partial application with a hole. It also curries a quotation, but uses the third element on the stack instead
840 of the second. Also, the resulting curried quotation will be applied to an element inserting it in the second position.
842 The example from the documentation probably tells more than the
843 above sentence -- try writing:
845 { $code "1 { 1 2 3 } [ / ] with map" }
847 Let me take again { $snippet "prime?" } , but this time write it without using helper words:
851 [ sqrt 2 swap [a,b] ] [ [ swap divisor? ] curry ] bi any? not ;" }
852 Using { $link with } instead of { $link curry } , this simplifies to
856 2 over sqrt [a,b] [ divisor? ] with any? not ;" }
857 If you are not able to visualize what is happening, you may want to consider the { $vocab-link "fry" } vocabulary. It defines { $strong "fried quotations" } ";"
858 these are quotations that have holes in them - marked by { $snippet "_" } - that are filled with values from the stack.
860 The first quotation is rewritten more simply as
863 [ '[ 2 _ sqrt [a,b] ] call ]
865 Here we use a fried quotation - starting with { $link POSTPONE: '[ } - to inject the element on the top of the stack in the second
866 position, and then use { $link call } to evaluate the resulting quotation. The second quotation can be rewritten as follows:
869 [ '[ _ swap divisor? ] ]
871 so an alternative defition of { $snippet "prime?" } is
874 : prime? ( n -- ? ) [ '[ 2 _ sqrt [a,b] ] call ] [ '[ _ swap divisor? ] ] bi any? not ;
876 Depending on your taste, you may find this version more readable. In this case, the added clarity is probably lost due
877 to the fact that the fried quotations are themselves inside quotations, but occasionally their use can do a lot to
880 Finally, there are times where one just wants to give names to variables that are available inside some scope, and use
881 them where necessary. These variables can hold values that are global, or at least not local to a single word. A
882 typical example could be the input and output streams, or database connections.
884 For this purpose, Factor allows you to create { $strong "dynamic variables" } and bind them in scopes. The first thing is to create a { $strong "symbol" }
887 { $code "SYMBOL: favorite-language" }
888 Then one can use the word { $link set } to bind the variable and { $link get } to retrieve its values, like
890 { $code "\"Factor\" favorite-language set
891 favorite-language get" }
892 Scopes are nested, and new scopes can be created with the word { $link with-scope } . Try for instance
897 \"Scala\" favorite-language set
898 favorite-language get .
900 If you run { $snippet "on-the-jvm" } , { $snippet "\"Scala\"" } will be printed, but after execution, { $snippet "favorite-language get" } will hold { $snippet "\"Factor\"" } as its value.
902 All the tools that we have seen in this section should only be used when absolutely necessary, as they break concatenativity and make
903 words less easy to factor. However, they can greatly increase clarity when needed. Factor has a very practical approach and
904 does not shy from offering features that are less pure but nevertheless often useful.
907 ARTICLE: "tour-io" "Input/Output"
909 We will now leave the tour of the language, and start investigating how to tour the outside world with Factor. This section will begin with basic input and output, and move on to asynchronous, parallel
912 Factor implements efficient asynchronous input/output facilities, similar to NIO on the JVM or the Node.js I/O system.
913 This means that input and output operations are performed in the background, leaving the foreground task free to
914 perform work while the disk is spinning or the network is buffering packets. Factor is currently single threaded, but
915 asynchrony allows it to be rather performant for applications that are I/O-bound.
917 All of Factor input/output words are centered on { $strong "streams" } . Streams are lazy sequences which can be read from or written
918 to, typical examples being files, network ports or the standard input and output. Factor holds a couple of dynamic
919 variables called { $link input-stream } and { $link output-stream } , which are used by most I/O words. These variables can be rebound locally
920 using { $link with-input-stream } , { $link with-output-stream } and { $link with-streams } . When you are in the listener, the default streams
921 write and read in the listener, but once you deploy your application as an executable, they are usually bound to the
922 standard input and output of your console.
924 The words { $link <file-reader> } and { $link <file-writer> } (or { $link <file-appender> } ) can be used to create a read or write stream to a
925 file, given its path and encoding. Putting everything together, we make a simple example of a word that reads each line
926 of a file encoded in UTF8, and writes the first letter of the line to the listener.
928 First, we want a { $snippet "safe-head" } word, that works like { $link head } , but returns its input if the sequence is too short. To do so
929 , we will use the word { $link recover } , which allows us to declare a try-catch block. It requires two quotations: the first
930 one is executed, and on failure, the second one is executed with the error as input. Hence we can define
933 : safe-head ( seq n -- seq' ) [ head ] [ 2drop ] recover ;" }
934 This is an impractical example of exceptions, as Factor defines the { $link short } word, which takes a
935 sequence and a number, and returns the minimum between the length of the sequence and the number. This allows us to write simply
938 : safe-head ( seq n -- seq' ) index-or-length head ;" }
939 With this definition, we can make a word to read the first character of the first line:
942 : read-first-letters ( path -- )
944 readln 1 safe-head write nl
945 ] with-input-stream ;" }
946 Using the helper word { $link with-file-reader } , we can also shorten this to
949 : read-first-letters ( path -- )
951 readln 1 safe-head write nl
952 ] with-file-reader ;" }
953 Unfortunately, we are limited to one line. To read more lines, we should chain calls to { $link readln } until one returns { $link f } .
954 Factor helps us with { $link file-lines } , which lazily iterates "over" lines. Our "final" definition becomes
957 : read-first-letters ( path -- )
958 utf8 file-lines [ 1 safe-head write nl ] each ;" }
959 When the file is small, one can also use { $link file-contents } to read the whole contents of a file in a single string.
960 Factor defines many more words for input/output, which cover many more cases, such as binary files or sockets.
962 We will end this section investigating some words to walk the filesystem. Our aim is a very minimal implementation of the { $snippet "ls" } command.
964 The word { $link directory-entries } lists the contents of a directory, giving a list of tuple elements, each one having the
965 slots { $snippet "name" } and { $snippet "type" } . You can see this by trying { $snippet "\"/home\" directory-entries [ name>> ] map" } . If you inspect the
966 directory entries, you will see that the type is either { $link +directory+ } or { $link +regular-file+ } (well, there are symlinks as well,
967 but we will ignore them for simplicity). Hence we can define a word that lists files and directories with
970 : list-files-and-dirs ( path -- files dirs )
971 directory-entries [ type>> +regular-file+ = ] partition ;" }
972 With this, we can define a word { $snippet "ls" } that will print directory contents as follows:
977 \"DIRECTORIES:\" write nl
978 \"------------\" write nl
979 [ name>> write nl ] each
982 [ name>> write nl ] each ;" }
983 Try the word on your home directory to see the effects. In the next section, we shall look at how to create an
984 executable for our simple program.
987 ARTICLE: "tour-deploy" "Deploying programs"
990 There are two ways to run Factor programs outside the listener: as scripts, which are interpreted by Factor, or as
991 standalone executable compiled for your platform. Both require you to define a vocabulary with an entry point (altough
992 there is an even simpler way for scripts), so let's do that first.
994 Start by creating our { $snippet "ls" } vocabulary with { $snippet "\"ls\" scaffold-work" } and make it look like this:
998 ! Copyright (C) 2014 Andrea Ferretti.
999 ! See https://factorcode.org/license.txt for BSD license.
1000 USING: accessors command-line io io.directories io.files.types
1001 kernel namespaces sequences ;
1006 : list-files-and-dirs ( path -- files dirs )
1007 directory-entries [ type>> +regular-file+ = ] partition ;
1013 \"DIRECTORIES:\" write nl
1014 \"------------\" write nl
1015 [ name>> write nl ] each
1018 [ name>> write nl ] each ;" }
1020 When we run our vocabulary, we will need to read arguments from the command line. Command-line arguments are stored
1021 under the { $link command-line } dynamic variable, which holds an array of strings. Hence - forgetting any error checking - we can
1022 define a word which runs { $snippet "ls" } on the first command-line argument with
1024 { $code ": ls-run ( -- ) command-line get first ls ;" }
1025 Finally, we use the word { $link POSTPONE: MAIN: } to declare the main word of our vocabulary:
1027 { $code "MAIN: ls-run" }
1028 Having added those two lines to your vocabulary, you are now ready to run it. The simplest way is to run the
1029 vocabulary as a script with the { $snippet "-run" } flag passed to Factor. For instance to list the contents of my home I can do
1031 { $code "$ ./factor -run=ls /home/andrea" }
1032 In order to produce an executable, we must set some options and call the { $snippet "deploy" } word. The simplest way to do this
1033 graphically is to invoke the { $link deploy-tool } word. If you write { $snippet "\"ls\" deploy-tool" } , you will be presented with a window to
1034 choose deployment options. For our simple case, we will leave the default options and choose Deploy.
1036 After a little while, you should be presented with an executable that you can run like
1040 $ ./ls /home/andrea" }
1041 Try making the { $snippet "ls" } program more robust by handling missing command-line arguments and non-existent or non-directory
1045 ARTICLE: "tour-multithreading" "Multithreading"
1047 As we have said, the Factor runtime is single-threaded, like Node. Still, one can emulate concurrency in a single-threaded
1048 setting by making use of { $strong "coroutines" } . These are essentially cooperative threads, which periodically release
1049 control with the { $link yield } word, so that the scheduler can decide which coroutine to run next.
1051 Although cooperative threads do not allow to make use of multiple cores, they still have some benefits:
1053 "input/output operations can avoid blocking the entire runtime, so that one can implement quite performant applications if I/O is the bottleneck;"
1054 "user interfaces are naturally a multithreaded construct, and they can be implemented in this model, as the listener itself shows;"
1055 "finally, some problems may just naturally be easier to write making use of the multithreaded constructs."
1058 For the cases where one wants to make use of multiple cores, Factor offers the possibility of spawning other processes
1059 and communicating between them with the use of { $strong "channels" } , as we will see in a later section.
1061 Threads in Factor are created using a quotation and a name, with the { $link spawn } word. Let us use this to print the
1062 first few lines of Star Wars, one per second, each line being printed inside its own thread. First, we will assign them to a
1068 \"A long time ago, in a galaxy far, far away....
1070 It is a period of civil war. Rebel
1071 spaceships, striking from a hidden
1072 base, have won their first victory
1073 against the evil Galactic Empire.
1075 During the battle, rebel spies managed
1076 to steal secret plans to the Empire's
1077 ultimate weapon, the DEATH STAR, an
1078 armored space station with enough
1079 power to destroy an entire planet.
1081 Pursued by the Empire's sinister agents,
1082 Princess Leia races home aboard her
1083 starship, custodian of the stolen plans
1084 that can save her people and restore
1085 freedom to the galaxy....\"
1086 \"\n\" split star-wars set
1089 We will spawn 18 threads, each one printing a line. The operation that a thread must run amounts to
1091 { $code "star-wars get ?nth print" }
1093 Note that dynamic variables are shared between threads, so each one has access to star-wars. This is fine, since it is
1094 read-only, but the usual caveats about shared memory in a multithreaded settings apply.
1096 Let us define a word for the thread workload
1099 : print-a-line ( i -- )
1100 star-wars get ?nth print ;" }
1102 If we give the i-th thread the name "\"i\"" , our example amounts to
1106 [ [ print-a-line ] curry ]
1111 Note the use of { $link curry } to send i to the quotation that prints the i-th line. This is almost what we want, but it runs
1112 too fast. We need to put the thread to sleep for a while. So we { $link clear } the stack that now contains a lot of thread
1113 objects and look for the { $link sleep } word in the help.
1115 It turns out that { $link sleep } does exactly what we need, but it takes a { $strong "duration" } object as input. We can create a
1116 duration of i seconds with... well { $snippet "i seconds" } . So we define
1119 : wait-and-print ( i -- )
1120 dup seconds sleep print-a-line ;" }
1126 [ [ wait-and-print ] curry ]
1131 Instead of { $link spawn } , we can also use { $link in-thread } which uses a dummy thread name and discards the returned thread,
1132 simplifying the above to
1136 [ wait-and-print ] curry in-thread
1139 In serious applications threads will be long-running. In order to make them
1140 cooperate, one can use the { $link yield } word to signal that the thread has done a unit of work, and other threads can gain
1141 control. You also may want to have a look at other words to { $link stop } , { $link suspend } or { $link resume } threads.
1144 ARTICLE: "tour-servers" "Servers and Furnace"
1146 Server applications often use more than one thread. When writing network
1147 applications, it is common to start a thread for each incoming connection (remember that these are green threads, so they are much
1148 more lightweight than OS threads).
1150 To simplify this, Factor has the word { $link spawn-server } , which works like { $link spawn } , but in addition repeatedly spawns the
1151 quotation until it returns { $link f } . This is still a very low-level word: in reality one has to do much more: listen for TCP
1152 connections on a given port, handle connection limits and so on.
1154 The vocabulary { $vocab-link "io.servers" } allows to write and configure TCP servers. A server is created with the word { $link <threaded-server> } , which requires an encoding as a parameter. Its slots can then be set to configure logging, connection limits,
1155 ports and so on. The most important slot to fill is { $snippet "handler" } , which contains a quotation that is executed for each
1156 incoming connection. You can see a simple example of a server with
1159 \"resource:extra/time-server/time-server.factor\" edit-file
1163 We will raise the level of abstraction even more and show how to run a simple HTTP server. First, { $snippet "USE: http.server" } .
1165 An HTTP application is built out of a { $strong "responder" } . A responder is essentially a function from a path and an HTTP
1166 request to an HTTP response, but more concretely it is anything that implements the method { $snippet "call-responder*" } . Responses are
1167 instances of the tuple { $link response } , so are usually generated calling { $link <response> } and customizing a few slots. Let us
1168 write a simple echo responder:
1169 { $code "TUPLE: echo-responder ;
1171 : <echo-responder> ( -- responder ) echo-responder new ;
1173 M: echo-responder call-responder*
1177 \"Document follows\" >>message
1178 \"text/plain\" >>content-type
1179 swap concat >>body ;" }
1181 Responders are usually combined to form more complex responders in order to implement routing and other features. In
1182 our simplistic example, we will use just this one responder, and set it globally with
1183 { $code "<echo-responder> main-responder set-global" }
1185 Once you have done this, you can start the server with { $snippet "8080 httpd" } . You can then visit { $url "https://localhost:8080/hello/%20/from/%20/factor" }
1186 in your browser to see your first responder in action. You can then stop the server with { $link stop-server } .
1188 Now, if this was all that Factor offers to write web applications, it would still be rather low level. In reality, web
1189 applications are usually written using a web framework called { $strong "Furnace" } .
1191 Furnace allows us - among other things - to write more complex actions using a template language. Actually, there are
1192 two template languages shipped by default, and we will use { $strong "Chloe" } . Furnace allows us to create { $strong "page actions" }
1193 from Chloe templates, and in order to create a responder we will need to add routing.
1195 Let use first investigate a simple example of routing. To do this, we create a special type of responder called a { $strong "dispatcher" } , that dispatches requests based on path parameters. Let us create a simple dispatcher that will choose
1196 between our echo responder and a default responder used to serve static files.
1198 dispatcher new-dispatcher
1199 <echo-responder> \"echo\" add-responder
1200 \"/home/andrea\" <static> \"home\" add-responder
1201 main-responder set-global" }
1203 Of course, substitute the path { $snippet "/home/andrea" } with any folder you like. If you start again the server with { $snippet "8080 httpd" }
1204 , you should be able to see both our simple echo responder (under { $snippet "/echo" } ) and the contents of your files (under { $snippet "/home" } ).
1205 Notice that directory listing is disabled by default, you can only access the content of files.
1207 Now that you know how to do routing, we can write page actions in Chloe. Things are starting to become complicated, so
1208 we scaffold a vocabulary with { $snippet "\"hello-furnace\" scaffold-work" } . Make it look like this:
1210 ! Copyright (C) 2014 Andrea Ferretti.
1211 ! See https://factorcode.org/license.txt for BSD license.
1212 USING: accessors furnace.actions http http.server
1213 http.server.dispatchers http.server.static kernel sequences ;
1217 TUPLE: echo-responder ;
1219 : <echo-responder> ( -- responder ) echo-responder new ;
1221 M: echo-responder call-responder*
1225 \"Document follows\" >>message
1226 \"text/plain\" >>content-type
1227 swap concat >>body ;
1229 TUPLE: hello-dispatcher < dispatcher ;
1231 : <example-responder> ( -- responder )
1232 hello-dispatcher new-dispatcher
1233 <echo-responder> \"echo\" add-responder
1234 \"/home/andrea\" <static> \"home\" add-responder
1236 { hello-dispatcher \"greetings\" } >>template
1237 \"chloe\" add-responder ;" }
1239 Most things are the same as we have done in the listener. The only difference is that we have added a third responder
1240 in our dispatcher, under { $snippet "chloe" } . This responder is created with a page action. The page action has many slots - say, to
1241 declare the behaviour of receiving the result of a form - but we only set its template. This is the pair with the
1242 dispatcher class and the relative path of the template file.
1244 In order for all this to work, create a file { $snippet "work/hello-furnace/greetings.xml" } with a content like
1245 { $code "<?xml version='1.0' ?>
1247 <t:chloe xmlns:t=\"https://factorcode.org/chloe/1.0\">
1248 <p>Hello from Chloe</p>
1251 Reload the { $snippet "hello-furnace" } vocabulary and { $snippet "<example-responder> main-responder set-global" } . You should be able to see
1252 the results of your efforts under { $url "https://localhost:8080/chloe" } . Notice that there was no need to restart the server, we
1253 can change the main responder dynamically.
1255 This ends our very brief tour of Furnace. Furnace is much more expansive than the examples shown here, as it allows for many general web
1256 tasks. You can learn more about it in the { $link "furnace" } documentation.
1259 ARTICLE: "tour-processes" "Processes and Channels"
1262 As discussed earlier, Factor is single-threaded from the point of view of the OS. If we want to make use of multiple cores, we
1263 need a way to spawn Factor processes and communicate between them. Factor implements two different models of message-passing concurrency: the actor model, which is based on the idea of sending messages asynchronously between threads, and the
1264 CSP model, based on the use of { $strong "channels" } .
1266 As a warm-up, we will make a simple example of communication between threads in the same process.
1267 { $code "FROM: concurrency.messaging => send receive ;" }
1268 We can start a thread that will receive a message and print it repeatedly:
1269 { $code ": print-repeatedly ( -- ) receive . print-repeatedly ;
1271 [ print-repeatedly ] \"printer\" spawn" }
1272 A thread whose quotation starts with { $link receive } and calls itself recursively behaves like an actor in Erlang or Akka.
1273 We can then use { $link send } to send messages to it. Try { $snippet "\"hello\" over send" } and then { $snippet "\"threading\" over send" } .
1275 Channels are slightly different abstractions, used for instance in Go and in Clojure core.async. They decouple the
1276 sender and the receiver, and are usually used synchronously. For instance, one side can receive from a channel before some
1277 other party sends something to it. This just means that the receiving end yields control to the scheduler, which waits
1278 for a message to be sent before giving control to the receiver again. This feature sometimes makes it easier to
1279 synchronize multithreaded applications.
1281 Again, we first use a channel to communicate between threads in the same process. As expected, { $snippet "USE: channels" } . You
1282 can create a channel with { $link <channel> } , write to it with { $link to } and read from it with { $link from } . Note that both operations are
1283 blocking: { $link to } will block until the value is read in a different thread, and { $link from } will block until a value is available.
1285 We create a channel and give it a name with
1289 Then we write to it in a separate thread, in order not to block the UI
1290 { $code "[ \"hello\" ch get to ] in-thread" }
1291 We can then read the value in the UI with
1292 { $code "ch get from" }
1293 We can also invert the order:
1294 { $code "[ ch get from . ] in-thread
1296 \"hello\" ch get to" }
1297 This works fine, since we had set the reader first.
1299 Now, for the interesting part: we will start a second Factor instance and communicate via message sending. Factor
1300 transparently supports sending messages over the network, serializing values with the { $vocab-link "serialize" } vocabulary.
1302 Start another instance of Factor, and run a node server on it. We will use the word { $link <inet4> } , that creates an IPv4
1303 address from a host and a port, and the { $link <node-server> } constructor
1304 { $code "USE: concurrency.distributed
1306 f 9000 <inet4> <node-server> start-server" }
1307 Here we have used { $link f } as host, which just stands for localhost. We will also start a thread that keeps a running count
1308 of the numbers it has received.
1309 { $code "FROM: concurrency.messaging => send receive ;
1311 : add ( x -- y ) receive + dup . add ;
1313 [ 0 add ] \"adder\" spawn" }
1314 Once we have started the server, we can make a thread available with { $link register-remote-thread } ":"
1315 { $code "dup name>> register-remote-thread" }
1316 Now we switch to the other instance of Factor. Here we will receive a reference to the remote thread and start sending
1317 numbers to it. The address of a thread is just the address of its server and the name we have registered the thread with
1318 , so we obtain a reference to our adder thread with
1319 { $code "f 9000 <inet4> \"adder\" <remote-thread>" }
1320 Now, we reimport { $link send } just to be sure (there is an overlap with a word having the same name in { $vocab-link "io.sockets" } , that we
1322 { $code "FROM: concurrency.messaging => send receive ;" }
1323 and we can start sending numbers to it. Try { $snippet "3 over send" } , and then { $snippet "8 over send" } - you should see the running total
1324 printed in the other Factor instance.
1326 What about channels? We go back to our server, and start a channel there, just as above. This time, though, we { $link publish } it to make it available remotely:
1327 { $code "USING: channels channels.remote ;
1329 <channel> dup publish" }
1330 What you get in return is an id you can use remotely to communicate. For instance, I just got
1331 { $snippet "72581372615274718877979307388951222312843084896785643440879198703359628058956" } (yes, they really want to be sure it is unique!).
1333 We will wait on this channel, thereby blocking the UI:
1334 { $code "swap from ." }
1335 In the other Factor instance we use the id to get a reference to the remote channel and write to it
1337 f 9000 <inet4> 72581372615274718877979307388951222312843084896785643440879198703359628058956 <remote-channel>
1338 \"Hello, channels\" over to" }
1339 In the server instance, the message should be printed.
1341 Remote channels and threads are both useful to implement distributed applications and make good use of multicore
1342 servers. Of course, it remains the question how to start worker nodes in the first place. Here we have done it manually - if
1343 the set of nodes is fixed, this is actually an option.
1345 Otherwise, one could use the { $vocab-link "io.launcher" } vocabulary to start other Factor instances programmatically.
1348 ARTICLE: "tour-where" "Where to go from here?"
1350 We have covered a lot of ground here, and we hope that this has given you a taste of the great things
1351 you can do with Factor. You can now
1352 work your way through the documentation, and hopefully contribute to Factor yourself.
1354 Let me end with a few tips:
1357 { "when starting to write Factor, it is " { $emphasis "very" } " easy to deal a lot with stack shuffling. Learn the "
1358 { $vocab-link "combinators" } " well, and do not fear to throw away your first examples." }
1359 "no definition is too short: aim for one line."
1360 "the help system and the inspector are your best friends."
1362 To be fair, we have to mention some drawbacks of Factor:
1365 "The community is small. It is difficult to find information about Factor on the internet.
1366 However, you can help with this by posting questions on Stack Overflow under the [factor] tag."
1367 "The concatenative model is very powerful, but also hard to get good at."
1368 "Factor lacks native threads: although the distributed processes make up for it, they incur some cost in serialization."
1369 "Factor does not currently have a package manager. Most prominent packages are part of the main Factor distribution."
1371 The Factor source tree is massive, so here's a few vocabularies to get you started off:
1373 { "We have not talked a lot about errors and exceptions. Learn more in the " { $vocab-link "debugger" } " vocabulary." }
1374 { "The " { $vocab-link "macros" } " vocabulary implements a form of compile time metaprogramming less general than parsing words." }
1375 { "The " { $vocab-link "models" } " vocabulary lets you implement a form of dataflow programming using objects with observable slots." }
1376 { "The " { $vocab-link "match" } " vocabulary implements ML-style pattern matching." }
1377 { "The " { $vocab-link "monads" } " vocabulary implements Haskell-style monads." }
1380 These vocabularies are a testament to the power and expressivity of Factor, and we hope that they
1381 help you make something you like. Happy hacking!
1386 \"https://factorcode.org/logo.png\" http-image." }
1389 ARTICLE: "tour" "Guided tour of Factor"
1390 Factor is a mature, dynamically typed language based on the concatenative paradigm. Getting started with Factor can be daunting
1391 since the concatenative paradigm is different from most mainstream languages.
1394 "Guide you through the basics of Factor so you can appreciate its simplicity and power."
1395 "Assume you are an experienced programmer familiar with a functional language"
1396 "Assume you understand concepts like folding, higher-order functions, and currying"
1399 Even though Factor is a niche language, it is mature and has a comprehensive standard library covering tasks from JSON
1400 serialization to socket programming and HTML templating. It runs in its own optimized VM with very high performance for a dynamically
1401 typed language. It also has a flexible object system, a Foreign Function Interface to C, and
1402 asynchronous I/O that works a bit like Node.js, but with a much simpler model for cooperative multithreading.
1404 Factor has a few significant advantages over
1405 other languages, most arising from the fact that it has essentially no syntax:
1408 "Refactoring is very easy, leading to short and meaningful function definitions"
1409 "It is extremely succinct, letting the programmer concentrate on what is important instead of boilerplate"
1410 "It has powerful metaprogramming capabilities, exceeding even those of LISPs"
1411 "It is ideal for creating DSLs"
1412 "It integrates easily with powerful tools"
1415 A few file paths in the examples may need to be adjusted based on your system.
1417 The first section gives some motivation for the peculiar model of computation of concatenative languages, but feel free
1418 to skip it if you want to get your feet wet and return to it after some hands on practice with Factor.
1420 { $heading "The Tour" }
1422 "tour-concatenative"
1425 "tour-parsing-words"
1426 "tour-stack-shuffling"
1432 "tour-metaprogramming"
1436 "tour-multithreading"