Rye

Very flexible (but uniform) about the language

Everything is an Expression

All constructs (even control flow, print, assignments) return a value. Expression based code composes better and requires less state handling. And it's easier to write in Rye.

b: print 123 + a: print 123
; prints:
; 123
; 234 and assigns 123 to a and 234 to b

direction: 'out
print2 either direction = 'in { "Hello" } { "Bye" } ", mr. Jones"
; prints:
; Bye, mr. Jones

load\csv %bears.csv |column? 'weight |with { .avg .print , .max .print }
; prints:
; 214
; 749    

Code is Data

Rye code consists of Rye values (e.g., blocks, words, literal values, ...). There is no difference between Rye code and Rye data. This brings internal consistency and options for code introspection.

thats-true: { print "That's true" }

do thats-true
; prints That's true    
    
if 1 > 0 thats-true
; prints That's true    

person: context { name: "Joe" }
print-name: fn\in { } person { print name }
; prints Joe

First-Class Everything

Words, functions, blocks of code, scopes (contexts), and literals are all values that can be created, passed, returned, or assigned. Every value of Rye Runtime is also accessible to the language itself.

some-word: 'this-word
some-func: fn { x } { x + 1 }

inspect-fn: fn { f } {
  print2 "Code: " dump ?f
  print2 "Result f(100): " f 100
}

inspect-fn ?some-func
; prints:
; Code: fn { x } { x + 1 }
; Result f(100): 101

some-scope: context { name: "Joe" }
print-name: fn\in { } some-scope { print name }
; prints Joe

Functions are all you need

Rye has no keywords and no special forms. For example if, loop, fn, try, return are all built-in functions and every active component of the language is just a built-in or an ordinary function call.

probe ?if
; Prints:
; [Pure BFunction(2): Executes a block of code if the condition is true, returning the result of the block or false.]

probe ?fn
; Prints:
; [Pure BFunction(2): Creates a function with named parameters specified in the first block and code in the second block.]

; our custom if
if-joe: fn { n code } { if n = "Joe" { do code } }
if-joe "Joe" { print "Hey" }
; prints Hey
    
flip-flop-loop: fn { n a b } { .loop { .is-odd .either { a } { b } |do } }
flip-flop-loop 5 { prns "Tik" } { prns "Tok" }
; Prints:
; Tik Tok Tik Tok Tik

Very strict about state

Constants by default

Words you define with set-words are all constants and can't be redefined in given context. This being the default gives you certainty that by default things won't change under your feet.

name: "Tango"

name: "Cash"
; produces error, you can't use a set-word (one colon) to set an already set word

name:: "Cash"
; also produces error, you can't use a mod-word (two colons) to modify a constant

; you need to use var, or mod-word directly to define or modify a variable word
var 'current-month "January"
current-month:: "February"

current-year:: 2024  ; mod-word also creates a variable word if not yet created
current-year:: 2025

cant-redefine: fn { } { "me" }

Explicit about modification of a word

As we've demonstrated above, set-words can only set words once. Modification of a word is visually explicit, and somewhat visually painfull, so you only use it when you have concrete reason.

{ "jim" "jane" "oto" } .for { :name , print capitalize name }
; produces error, set-word can't set an already set word

    
; sometimes you must modify a value of the word
{ "jim" "jane" "oto" } .for { ::name , print capitalize name }
; prints:
; Jim
; Jane
; Oto

; but also a lot of those cases can be solved better
{ "jim" "jane" "oto" } .for { .capitalize .print }
; prints:
; Jim
; Jane
; Oto

No invisible modification in-place

Rye code usually always returns a new value rather than modify a value and it has good support for this way of solving problems. For rare and specific cases where you do need to chanve a value in-place, the functions it has must end with exclamation mark (!).

; many cases where you would use append have better solutions
names: { "jane" "anne" "john" }

; you don't want to do this
jay-s: { }
for names {
    ::n
    if first n = "j" { append! jay-s n }
}

; if you can do 
filter names { .first = "j" }
    

Failures, Not Nulls

Functions return the result or Fail, not nulls.
Unhandled failures become runtime errors (e.g., try or match to recover).

State and Data Flow

Information-Oriented Flow

Minimize state; emphasize data transformation pipelines.

Separation of State and Logic

Data is immutable by default; mutation is explicit and localized.
"Practically functional": pure functions where possible, controlled side effects where needed.

Explicit Validation

Declarative validation DSL.

Data Structures

Table Datatype

Built-in spreadsheet-like tables for tabular data (e.g., SQL-like ops, columnar transforms).

Philosophy

Words-in-Context

Avoid paradigm-specific terms (e.g., "methods," "monads").
Focus on "words" (symbols) bound to functions/values in named contexts (scopes).

Errors vs. Failures

Failures: Expected, recoverable (e.g., "file not found").
Errors: Bugs; halt execution and debug.