Morgan Stanley Hobbes

Hobbes is a domain-targeting programming language and execution environment designed for ultra-low latency, high-performance integration with C/C++ applications. It is primarily used for managing the runtime of low-latency processes (like equities trading engines) that require dynamic, in-process rewriting of processing rules and persistence of structured logs without requiring restarts during working hours.

Key capabilities include:

• Dynamic Rule Rewriting: In-process rewriting of processing rules for domain objects such as trades, orders, and executions.
• Structured Logging: Persistence and out-of-band processing of logs for order managers and surrounding processes.
• Low Latency: Optimized for rock-solid, ultra-low latency execution.
• Functional Paradigm: A variant of the pure-functional language Haskell.

Security and Safety Warning: Hobbes is designed for performance over sandboxing. It does not have a sandboxed runtime or runtime safety features. It provides direct access to memory and does not perform array bounds checks. It also supports remote compilation and execution of native code over a network (RPC), which should only be used within trusted internal networks due to the security implications of these design choices.

nil :: () -> (^x.(()+(a*x)))
nil _ = roll(|0=()|)

cons :: (a, ^x.(()+(a*x))) -> (^x.(()+(a*x)))
cons x xs = roll(|1=(x,xs)|)

Hobbes is a specialized language designed for DevOps staff to manage the in-process configuration of extremely low-latency Order Managers (OM).

An Order Manager is responsible for maintaining the state of trade orders and executing logic based on market conditions (e.g., executing a limit order when a stock price hits a specific threshold).

Key requirements addressed by Hobbes:

• Low Latency: Logic must run in the 'hot path' of trading systems where execution speed is critical. Hobbes produces compiled, in-process logic to maximize processor efficiency (mechanical sympathy).
• Dynamic Runtime Changes: The ability to change both the static portion (the operations/logic) and the dynamic portion (the operands/data like stock prices) at runtime without restarting the process.
• Complex Decision Trees: Managing complex trading strategies (algo trading), venue splitting, and credit constraints that would be too slow if implemented with standard type hierarchies or long if-else chains in a high-frequency environment.

Hobbes implements polymorphism through Type Classes, which allow you to externally declare behaviors that a type supports. This enables writing generic functions that work across any data type implementing a specific capability (e.g., addition, multiplication, or printing).

Anonymous Function Syntax

You can define polymorphic functions using lambda syntax. The backslash \ starts the function, and the period . separates the argument list from the function body. Hobbes uses type inference to determine the necessary Type Class restrictions based on the operations used inside the function.

Type Inference and Notation

You can inspect the inferred type of an expression using the :t command. The resulting type notation follows the pattern: Restrictions => (Input Types) -> Return Type

• Restrictions: The part before => specifies the Type Classes required (e.g., Add a b c =>).
• Function Type: The part after => describes the mapping from input to output (e.g., (a * b) -> c).

Common Type Classes

• Add: Required for types supporting the + operator.
• Equiv: For types supporting equivalence/equality.
• Multiply: For types supporting the * operator.
• Print: For types whose values can be printed.

Hobbes supports pattern matching for classifying and destructuring data using match expressions. This generalizes C++ switch statements by allowing matching on multiple values simultaneously, binding variables to parts of the matched value, and using guard expressions for conditional branching.

Key Features

• Multi-value matching: Match against multiple expressions at once (e.g., match x y with).
• Variable Binding: Bind payloads from variant types or sub-elements of structures to variables (e.g., |paymentReceived=x|).
• Regex Matching: When matching character arrays, use regular expressions with named capture groups for binding.
• Guard Expressions: Use the where keyword to add a condition to a match row. The row is only selected if both the pattern matches and the guard evaluates to true.

Requirements for Validity

• Exhaustiveness: Every possible input must have a matching row. It is common practice to include a catch-all row using the _ pattern.
• Reachability: No row should be redundant (i.e., no prior row should fully subsume it). Reachability checks are enabled by default in the compiler.

match x y with
| 0 0 -> "foo"
| 0 1 -> "foobar"
| 1 0 -> "bar"
| 1 1 -> "barbar"
| 2 0 -> "chicken"
| 2 1 -> "chicken bar!"
| _ _ -> "beats me"

For complex parsing tasks that regular expressions cannot handle (like expression languages), hobbes provides a syntax to define LALR(1) parsers based on context-free grammars. You use the parse { RULES } syntax to construct a parser. Rules define both the syntax and "actions" (arbitrary hobbes code) that produce semantic values from the matched rules.

Key features include:

• Rule definitions: Rules can be composed of other rules or lexical constants.
• Value binding: You can bind values matched by sub-rules to variables (e.g., v:V) to use them in the rule's action.
• Left recursion: The parser supports left recursion for handling indefinite-length sequences.
• Ambiguity detection: Hobbes rejects parser definitions that introduce ambiguous choices, ensuring $O(n)$ parse time.

calc = parse {
  E := x:E "+" y:T { x + y }
    |  x:E "-" y:T { x - y }
    |  x:T         { x }

  T := x:T "*" y:F { x * y }
    |  x:T "/" y:F { x / y }
    |  x:F         { x }

  F := "(" x:E ")" { x }
    |  x:V         { x }

  V := v:V d:D { v*10 + d }
    |  d:D     { d }

  D := "0" {0} | "1" {1} | "2" {2} | "3" {3} | "4" {4}
    |  "5" {5} | "6" {6} | "7" {7} | "8" {8} | "9" {9}
}

Match expressions allow you to perform actions based on the value or type of an expression. They work top-down: the first valid case encountered is executed.

Key Rules:

• Wildcards: The underscore _ acts as a wildcard (default case) or an instruction not to bind a name to the matched element.
• Exhaustiveness: The compiler requires that all potential options are covered. If a match is not exhaustive, you must add a default case (e.g., _).
• Reachability: Every case must be reachable; a case that matches everything must not appear before more specific cases.
• Type Consistency: Since match is an expression, all branches must return the same type. Failing to do so results in a type unification error.
• Terse Syntax: Match expressions can be written on a single line for idiomatic, concise code.

Matching Multiple Values

When matching against multiple values (like a tuple), you must provide the correct number of underscores/patterns to match the expected column count.

Example of a simple match:

match 3 with 
| 1 -> show("hello")
| 2 -> show("hobbes")
| _ -> show("oops!")

Example of a match expression assigned to a variable:

hostport = match env with | "prod" -> "lnprd" | "qa" -> "euqa" | _ -> "ln123dev"