Article index
Factor handbook

Prev:Vocabulary index
Next:Primitive index

A Simple, Fast Dominance Algorithm
A quick introduction to regular expressions
ANSI C streams
ASCII encoding
AVL trees
Abstract stack checker values
Accessing C global variables
Accessing sequence elements
Accessing the environment via the assoc protocol
Action gestures
Adding and removing sequence elements
Additional bitwise arithmetic
Additional generalizations
Additional vocabulary roots file
Address specifiers
Adler-32 checksum
Adobe Brackets support
Affine Transformations of 2d Vectors
Algebraic data types
Alias analysis for stack operations, array elements and tuple slots
Aliases that resemble DOT code
Alien addresses
Alien destructors
Alien endian-aware types
Alien expiry
Alien object literal syntax
All tips of the day
Allocating registers for live intervals
Allocation for alien node parameters
Amazon S3
An example of XML processing
An example of a custom Chloe component
An introduction to encodings
Appending sequences
Application cookbook
Application deployment
Apply combinators
Arithmetic functions
Array syntax
Arrow models
Article index
Assign representations to vregs
Assigning registers to live intervals
Association lists
Associative mapping combinators
Associative mapping conversions
Associative mapping operations
Associative mapping protocol
Atom and RSS feed syndication
Atom feed entry protocol
Audio file loader
Audio framework
Audio generator protocol
Audio listener protocol
Audio playback engine
Audio source protocol
Authentication capabilities
Authentication provider protocol
Authentication providers
Authentication realm configuration
Authentication realms
Automated log analysis
BLAS interface matrix operations
BLAS interface types
BLAS interface vector operations
BSD checksum
Balloon Bomber Emulator
Base 64 conversions
Basic Linear Algebra Subroutines (BLAS) interface
Basic authentication
Basic block instructions
Basic syntax cookbook
Batch error reporting
Bidirectional assocs
Binary Application Record Encoding (BARE)
Binary and text streams
Binary encoding
Binary object serialization
Binary search
Binary search trees
Bit arrays
Bit sets
Bit vectors
Bitwise arithmetic
Bitwise operations on floats
Block Joining
Block elements
Bloom filters
Boilerplate Chloe tags
Boilerplate configuration
Boilerplate example
Boilerplate support
Book layouts
Boolean expressions
Bootstrap initialization file
Bootstrap primitives
Bootstrap support
Bootstrapping new images
Border gadgets
Boxes as references
Branch stack effects
Browsing documentation
Buffer objects
Building user interfaces
Built-in classes
Button gadgets
Byte array syntax
Byte arrays
Byte arrays and the garbage collector
Byte vectors
Byte-array streams
C library interface
C standard library math functions
C strings
C type specifiers
C value boxes
C99 complex number types
CFG construction utilities
CFG node emitter for alien nodes
CGI (Common Gateway Interface)
CIE 1931 XYZ colors
CIE 1931 xyY colors
CIE 1976 LAB colors
CIE 1976 LUV colors
CMYK colors
CPU architecture description model
CPU x86 assembler
CPU x86 compiler backend
CPU x86 features
CPU x86 registers and memory operands
CRC16 checksum
CRC32 checksum
Calculations over periods of time
Calendar facts
Calling C from Factor
Calling Factor from C
Calling Objective C code
Calling arbitrary assembly code
Calling less-specific methods
Calling the optimizing compiler
Canned HTTP responses
Cartesian product operations
Case mapping
Changer syntax
Changing variable values
Character and string syntax
Character encodings and the HTTP client
Character escape codes
Character styles
Checksumming with External Utilities
Checksumming with Multiple Algorithms
Chloe link and form tags
Chloe templates
Circular lists
Circular sequences
Class index
Class linearization
Class operations
Class predicate words
Cleanup Phase
Cleave combinators
Client handler quotation
Client stream parameters
Clipboard protocol
Cluster example
Co-operative threads
Cocoa application utilities
Cocoa bridge
Cocoa file dialogs
Cocoa pasteboard utilities
Cocoa view utilities
Cocoa window utilities
Code annotations
Code generation from MR (machine representation)
Coercive slot declarations
Collation and weak comparison
Colon definitions
Color protocol
Colored circles example
Column sequences
Combinator Connections
Combinator stack effects
Combinators for lists
Combinators for manipulating lazy lists
Comma-separated-values parsing and writing
Command line arguments
Command line switches for bootstrap
Command line switches for general usage
Command line switches for the VM
Common code used by several passes for def-use analysis
Common error handling pitfalls
Common parametric curves.
Comparing intervals
Comparing sequences
Comparison conditions
Comparisons GVN
Compilation units
Compilation units internals
Compiler declarations
Compiler errors
Compiler implementation
Compiler specialization hints
Complete bipartite graphs
Complete graphs
Complex component virtual sequences
Complex number syntax
Complex numbers
Complex shuffle words
Complex virtual sequences
Component Chloe tags
Componentwise logic with SIMD vectors
Compositional combinators
Compressing data with bzip3
Compression (ZLIB)
Computing cumulative sequences
Computing histograms
Computing stack frame size and layout
Concatenative Languages
Concise Binary Object Representation (CBOR)
Concurrent combinators
Conditional combinators
Configuring Atom feed actions
Configuring the BLAS interface
Connection pools
Connection-oriented networking
Constructing bit fields
Constructing lazy lists
Constructing regular expressions
Constructing strict lists
Continuation implementation details
Control Flow Graph IR
Control Pictures
Control flow cookbook
Control flow with sequences
Control-flow Chloe tags
Controlling the floating-point environment
Conventional SSA Form
Conversion of COLLADA assets
Conversion of Wavefront OBJ assets
Converting between numbers and strings
Converting objects to human-readable strings
Converting objects to summary strings
Copy propagation
Core Graphics types
CouchDB Authentication Provider
Count-down latches
Counted loops
Counting semaphores
Coverage tool
Coverage tool dummy test vocabulary
Creating Tensors
Creating a vocabulary for your first program
Creating an editor integration
Creating directories
Creating instances of structs
Creating intervals
Crossreferencing word dependencies.
Ctags file
Ctrl-Break handler
Cuckoo Filters
Current working directory
Curried dataflow combinators
Custom database combinators
Custom method combination
Customizing gadget appearance
Cycle graphs
DELETE requests with the HTTP client
DLL handles
Database authentication provider
Database library
Database types
Dataflow combinators
Day names in English
Dead code elimination
Dead code elimination
Deep sequence combinators
Def/use chain construction
Default input and output streams
Deferred words and mutual recursion
Defining our first word
Defining struct classes
Defining words
Definition Dependency Management
Definition cross referencing
Definition icons
Definition protocol
Definition sanity checking
Delay models
Deleting, moving, and copying files
Deploy tool caveats
Deploy tool implementation
Deploy tool usage
Deployed resource files
Deploying programs
Deployment configuration
Deployment flags
Deprecation tracking
Derivative Syntax
Descriptive errors
Destructive sequence operations
Destructor tools
Deterministic resource disposal
Developer tools
Developing UI backends
Diffie-Hellman parameter file
Directed graph utilities
Directory hierarchy manipulation
Directory listing
Directory manipulation
Disassembling words
Disjoint sets
Dispatch on XML tag names
Displaying Images
Distributed Concurrency Example
Distributed message passing
Division by zero
Document elements
Document locations
Double-linked lists
Dual Numbers
Dummy authentication provider
Duplex streams
Dynamic variables
Dynamic variables cookbook
EBNF Action
EBNF Foreign Rules
EBNF Rule: And
EBNF Rule: Any
EBNF Rule: Character Class
EBNF Rule: Choice
EBNF Rule: Group
EBNF Rule: Ignore
EBNF Rule: Not
EBNF Rule: One or more
EBNF Rule: Option
EBNF Rule: Sequence
EBNF Rule: Strings
EBNF Rule: Zero or more
EBNF Semantic Action
EBNF Tokenizers
EBNF Variable
ELF nm
EUC-KR encoding
EditPad Pro support
Editing slot values in the inspector
Editor gadget commands
Editor gadgets
Editor integration
Element types
Elevate bugs and caveats
Elevated permissions API
Embedding API restrictions
Embedding Factor into C applications
Embedding of real numbers in complex numbers
Encoding and decoding strings
Encoding descriptors
Encoding protocol
English natural language transformations
Enumeration types
Environment variables
Ephemeral RSA key bits
Error index
Escape analysis for tuple unboxing
Etags file
Evaluating strings at run time
Evaluating strings with a different vocabulary search path
Event-based XML parsing
Examples of abbrev usage
Examples of compositional combinator usage
Examples of custom Chloe tags
Examples of fried quotations
Examples of lexical variables
Examples of reading and writing files
Exception handling
Expansions of call( and execute( words
Expressing conditionals with boolean logic
Extending Chloe
Extending Chloe with custom components
Extending Chloe with custom tags
Extending the prettyprinter
Extending your first program
Extra matrix operations
Extra properties for special words
Extra sets words
FHTML templates
FUEL command listener
Factor cookbook
Factor documentation
Factor embedding API
Factor handbook
Factor philosophy
Farkup syntax tree nodes
File drop gestures
File system change descriptors
File system change monitors
File system metadata
File types
Files tools
Final pass cleans up high-level IR
Final stage of compilation generates machine code from dataflow IR
Financial math
Finite state machine example
Fletcher's checksum
Float syntax
Floating point comparison operations
Form submission referrer checking
Form validation with actions
Form validators
Formatted output
Formatted output on the default stream
Formatted printing
Formatted stream protocol
Fortran ABIs
Fortran FFI
Fortran types
Fowler-Noll-Vo checksum
Frame layouts
Framebuffer objects
Free-form keyboard input
Fried quotation philosophy
Fried quotations
Functionality specific to Mac OS X
Functionality specific to Windows
Fundamental combinators
Furnace Atom syndication support
Furnace JSON support
Furnace action configuration
Furnace action lifecycle
Furnace actions
Furnace actions implementation
Furnace alloy responder
Furnace asides
Furnace authentication
Furnace authentication example
Furnace boilerplate support
Furnace conversation scope
Furnace database support
Furnace extension points
Furnace framework
Furnace page action example
Furnace page actions
Furnace persistence layer
Furnace presentation layer
Furnace redirection support
Furnace sessions
Furnace user administration tool
Fuzz Testing
Fuzzy completion
GB 18030
GC maps
GC maps decoder
GET requests with the HTTP client
GIF Image Loader
GMail Client
GNU Database Manager
GPU state
GPU-accelerated rendering
Gadget geometry
Gadget hierarchy and layouts
Gadget line support
Game controller input
Game loop delegate
Game loops
Game worlds
Garbage collection check insertion
Generalized combinators
Generalized sequence words
Generalized shuffle words
Generalized shuffle words and combinators
Generating instructions for accessing the data and retain stacks
Generating instructions for fixnum arithmetic
Generating instructions for inline memory allocation
Generating instructions for slot access
Generating random integers
Generating random passwords
Generic word introspection
Generic words and methods
Gesture handling differences between platforms
Getting and setting editor contents
Glass layers
Global stack analysis
Global variables
Graphics context management
Graphviz attributes
Graphviz data structures
Graphviz gallery
Graphviz notation
Grayscale colors
Grid layouts
Grid lines
Groups and clumps
Gtk-based UI backend
Guided tour of Factor
HEAD requests with the HTTP client
HSL colors
HSV colors
HTML components
HTML elements
HTML entities
HTML form infrastructure
HTML form values
HTML forms
HTML streams
HTML template interface
HTTP client
HTTP client errors
HTTP client post data
HTTP cookies
HTTP dispatcher examples
HTTP dispatchers and virtual hosting
HTTP headers
HTTP post data
HTTP protocol objects
HTTP request variables
HTTP requests
HTTP responder filters
HTTP responder redirection
HTTP responses
HTTP server
HTTP server port remapping
HTTP server responders
HTTP server variables
HTTP(S) proxy variables
HWB colors
Hardware vector arithmetic (SIMD)
Hash set syntax
Hash sets
Hashtable implementation details
Hashtable keys
Hashtable syntax
Hashtable utilities
Help coverage linting
Help lint tool
Help system
Help system implementation
High-level optimizer operating on lexical tree SSA IR
High-level tuple/database integration
High-level tuple/database words
History models
Hooks for dynamic content
Human-friendly sorting
I/O encodings
I/O timeout protocol
IANA-registered encoding names
ID3 tags
IMAP library
IRC Client
ISO 2022-JP-1 encoding
Image normalization
Implementation details
Implementing controls
Implementing custom drawing logic
Implementing layout gadgets
Implementing models
Implementing new gadgets
Implementing sequence combinators
In-memory authentication provider
Incremental layouts
Inferring alien words
Infix notation
Initial values of slots
Initialization and startup
Input and output
Input/output redirection
Insert context saves
Integer functions
Integer logarithms
Integer syntax
Integer virtual sequences
Integration with Emacs
Intel 8080 CPU Emulator
Interactive debugging of OpenGL applications
Interference testing using SSA properties.
Internet checksum
Interpolating code results into literal values
Intersection classes
Interval arithmetic
Interval maps
Interval sets
Introduction to SIMD support
Invertible quotations
JSON serialization
Kakoune support
Keyboard focus
Keyboard gestures
Korean Johab encoding
LCS, diffing and distance
LD Cache
LZW compression
LZW differences between TIFF and GIF
Label gadgets
Labeled gadgets
Launch descriptors
Launcher examples
Launching processes
Layout basics
Lazy list I/O
Lazy lists
Leader book-keeping
Learning the Tools
Legacy 8-bit encodings
Lexical variables
Lexical variables and fry
Lexical variables in literals
Limitations of lexical variables
Limited input streams
Limiting connections
Linear order example
Linear order protocol
Linear-scan register allocation
Link components
Linked assocs
Linked exceptions
List gadgets
Listing threads
Literal prettyprinting protocol
Live interval splitting
Live interval state
Live interval utilities
Live ranges for interference testing
Live ranges utilities
Liveness analysis
Load balancing and fail-over with Furnace
Loader for Factor images
Loading native libraries
Local stack analysis
Locked I/O buffers
Log analysis
Log file parser
Log files
Log implementation
Log levels
Log rotation
Logging connections
Logging framework
Logging messages
Login authentication
Looking up and creating words
Lookup and querying of assocs
Looping combinators
Low-level SIMD primitives
Low-level database protocol
Low-level database tutorial
Low-level slot operations
Lucas-Lehmer Mersenne Primality test
Lunar Rescue Emulator
MD5 checksum
MD5 shadow passwords
MIME types
Make philosophy
Making sequences with variables
Manipulating Tensors
Manipulating lazy lists
Manipulating lists
Manual layouts
Manual memory management
Manually constructing an encoded stream
Mapping between Factor and YAML types
Markup element utilities
Matching operations with regular expressions
Mathematical functions
Matrix operations
Maybe classes
MediaWiki API
Memory-mapped file examples
Memory-mapped files
Merging sequences
Message-passing concurrency
Method chaining syntax
Method inlining and dispatch elimination
Method precedence
MetroHash checksum
Miller-Rabin probabilistic primality test
Miscellaneous Furnace features
Miscellaneous vector functions
Mixin classes
Modeling transformations
Modular arithmetic
MongoDB factor integration
Monitors on different platforms
Month names in English
Motivation for default streams
Mouse gestures
Multi-touch gestures
MurmurHash checksum
Mutable lexical variables
Mutual-exclusion locks
N-based sequences
Namespace combinators
Namespace implementation details
Nested structure
Networking examples
Next steps
Non-blocking I/O implementation
Normalize IR created by high level IR builder to simplify subsequent passes
Notation for setting Graphviz attributes
Null streams
Number protocol
Number syntax
Numeric ranges
Numerical accuracy of SIMD primitives
OPTIONS requests with the HTTP client
Oauth2 Support
Object exchange points
Object memory tools
Ogg Vorbis audio streaming
OpenGL binding
OpenGL error reporting
OpenGL geometric primitives
OpenGL utility words
OpenSSL Binding
OpenSSL checksums
Operating system detection
Operating system processes
Operations on sets
Optimizing compiler
Optional authentication features
Ordering specifiers
Output parameters in C
PCRE binding
POP3 client library
POST requests with the HTTP client
PUT requests with the HTTP client
Pack layouts
Packet-oriented networking
Pair-wise sequence combinators
Pane gadgets
Paragraph styles
Parallel copy
Parameterized constructors
Parse time evaluation
Parse-time word lookup
Parser algorithm
Parsing Words
Parsing raw tokens
Parsing simple flat files
Parsing words
Partial continuations
Partially-dispatched math operations, used by the compiler
Passing data between Factor and C
Passing pointers to C functions
Passing specialized arrays to C functions
Passing specialized vectors to C functions
Passing structs to C functions
Path finding using the A* algorithm
Pathname presentations
Pathname syntax
Pattern matching
Peephole optimizations
Per-node dispatch for escape analysis
Persistent deques
Persistent heaps
Persistent sequence protocol
Persistent vectors
Pitfalls to avoid
Pixel format attributes
Pixel formats
Plain writer streams
Plan9 acme editor support
Playing with the stack
Pointer and array types
Popup menus
Porter stemming algorithm
Post-mortem error inspection
Powers and logarithms
Pre-made UI gadgets
Predicate classes
Preparing to deploy an application
Presentation gadgets
Presentations in the UI
Preserving combinators
Prettyprint control variables
Prettyprinter limitations
Prettyprinter section protocol
Prettyprinter sections
Prettyprinter stylesheet
Prettyprinting more complex literals
Prettyprinting numbers
Prettyprinting stacks
Prime numbers
Primitive C types
Primitive index
Printing definitions
Printing markup elements
Private words
Process run-time timeouts
Processes and Channels
Processor detection
Product models
Product sequences
Progress bar models
Progress bars
Propagation for inline recursive combinators
Propagation for read-only tuple slots and array lengths
Propagation for straight-line code
Properties of interval arithmetic
Protected resources
Protocol slots
Python binding
Quotation construction utilities
Quotation syntax
Quoted printable encoding
Quoted words
RIPEMD checksum
RYB colors
Random access result sets
Random combinators
Random protocol
Range model protocol
Range models
Ratio syntax
Rational numbers
Read-only slots
Read-write locks
Reading XML
Reading ahead
Reading and writing files
Reading and writing memory directly
Readline listener
Recaptcha example
Recaptcha support for Furnace
Record example
Recursive combinator stack effects
Reference image
Reference implementations
Reference protocol
Reference utilities
Reflection support for vocabulary search path
Regular expression combinator rationale
Regular expression combinators
Regular expression options
Regular expression syntax
Regular expressions
Regular expressions and the deploy tool
Relative timestamps
Relocatable VM objects
Remote Channels
Rendering Graphviz output
Rendering graphs by layout engine
Rendering graphs by output format
Rendering text
Reservoir Sampling
Reshaping sequences
Resizable sequence implementation
Resolution of ambiguous word names
Resource disposal anti-patterns
Restartable errors
Result sets
Rewrite responder overview
Roman numerals
Running code on startup
Running hidden processes
Running processes in the background
Runtime code reloading
Ryƫ Float to String Conversion
SHA-2 checksum
SIMD data in struct classes
SIMD vector conversion
SIMD vector types
SIMD vector words
SMTP client library
SSA Destruction
SSA construction
SSL/TLS methods
Safe prime numbers
Sampling profiler
Scaffold tool
Scripting cookbook
Scroller gadgets
Search deques
Searching directories
Searching sequences
Secure redirection
Secure socket addresses
Secure socket configuration
Secure socket contexts
Secure socket errors
Secure sockets (SSL, TLS)
Semaphore examples
Sending and receiving messages
Sequence combinators
Sequence operations
Sequence protocol
Sequences as sets
Sequential result sets
Servers and Furnace
Serving CGI scripts
Serving static content
Session manager configuration
Session state serialization
Set implementations
Set-theoretic operations on assocs
Set-theoretic operations on intervals
Setting breakpoints
Setting environment variables
Setting ports to listen on
Setting process groups
Setting process priority
Setting up SMTP with gmail
Shader objects
Shift JIS
Short-circuit combinators
Shuffle word and definition cookbook
Shuffle words
Signal handlers
Signals that can be handled by Factor
Simple backtracking non-determinism
Singleton classes
Sizes and limits
Skipping escape analysis pass for code which does not allocate
Slider gadgets
Slot accessors
Slot class declarations
Slots syntax sugar
Smart arrow models
Smart combinators
Smart short-circuit combinators
Snake Game
Sorting by multiple keys
Sorting sequences
Source files
Space Invaders Emulator
Span elements
Sparse propagation for branches
Special mapping keys
Special pathnames
Specialized array examples
Specialized array words
Specialized arrays
Specialized vector words
Specialized vectors
Specifying a command
Specifying vertices
Spider tutorial
Spill slot assignment
Splay trees
Splitting sequences
Splitting trending sequences
Spread combinators
Stack Shuffling
Stack checker errors
Stack effect checking
Stack effect checking escape hatches
Stack effect declarations
Stack effect inference implementation
Stack effect row variables
Stack effect syntax
Stack effect tools
Stack finalization
Stack frames
Stack machine model
Standard Chloe tags
Standard color database
Starting and stopping threads
Starting the UI
Starting the UI tools
Startup initialization file
Status bars and mouse-over help
Stepping through code
Storing keys and values in assocs
Straight-line stack effects
Stream example
Stream protocol
Stream utilities
String buffer syntax
String buffers
String streams
String word wrapping
Strongly-typed word definitions
Struct and union types
Struct class examples
Struct classes
Subclassing Objective C classes
Subclassing worlds
Subsequences and slices
Suffix arrays
SuperFastHash checksum
Support for predicated value info
Supported SIMD instruction sets and operations
Symbolic links
Synchronous sends
Syntax extensions for XML
Syntax for python calls from factor
Syntax to control word lookup
System interface
TRACE requests with the HTTP client
Table gadget configuration
Table gadget example
Table gadgets
Table row actions
Table row renderer protocol
Table row selection
Table styles
Tagged pointers
Tail-call optimization
Temporary files
Tensor Operators
Testing image encoders and decoders
Testing sequences
Testing your first program
Tests and Documentation
Text styles
Texture objects
The Boyer-Moore algorithm
The CA file and path
The Game of 24
The Kaleidoscope language
The Object System
The UI co-ordinate system
The Unused Vocabulary Linter
The caret and mark
The debugger
The f object as a sequence
The implementation
The inspector
The key file and password
The language
The lexer
The list protocol
The listener
The parser
The prettyprinter
The process lifecycle
The theory of regular expressions
Thread implementation
Thread-local state and variables
Threaded server configuration
Threaded server examples
Threaded servers
Throwing exceptions on stream exhaustion
Time-Based One-Time Passwords
Timestamp arithmetic
Timing code and collecting statistics
Tips of the day
Tom's Obvious Markup Language (TOML)
Top level forms
Top-level windows
Track layouts
Tracking memory allocations
Translating Factor graphs into DOT
Transposed assoc operations
Treating sequences as stacks
Trigonometric and hyperbolic functions
Trimming sequences
Triple-wise sequence combinators
Tuple arrays
Tuple constructors
Tuple database protocol
Tuple database tutorial
Tuple examples
Tuple introspection
Tuple redefinition
Tuple slot declarations
Tuple subclassing
Tuple subclassing example
Tuple syntax
Tuple unboxing
Tuple-constructing combinators
Type numbers
UI application deployment tool
UI backend window management
UI browser
UI developer tools
UI error list tool
UI framework
UI gestures
UI glossary
UI initialization and the event loop
UI inspector
UI listener
UI pen protocol
UI tool keyboard shortcuts
UI walker
URL encoding and decoding
URL implementation utilities
URL objects
URL rewrite responders
UTF-16 encoding
UTF-32 encoding
UTF-8 encoding
UUID (Universally Unique Identifier)
Unicode category syntax
Unicode data tables
Unicode normalization
Unicode script properties
Unicode support
Uninitialized stack location clearing
Uninterned words
Union classes
Unique files
Unit testing
Universally Unique Lexicographically Sortable Identifier
Unix Process Scheduling
Unix file attributes
Unix file permissions
Unix file timestamps
Unix file user and group ids
Unix groups
Unix users
Unrolled lists
Unrolled sequence iteration combinators
Unsafe array operations
Unsafe combinators
Unsafe sequence operations
Upgrading existing connections
User password recovery
User profile deactivation
User profile editing
User profiles
User registration
Using destructors
Using durations
Utilities for generic word and method defining parsing words
Utilities for traversing XML
Utilities used by several optimization passes run in the later stages
Utility words used by CFG optimization
Utility words used by locals parsing words
VM memory layout constants
VM memory layouts
Value info data type and operations
Value numbering expression graph
Value numbering utilities
Variables for holding stack effect inference state
Vector arithmetic
Vector arithmetic with specialized arrays
Vector component- and bit-wise logic
Vector operations
Vector shuffling, packing, and unpacking
Vector syntax
Vim support
Virtual register representation selection
Virtual sequence protocol
Virtual sequences
Virtual single-assignment registers
Vocabularies cookbook
Vocabulary authors
Vocabulary hierarchy tools
Vocabulary icons
Vocabulary index
Vocabulary loader
Vocabulary metadata
Vocabulary resource metadata
Vocabulary roots
Vocabulary tags
Vreg Coalescing
Watching variables in the listener
What embedding looks like from Factor
Wheel graphs
When not to use tuple subclassing
When the stack is not enough
When to use destructive operations
Where to go from here?
Window controls
Windowed sequences
Word Timer
Word aliasing
Word and grapheme breaks
Word annotations
Word implementation details
Word introspection
Word lookup errors
Word name clashes with C types
Word object wrapping
Word properties
Word syntax
Word wrapping
Working with XML namespaces
Working with binary data
Working with code outside of the Factor source tree
Working with memory-mapped data
Wrapped Hashtable protocol
Writing XML
Writing documentation
Writing efficient SIMD code
Writing new destructors
Writing some logic in your first program
XML data classes
XML data constructors
XML data types
XML entities
XML interpolation syntax
XML literals
XML parser
XML parsing errors
XxHash checksum
YAML control variables
YAML deserialization control
YAML errors
YAML serialization
YAML serialization control
YIQ colors
YUV colors
Year operations
Yielding and suspending threads
Your first program
Z algorithm