Most programming languages treat control structures like if, for, and while as sacred syntax—special forms with rigid rules. But what if they were just ordinary functions? Languages like Rye, REBOL, and Red embrace this paradigm, transforming how developers compose logic. Here's why it matters:

The Core Shift: Control Flow as Data

In Python, control structures require dedicated syntax:

if temperature > 30:
    print("Hot!")

Rye reimagines this as a function call:

if temperature > 30 { print "Hot!" }

The critical insight? Code blocks { ... } are inert data until explicitly evaluated. The if function accepts a condition and a block, deciding whether to execute it. No keywords, no magic—just functions and values.

Three Revolutionary Implications

  1. Consistency: One pattern rules all. Loops, conditionals, and functions share identical call syntax:
    loop 3 { print "Hey!" }  
add: fn { a b } { a + b }
  2. Flexibility: Compose control flow like any other function. Pipe conditions into if or reuse code blocks:
    temperature > 30 |if { print "Hot!" }
hot-code: { print "Hot!" }  
unless tired hot-code
  3. Extensibility: Craft custom control structures. Need until or FizzBuzz logic? Define it:
    until { count > 5 } { print count }
cases {  
  {n .multiple-of 3} { "Fizz" }  
  {n .multiple-of 5} { "Buzz" }
}

The Power Unleashed

  • Partial Application: Create new control logic by binding arguments:
    three-times: partial ?loop [ 3 _ ]
three-times { print "Composable!" }
  • Higher-Order Flow: Inject functions into control structures:
    verbose-if: fn { cond block } { 
  probe cond; probe block; if cond block 
}
  • Library Integration: External tools (like OpenAI bindings) extend control flow naturally:
    Chat\stream "Tell a joke" { .prn }

The Trade-offs

  • Performance: Function calls incur runtime overhead vs. compile-time optimized syntax.
  • Tooling: IDEs struggle to provide specialized support without syntactic landmarks.

Yet this simplicity has advantages: Language implementers optimize one construct (function calls) instead of dozens of special forms. The result? A universe where every developer can reshape the language itself—no core privileges, no syntactic barriers.

Source: Rye Language Blog