view release on metacpan or  search on metacpan

SIDEF_ADVANCED_GUIDE.md  view on Meta::CPAN

var lines = (1..5).map { "Line #{_}" }
File("out.txt").write(lines.join("\n") + "\n")
```

### Directory Operations

```ruby
# List files in a directory
Dir(".").each { |entry|
    say entry if entry =~ /\.sf$/
}

# Recursive file finder
func find_files(dir, pattern) {
    gather {
        Dir(dir).each_r { |f|
            take(f) if (f =~ pattern)
        }
    }
}

find_files(".", /\.sf$/).each { |f| say f }
```

### File Metadata

```ruby
var f = File("script.sf")

say f.exists        # true/false
say f.size          # size in bytes
say f.mtime         # modification time
say f.is_file       # true
say f.is_dir        # false
say f.abs_path      # absolute path
```

### Pipe and Shell Integration

```ruby
# Run a command and iterate its output lines
Pipe("ls -la").each_line { |line|
    say line if line =~ /\.sf$/
}

# Capture output
var git_log = %x(git log --oneline -10)
git_log.lines.each { |line| say line.trim }
```

---

## 15. Perl Module Integration

Any CPAN module can be used directly, making Sidef's ecosystem enormous.

### Object-Oriented Perl Modules

```ruby
# HTTP requests
var ua       = require('LWP::UserAgent').new
var response = ua.get('https://api.github.com')
say response.decoded_content

# JSON encoding/decoding
var json    = require('JSON')
var encoded = json.encode(Hash(name => "Alice", scores => [98, 87, 92]))
say encoded

var decoded = json.decode('{"x":1,"y":2}')
say decoded{:x}    # 1
```

### Functional Perl Modules

```ruby
var posix = frequire('POSIX')
say posix.floor(3.7)    # 3
say posix.ceil(3.2)     # 4

var list_util = frequire('List::Util')
say list_util.sum(1..10)    # 55
say list_util.max(3,1,4,1,5,9,2,6)    # 9
say list_util.shuffle([1..10]...)
```

### Using Perl's DBI for Databases

```ruby
var dbi = require('DBI')
var dbh = dbi.connect("dbi:SQLite:dbname=test.db", "", "")

dbh.do("CREATE TABLE IF NOT EXISTS users (id INTEGER, name TEXT)")
dbh.do("INSERT INTO users VALUES (1, 'Alice')")

var sth = dbh.prepare("SELECT * FROM users WHERE id = ?")
sth.execute(1)

while (var row = sth.fetchrow_hashref) {
    say "#{row{:id}}: #{row{:name}}"
}
dbh.disconnect
```

---

## 16. Sorting Algorithms

Sidef makes it easy to implement and compare classic algorithms.

### Quicksort

```ruby
func quicksort(arr) {
    return arr if (arr.len <= 1)
    var pivot = arr[arr.len / 2]
    var left  = arr.grep { _ < pivot }
    var mid   = arr.grep { _ == pivot }
    var right = arr.grep { _ > pivot }
    [quicksort(left)..., mid..., quicksort(right)...]
}

say quicksort([3, 6, 8, 10, 1, 2, 1])    # [1, 1, 2, 3, 6, 8, 10]
```

### Merge Sort

```ruby
func merge(a, b) {
    var result = []
    while (a && b) {
        result << (a[0] <= b[0] ? a.shift : b.shift)
    }
    [result..., a..., b...]
}

func mergesort(arr) {
    return arr if (arr.len <= 1)
    var mid = arr.len / 2
    merge(mergesort(arr[0 .. mid-1]), mergesort(arr[mid .. arr.end]))
}

say mergesort([5, 2, 8, 1, 9, 3])    # [1, 2, 3, 5, 8, 9]
```

### Radix Sort

```ruby
func radix_sort(arr, base = 10) {
    return arr if (arr.len <= 1)