The Sidef Programming Language

<div align="center">

            **   **         ****   *           *********   *********
          * * ** * *        ****   **          ** ** **    ** ** **
           **   **          ****   ***         *********   *  *  *
  **        **        **    ****   *  *        ******      ******
* * *     * * *     * * *   ****   ** **       ** **       ** **
 **        **        **     ****   ******      ******      *  *
       **   **              ****   *  *  *     *********   ***
     * * ** * *             ****   ** ** **    ** ** **    **
      **   **               ****   *********   *********   *

A modern, high-level programming language for versatile general-purpose applications

Website • Tutorial • Documentation • Try Online • Discussions

</div>

---

🌟 Why Sidef?

Sidef is a modern, expressive programming language that combines the elegance of Ruby, the versatility of Raku, and the mathematical power of a built-in computer algebra system. It features exact rational arithmetic by default, an extensive number theory library (1,000+ functions), and seamless Perl module integration — making it equally at home for scripting, mathematical research, and general-purpose programming.

# Exact rational arithmetic — no floating-point surprises
say (1/3 + 1/6)         #=> 1/2

# Built-in number theory
say (2**127 - 1)        #=> 170141183460469231731687303715884105727 (Mersenne prime)
say factor(2**64 - 1)   #=> [3, 5, 17, 257, 641, 65537, 6700417]

# Expressive, concise syntax
say 71.primes           #=> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]

✨ Key Features

Programming Paradigms

• Object-oriented programming with multiple dispatch
• Functional programming and pattern matching
• Lexical scoping and closures
• Keyword arguments and optional lazy evaluation

Numeric Computing

• Exact rational numbers by default
• Arbitrary-precision integers, floats, and complex numbers
• 1,000+ built-in number theory functions (backed by GMP, MPFR, MPC)
• Gaussian integers, quaternions, matrices, polynomials

Language & Integration

• Regular expressions and string interpolation
• Optional dynamic type checking
• Seamless Perl module integration
• REPL with interactive help (-H flag)

🚀 Quick Start

Prerequisites

Sidef requires Perl 5.18+ and the following C libraries:

| Library | Purpose | |---------|---------| | GMP | Big integers and rationals | | MPFR | Arbitrary-precision floats | | MPC | Arbitrary-precision complex numbers |

Debian/Ubuntu:

sudo apt-get install libgmp-dev libmpfr-dev libmpc-dev

Arch Linux:

sudo pacman -S gmp mpfr libmpc

Termux:

pkg install perl make clang libgmp libmpfr libmpc

Installation

Via CPAN:

cpan Sidef
# or (skip tests for faster install):
cpan -T Sidef
# or with cpanminus:
cpanm Sidef

Build from source:

git clone https://github.com/trizen/sidef.git
cd sidef
perl Makefile.PL
make
make test
make install

Via AUR:

trizen -S sidef

Platform packages:

• Arch Linux: AUR package
• Slackware: SlackBuilds
• Other systems: See pkgs.org

Hello World

say "Hello, World!"

sidef hello.sf
sidef -E 'say "Hello, World!"'
sidef -i            # start the REPL

Try It Online

Experiment with Sidef instantly at Try It Online without any installation.

🔤 Language at a Glance

Variables and Types

var name   = "Sidef"               # String
var num    = 42                    # Number (exact integer)
var ratio  = 3/7                   # Rational (exact)
var arr    = [1, 2, 3]             # Array
var hash   = Hash(a => 1, b => 2)  # Hash
var block  = {|n| n.is_prime }     # Block

Functions and Pattern Matching

func greet(name) { "Hello, #{name}!" }
say greet("world")    #=> Hello, world!

# Multi-dispatch / pattern matching
func fib({|n| n == 0 }) { 0 }
func fib({|n| n == 1 }) { 1 }
func fib(n) { fib(n-1) + fib(n-2) }

say fib(10)    #=> 55

Object-Oriented Programming

class Animal(name, sound) {
    method speak { say "#{name} says #{sound}!" }
}

class Dog(name) < Animal(name, "woof") {
    method fetch { say "#{name} fetches the ball!" }
}

var d = Dog("Rex")
d.speak    #=> Rex says woof!
d.fetch    #=> Rex fetches the ball!

Functional Programming

var nums = 1..10   # Range object

# Map, filter, reduce
var evens   = nums.grep { .is_even }              #=> [2, 4, 6, 8, 10]
var squares = nums.map  { |n| n**2 }              #=> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
var total   = nums.reduce { |a, b| a + b }        #=> 55

