Because Funk2 is currently a very active research project, these documentation pages will not be able to explain the cutting edge features of the language and theory of causal reflection or reflective programming. For the time being, please feel free to email the author, Bo Morgan <bo@mit.edu>, if you have questions or bugs to report. There are publications about the intended uses for Funk2 here: Funk2 Home.

Funk2 currently compiles on 32-bit and 64-bit Linux operating systems. 64-bit pointers are recommended because of the amount of memory needed for the reflective capabilities; a 32-bit machine is currently only able to index a few gigabytes of memory.

Here is one straightforward way to write a "Hello world!" program in the Funk2 language:

Here is another more advanced way to holla your planet:

The apropos funktion provides a helpful text search that looks through the local and global environment for funks or metros that have documentation that matches the search string. This feature does not currently search through object type slots, which can be browsed using the lookup_type funktion discuss further below. For now, if you are looking for a sort funktion:

Here is how to define and subsequently call a funktion:

Here is how to loop over a list of values:

Here is how to call our funktion above in a parallel thread:

Here is how to serially filter every element in a list:

Here is how to concurrently filter every element in a list:

Here is one straightforward way to create a new type of frame:

We can create a new dog frame like this:

We can put a new dog frame in a global variable like this:

We can set the dog's color to black like this:

We can see our globalized dog frame like this:

We can get the dog's color like this:

We can ask for brief documentation for any object like this:

We can see our new frame type like this:

Here is how to define and subsequently call a funktion:

Define a property in the current causal frame:

Causal frame definitions are accessed if there is not a local environmental definition:

The shelter command allocates a new parallel fiber with a new cause object. The shelter command takes a list of commands that are executed in sequence. If a bug is encountered, the shelter command returns the symbol sheltered, or otherwise, the normal return value is returned. Following are some examples of how the shelter command may be used:

The shelter command can be used for its new cause frame. Defining new slot values in the new cause frame does not affect the original cause frame:

While the use of the cause frame may not seem to give us much advantage over using normal environment variables, here is an example of how cause frames are different and useful:

The shelter command may be used to guard against bugs that would otherwise stop the currently executing fiber:

As an introduction to basic event tracing, let us start with an example of the funktracer command. The funktracer command executes a block of code every time a funk bytecode is executed. A few local environment variables are defined to describe the funktion call, including the funk and args variables. In our example below, the test-funktracer metro takes a block of code and prints the funktion name and a short list of arguments for every funktion that is called within that block.

Here is an example of how to remember the value of array slots at previous times. Since arrays are the basic memory type in Funk2, almost all objects can be traced using this array-based memory feature:

Graphs with labeled edges and nodes are useful ways of thinking about many computer science ideas. For example, the following objects can be easily converted to and from a graph representation: (1) relational databases, (2) programming language memory objects, (3) causal traces and other procedural relationships, (4) narratives and stories, (5) frame-based objects, (6) social networks, etc. The Funk2 pattern matching is based on recognizing large and exact patterns in graph structures.

read> [deframe dog [frame] [legs weight color]] [deframe dog [frame] [legs weight color]] out-> [] read> [globalize rufus [new dog]] out-> [] read> [get rufus as-graph] out-> [graph   :root_node [graph_node :label [dog :type dog :legs [] :weight [] :color []]]   :nodes     [[graph_node :label [dog :type dog :legs [] :weight [] :color []]] [graph_node :label dog] [graph_node :label []]]   :edges     [[graph_edge :label type :left_node [graph_node :label [dog :type dog :legs [] :weight [] :color []]] :right_node [graph_node :label dog]]               [graph_edge :label color :left_node [graph_node :label [dog :type dog :legs [] :weight [] :color []]] :right_node [graph_node :label []]]               [graph_edge :label weight :left_node [graph_node :label [dog :type dog :legs [] :weight [] :color []]] :right_node [graph_node :label []]]               [graph_edge :label legs :left_node [graph_node :label [dog :type dog :legs [] :weight [] :color []]] :right_node [graph_node :label []]]]] read> [have rufus gview] out-> []

