coding-style

F# Coding Style Preferences

Based on analysis of existing codebase (/mnt/c/projects/advent-of-code-2024), follow these consistent coding patterns:

1. Pipe Operators and Data Flow

• Heavy preference for pipe operators (|>) over nested parentheses
• Multi-line pipe chains with aligned operators
• Example:

  // Preferred pipeline style
  input
  |> List.map parseRule
  |> List.filter isValid
  |> List.collect expand
  |> Set.ofList
  
  // Use parentheses only for: function calls with multiple args, complex expressions, tuples
  abs (x - y)
  (r1,c1),(r2,c2)
  

2. Naming Conventions

• Descriptive names: validUpdates, robotLocation, firstNonBoxLoc
• Short names for common patterns: r, c for row/column, h, t for head/tail
• camelCase throughout: maxRow, inBounds
• Plural forms for collections: rules, updates, obstacles

3. Function Definitions

• Simple let bindings: let coord (r,c) = 100*r+c
• Pattern matching with function keyword:

  let parseCommand =
      function
      | '^' -> U | '>' -> R
      | 'v' -> D | '<' -> L
  

• Multi-line definitions with clear indentation

4. Pattern Matching (Preferred over conditionals)

• List patterns: | [] -> base | h :: t -> process h t
• Tuple destructuring: | (r1,c1),(r2,c2) when r1 = r2 ->
• Discriminated union patterns
• failwith for unexpected cases: | unknown -> failwith $"unknown %A{unknown}"

5. Collection Processing - PURE FUNCTIONAL STYLE

• NEVER use for loops - use collection functions instead
• Higher-order functions: List.map, List.filter, List.collect, List.fold, List.mapi, List.choose
• Pipeline transformations: Chain operations with |>
• Immutable data structures: List, Set, Map, Array (but prefer List)
• Functional patterns:
  • Use List.fold for accumulation instead of mutable counters
  • Use List.filter instead of conditional accumulation
  • Use List.choose for map filter combinations
  • Use List.mapi when you need index access