say evens
say squares
say total

Number Theory

say primes(50, 100)          # array of primes in range [50, 100]
say prrime_count(10**9)      # number of primes up to 10^9
say prime(100)               # 100th prime => 541
say 12.divisors              # [1, 2, 3, 4, 6, 12]
say euler_phi(100)           # Euler's totient => 40
say gcd(48, 18)              # => 6
say is_prime(2**521 - 1)     # Mersenne prime check => true

Lazy Evaluation

# Infinite lazy list of primes
var lazy_primes = (2..Inf -> lazy.grep { .is_prime })
say lazy_primes.first(10)    #=> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

⌨️ Command-Line Reference

sidef [options] [script.sf] [script-arguments]

| Flag | Description | |------|-------------| | -E 'code' | Execute a one-line program | | -e 'code' | Alias for -E | | -i [file] | Start the interactive REPL (optionally loading a file) | | -c | Compile script to a stand-alone Perl program | | -C | Check syntax only (parse without execution) | | -r | Deparse program back to Sidef code | | -R lang | Deparse to another language (perl, sidef) | | -P int | Set floating-point precision in bits (default: 192) | | -O level | Optimization level: 0 (none), 1 (recommended), 2 (max) | | -s | Enable precompilation (cache compiled code) | | -t | Test mode: treat all arguments as script files | | -D | Dump the Abstract Syntax Tree (AST) | | -H | Interactive help mode for exploring documentation |

Examples:

sidef -E 'say 10.of { |i| i**2 }'            # one-liner
sidef -i                                     # start REPL
sidef -i script.sf                           # run script in REPL
sidef -C script.sf                           # syntax check
sidef -c -o output.pl script.sf              # compile to Perl
sidef -P 400 -E 'say sqrt(2)'                # 400-bit precision
sidef -O1 script.sf                          # with optimization
sidef -r script.sf                           # deparse to Sidef
sidef -t tests/*.sf                          # run test files

🖥️ Interactive Mode (REPL)

Start the REPL with sidef -i:

$ sidef -i
sidef> say "Hello!"
Hello!
sidef> x = 2**64
18446744073709551616
sidef> x.is_prime
false
sidef> is_prime(2**127 - 1)
true
sidef> 1..10 -> map { .square }.sum
385
sidef> quit

Use -H to open interactive documentation help:

sidef -H

🎯 Code Examples

Classes and Inheritance

class Shape {
    method area { die "Not implemented" }
    method describe { say "I am a #{self.class} with area #{self.area}" }
}

class Circle(r) < Shape {
    method area { Num.pi * r**2 }
}

class Rectangle(w, h) < Shape {
    method area { w * h }
}

Circle(5).describe        #=> I am a Circle with area 78.539...
Rectangle(4, 6).describe  #=> I am a Rectangle with area 24

Functional Array Processing

# FizzBuzz in one line
say (1..20 -> map { |n|
    n%%15 ? "FizzBuzz" : (n%%3 ? "Fizz" : (n%%5 ? "Buzz" : n))
})

# Pipeline style
(1..50).grep { .is_prime } \
       .map  { .square } \
       .first(5) \
       .say    #=> [4, 9, 25, 49, 121]

Number Theory One-Liners

say 100.by { .is_prime }              # first 100 primes
say sum(1..100)                       #=> 5050
say prod(1..10)                       #=> 3628800  (10!)
say { .euler_phi }.map(1..10)         #=> [1, 1, 2, 2, 4, 2, 6, 4, 6, 4]

The Y Combinator

Demonstrating functional programming with the Y combinator:

var y = ->(f) {->(g) {g(g)}(->(g) { f(->(*args) {g(g)(args...)})})}

var fac = ->(f) { ->(n) { n < 2 ? 1 : (n * f(n-1)) } }
say 10.of { |i| y(fac)(i) }     #=> [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]

var fib = ->(f) { ->(n) { n < 2 ? n : (f(n-2) + f(n-1)) } }
say 10.of { |i| y(fib)(i) }     #=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Sierpinski Triangle

ASCII generation of the Sierpinski triangle:

func sierpinski_triangle(n) {
    var triangle = ['*']
    { |i|
        var sp = (' ' * 2**i)
        triangle = (triangle.map {|x| sp + x + sp} +
                    triangle.map {|x| x + ' ' + x})
    } * n
    triangle.join("\n")
}

say sierpinski_triangle(4)

<details> <summary>Show Output</summary>

               *