Graphs can also contain variables at nodes and edges. Here, we create a graph from a simple dog frame as in the last example, but we also create another variable graph from this initial graph structure that we store in the rufus-variable_graph global variable. Pay special attention to the very last command, which demonstrates how variable graphs can be matched against object graphs, which returns a hash table of variable bindings. This type of graph matching will be the basis for reflective pattern recognition for building the larger critic-selector architecture within Funk2.

	read> [deframe dog [frame] [legs weight color]] [deframe dog [frame] [legs weight color]] out-> [] read> [globalize rufus [new dog]] out-> [] read> [set rufus legs 4] out-> [] read> [set rufus weight `heavy] out-> [] read> [set rufus color `brown] out-> [] read> [get rufus as-graph] out-> [graph   :root_node [graph_node :label [dog :type dog :legs 4 :weight heavy :color brown]]   :nodes     [[graph_node :label [dog :type dog :legs 4 :weight heavy :color brown]] [graph_node :label 4] [graph_node :label dog] [graph_node :label heavy] [graph_node :label brown]]   :edges     [[graph_edge :label legs :left_node [graph_node :label [dog :type dog :legs 4 :weight heavy :color brown]] :right_node [graph_node :label 4]]               [graph_edge :label type :left_node [graph_node :label [dog :type dog :legs 4 :weight heavy :color brown]] :right_node [graph_node :label dog]]               [graph_edge :label weight :left_node [graph_node :label [dog :type dog :legs 4 :weight heavy :color brown]] :right_node [graph_node :label heavy]]               [graph_edge :label color :left_node [graph_node :label [dog :type dog :legs 4 :weight heavy :color brown]] :right_node [graph_node :label brown]]]] read> [have rufus gview] out-> []
	read> [globalize rufus-variable_graph [get rufus as-graph]] out-> [] read> [have rufus-variable_graph make_node_variable rufus `x] out-> [graph_variable :name x] read> [have rufus-variable_graph make_node_variable 4 `leg_count] out-> [graph_variable :name leg_count] read> [have rufus-variable_graph make_node_variable `heavy `how_heavy] out-> [graph_variable :name how_heavy] read> [have rufus-variable_graph make_edge_variable `color [new graph_variable `x] `brown `brown_property] out-> [graph_variable :name brown_property] read> rufus-variable_graph out-> [graph   :variables [[graph_variable :name x] [graph_variable :name leg_count] [graph_variable :name how_heavy] [graph_variable :name brown_property]]   :root_node [graph_node :label [graph_variable :name x]]   :nodes     [[graph_node :label dog] [graph_node :label brown] [graph_node :label [graph_variable :name x]] [graph_node :label [graph_variable :name leg_count]] [graph_node :label [graph_variable :name how_heavy]]]   :edges     [[graph_edge :label type :left_node [graph_node :label [graph_variable :name x]] :right_node [graph_node :label dog]]               [graph_edge :label [graph_variable :name brown_property] :left_node [graph_node :label [graph_variable :name x]] :right_node [graph_node :label brown]]               [graph_edge :label legs :left_node [graph_node :label [graph_variable :name x]] :right_node [graph_node :label [graph_variable :name leg_count]]]               [graph_edge :label weight :left_node [graph_node :label [graph_variable :name x]] :right_node [graph_node :label [graph_variable :name how_heavy]]]]] read> [have rufus-variable_graph gview] out-> []
	read> [get [get rufus as-graph] contains_match_with_bindings rufus-variable_graph []] out-> [ptypehash :key_count 4 :is_empty [] :write_mutex [mutex :is_locked []] :slot_names [leg_count brown_property how_heavy x] :bin_array ([[x . [dog :type dog :legs 4 :weight heavy :color brown]] [how_heavy . heavy] [brown_property . color]                [leg_count . 4]] [] [] [] [] [] [] [] [] [] [] [] [] [] [] []) :bin_num_power 4]

λ