Jump to content

Factor (programming language)

From Wikipedia, the free encyclopedia
This is an old revision of this page, as edited by 206.169.226.36 (talk) at 19:23, 11 June 2008. The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.
Factor
Paradigmstack-based
DeveloperSlava Pestov
First appeared2003
Stable release
Continuous Builds
Typing disciplinestrong, dynamic
OSWindows, Mac OS, Linux, others
LicenseBSD license
Websitefactorcode.org
Influenced by
Joy, Forth, Lisp, Self
Influenced
Cat

Factor is a dynamically typed concatenative programming language whose design and implementation is led by Slava Pestov. Factor's main influences are Joy, Forth, Lisp and Self. Current versions of Factor exist as Continuous Builds for supported platforms while version 1.0 is under developement[1]. A 1.0 release is planned in 2008.

Like other concatenative languages, Factor has a postfix syntax, meaning that you write the arguments of a function before its name. As an example, Hello world in Factor is 

"Hello world" print

Factor is dynamically typed, and a unique object system accompanies it. In Factor, there is a small group of base types, and users and the standard library can make their own classes using tuples and other mechanisms. There is no inheritance, but there is delegation as in Self. Additionally, there are other ways to make classes other than types or tuples; Factor supports predicate classes and union classes. Factor's built-in compound datatypes include fixed and variable length vectors and hashtables. The language also supports floating point, and arbitrary precision integers. Linked lists, complex numbers and fractions are implemented in the standard library.

Factor was originally only interpreted, but is now fully compiled (the non-optimizing compiler basically unrolls the interpreter loop[1][2]). The optimizing machine code compiler is written entirely in Factor. It does not output standalone executables, but rather generates machine code which is saved in the image. This image can then be deployed with the deploy-tool which produces a minimal tree shaken image along with the VM.

When using the stack system does not suffice, lexical and dynamic scoping are supported alternatives. Factor has a growing library which supports vocabularies, continuations, an HTTP server and accompanying web framework, an OpenGL binding, a GUI library, an XML parser, and several other utilities.

One of Factor's main goals is to be useful for interactive and test-driven development, which is why Factor is, at its core, a safe version of Forth. Factor is dynamically typed, but the compiler assesses the stack depth of words (functions).

Lisp Like Features

Factor shares a lot of features with Lisp, including a homoiconic syntax, garbage collection, HOFs, compile-time evaluation, REPL, treeshaker, etc.

Unlike Lisp, function composition proceeds left to right rather than: 

(languages (applicative (in (backwards (is (composition (function)))))))[3]

This is an inherent feature in concatenative languages.

Java Like Collections

Sequences

  • Fixed-length sequences:
    • Arrays
    • Quotations
  • Fixed-length specialized sequences:
    • Strings
    • Bit arrays
    • Byte arrays
    • Float arrays
  • Resizable sequences:
    • Vectors
  • Resizable specialized sequences:
    • String buffers
    • Bit vectors
    • Byte vectors
    • Float vectors

Associative mappings

  • Hashtables
  • Association lists
  • Enumerations

Double-ended queues

  • Double-linked lists
  • Search dequeues

Other collections

  • Boxes
  • Heaps
  • Locked I/O buffers
  • Disjoint sets
  • Persistent vectors
  • Tuple arrays
  • Directed graph utilities

Concurrency Support

Factor's concurrency support was insipired by Erlang, Termite, Scheme48 and Java's java.util.concurrent library.

The basic building blocks:

  • Lightweight co-operative threads

High-level abstractions:

  • Concurrent combinators
  • Promises
  • Futures
  • Mailboxes
  • Message-passing concurrency

Shared-state abstractions:

  • Locks
  • Counting semaphores
  • Count-down latches
  • Object exchange points
  • Flags

Other concurrency abstractions include:

  • concurrency.distributed
  • channels

Implementations

So far, both Java and C implementations have been constructed. The Java implementation is deprecated and no longer maintained. The native runtime of the C version is continually shrinking as an increasing proportion of Factor is self-hosted. However, there will likely always be a portion of Factor written in C.

Though Factor does not adhere to an external standard the way C does, the language is heavily documented.

References

  1. ^ Factor: a practical stack language: Two-tier compilation comes to Factor
  2. ^ Factor: a practical stack language: Compiler overhaul
  3. ^ Slava Pestov, reddit comment
Retrieved from "https://en.wikipedia.org/w/index.php?title=Factor_(programming_language)&oldid=218691420"