windjammer 0.48.0

A simple language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

// std/csv - CSV parsing and writing
// Thin wrapper over the csv crate for clean Windjammer APIs

use csv

// Read CSV from string, returns vector of string records
fn parse(data: string) -> Result<Vec<Vec<string>>, csv.Error> {
    let mut reader = csv.Reader.from_reader(data.as_bytes())
    let mut records = Vec.new()
    
    for result in reader.records() {
        let record = result?
        let row: Vec<string> = record.map(|field| "${field}").collect()
        records.push(row)
    }
    
    Ok(records)
}

// Read CSV with headers, returns headers and data separately
fn parse_with_headers(data: string) -> Result<(Vec<string>, Vec<Vec<string>>), csv.Error> {
    let mut reader = csv.Reader.from_reader(data.as_bytes())
    
    // Get headers
    let headers = reader.headers()?
        .map(|h| "${h}")
        .collect()
    
    // Get records
    let mut records = Vec.new()
    for result in reader.records() {
        let record = result?
        let row: Vec<string> = record.map(|field| "${field}").collect()
        records.push(row)
    }
    
    Ok((headers, records))
}

// Write CSV from vector of records
fn write(records: &[Vec<string>]) -> Result<string, csv.Error> {
    let mut writer = csv.Writer.from_writer(vec![])
    
    for record in records {
        writer.write_record(record)?
    }
    
    let data = writer.into_inner()?
    match String.from_utf8(data) {
        Ok(s) => Ok(s),
        Err(_) => Err(csv.Error.from(std.io.Error.new(std.io.ErrorKind.InvalidData, "Invalid UTF-8")))
    }
}

// Write CSV with headers
fn write_with_headers(headers: &[string], records: &[Vec<string>]) -> Result<string, csv.Error> {
    let mut writer = csv.Writer.from_writer(vec![])
    
    // Write headers
    writer.write_record(headers)?
    
    // Write records
    for record in records {
        writer.write_record(record)?
    }
    
    let data = writer.into_inner()?
    match String.from_utf8(data) {
        Ok(s) => Ok(s),
        Err(_) => Err(csv.Error.from(std.io.Error.new(std.io.ErrorKind.InvalidData, "Invalid UTF-8")))
    }
}

// Parse CSV from bytes
fn parse_bytes(data: &[u8]) -> Result<Vec<Vec<string>>, csv.Error> {
    let mut reader = csv.Reader.from_reader(data)
    let mut records = Vec.new()
    
    for result in reader.records() {
        let record = result?
        let row: Vec<string> = record.map(|field| "${field}").collect()
        records.push(row)
    }
    
    Ok(records)
}

// Create a CSV reader with custom delimiter
fn reader_with_delimiter(data: string, delimiter: u8) -> csv.ReaderBuilder {
    csv.ReaderBuilder.new()
        .delimiter(delimiter)
        .from_reader(data.as_bytes())
}

// Create a CSV writer with custom delimiter
fn writer_with_delimiter(delimiter: u8) -> csv.WriterBuilder {
    csv.WriterBuilder.new()
        .delimiter(delimiter)
        .from_writer(vec![])
}