• Publish code in canonical format to a repository database
• Work with repository code without downloading it all first
• Publish mutually recursive definitions
• stretch: Documentation-only UX

Any type can be thrown as an exception. All we need is some new node types to work with them.

• Exception handling node + evaluation
• Exception raising node + evaluation
• Type cast assertion node + evaluation

• Allow language switching (get list from Google Translate)
• Auto-translate the source language into the current language with Google Translate if the current language isn't available
• Allow the user to "vet" a translated string

Deleting definitions

• delete if it's always disconnected
• warn if it's used and connected

Inlining functions

• Bust a node, dropping its contents into the graph still properly connected
• Join a set of selected nodes into a new definition, still properly connected. Show an error if this isn't possible.

Function pointer <-> inline functions

• Turn a function pointer into an inline function
• Turn an inline function into a function pointer if it doesn't make use of the parent scope.

Replacing nodes

• Replace a node. If it's connected on keyword nibs, show a UI to match up the new nibs to the old nibs where necessary. Otherwise just replace it.

• All edits push new states onto the history. Errors are not included. The active definition is included, but changing it does not push a new state.
• History states have short descriptions. The history can be displayed as a list.
• History states can be returned to by clicking them in the history list or clicking Undo.
• Returning to an old state navigates you to a relevant definition
• Un-done state is not lost, but rather stored in a graph-like fashion that tracks the heads and can be returned to at any time.
• How should this interact with collaboration? History items could include the user who did them. Reverts would not always be possible.

The app needs to be a joy to use on your iPad.

• Make touchable areas larger

Changing scopes

• Visualize the dragging
• Enable touch dragging

Code quality

• Change to the standard way of iterating through touches

Checklist to Factorial

Implementing the factorial function is a good first milestone for this project. The editor needs to be capable of creating and executing this function.

It will need these definitions:

• Yes: Label(nothing)
• No: Label(nothing)
• Boolean: Union(Yes, No)
• Branch: External((Boolean, 'a, 'a) => 'a)
• <=: External((Number, Number) => Boolean)
• *: External((Number, Number) => Number)
• -: External((Number, Number) => Number)

Ability to create it more from scratch:

• Can execute the function
• Can create labels
• Can create unions

Elements

Definition types

• New union types, implemented as a set.
• Label types

Node types

• Symbol
• Label constructor
• Label accessor
• Exception raising node
• Exception handling node
• Type cast assertion node

Definition Uses

• List where a definition is used.
• Links to jump to those uses.
• Differentiate between connected and disconnected in uses

Editing

Definitions

• fork

Deleting definitions

• delete if it's always disconnected
• warn if it's used and connected

Inputs/Outputs

• add
• change name
• change order
• change name in graph
• change order in graph

Removing Inputs/Outputs

• remove if it wouldn't break connections
• warn if it would break connections
• list affected graphs

Connections

• Add
• Select
• Remove

Avoid creating invalid connections

• Prevent cycles
• Prevent crossing of scope boundaries unless it's a source in an ancestor scope leading to a sink in a child scope

Nodes

• Select
• Sort nodes by depth so they can be selected
• Remove, breaking connections

Create

• Create simple value nodes
• Create a node while connecting to a specific input/output
• Create, disconnected, in the selected scope (no selection = graph scope)
• Create all types

Change Scope

• Drag into a different scope
• Prevent dragging into an invalid scope
• Visualize the dragging
• Enable touch dragging

Refactoring

• Turn a function pointer into an inline function
• Turn an inline function into a function pointer if it doesn't make use of the parent scope.
• Bust a node, dropping its contents into the graph still properly connected
• Join a set of selected nodes into a new definition, still properly connected. Show an error if this isn't possible.
• Replace a node. If it's connected on keyword nibs, show a UI to match up the new nibs to the old nibs where necessary. Otherwise just replace it.

Undo

• All edits push new states onto the history. Errors are not included. The active definition is included, but changing it does not push a new state.
• History states have short descriptions. The history can be displayed as a list.
• History states can be returned to by clicking them in the history list or clicking Undo.
• Returning to an old state navigates you to a relevant definition
• Un-done state is not lost, but rather stored in a graph-like fashion that tracks the heads and can be returned to at any time.
• How should this interact with collaboration? History items could include the user who did them. Reverts would not always be possible.

Translation

• Allow language switching (get list from Google Translate)
• Auto-translate the source language into the current language with Google Translate if the current language isn't available
• Allow the user to "vet" a translated string

Auto-Save

• Persist to localStorage automatically
• Checkbox to disable this and reset to defaults

The old version of this project had a program where you could move a box around with the arrow keys. I should implement that here so this is a full upgrade.