Call for Code Samples about www.ziglang.org HOT 11 CLOSED

// compile with `zig build-exe zig-curl-test.zig --library curl --library c $(pkg-config --cflags libcurl)`
const std = @import("std");
const cURL = @cImport({
    @cInclude("curl/curl.h");
});

pub fn main() !void {
    var arena_state = std.heap.ArenaAllocator.init(std.heap.c_allocator);
    defer arena_state.deinit();
    var allocator = &arena_state.allocator;

    // global curl init, or fail
    if (cURL.curl_global_init(cURL.CURL_GLOBAL_ALL) != .CURLE_OK)
        return error.CURLGlobalInitFailed;

    // curl easy handle init, or fail
    const handle = cURL.curl_easy_init() orelse return error.CURLHandleInitFailed;
    // defer curl cleanup
    defer {
        cURL.curl_easy_cleanup(handle);
        cURL.curl_global_cleanup();
    }

    var response_buffer = std.ArrayList(u8).init(allocator);
    defer response_buffer.deinit();

    // setup curl options
    if (cURL.curl_easy_setopt(handle, .CURLOPT_URL, "https://ziglang.org") != .CURLE_OK)
        return error.CouldNotSetURL;

    // set write function callbacks
    if (cURL.curl_easy_setopt(handle, .CURLOPT_WRITEFUNCTION, writeToArrayListCallback) != .CURLE_OK)
        return error.CouldNotSetWriteCallback;
    if (cURL.curl_easy_setopt(handle, .CURLOPT_WRITEDATA, &response_buffer) != .CURLE_OK)
        return error.CouldNotSetWriteCallback;

    // perform
    if (cURL.curl_easy_perform(handle) != .CURLE_OK)
        return error.FailedToPerformRequest;

    std.log.info("Got response of {} bytes", .{response_buffer.items.len});
    std.debug.print("{}\n", .{response_buffer.items});
}

fn writeToArrayListCallback(data: *c_void, size: c_uint, nmemb: c_uint, user_data: *c_void) callconv(.C) c_uint {
    var buffer = @intToPtr(*std.ArrayList(u8), @ptrToInt(user_data));
    var typed_data = @intToPtr([*]u8, @ptrToInt(data));
    buffer.appendSlice(typed_data[0 .. nmemb * size]) catch return 0;
    return nmemb * size;
}

const std = @import("std");

fn LinkedList(comptime T: type) type {
    return struct {
        data: T,
        next: ?*LinkedList(T),

        pub fn from_list(values: []const T, alloc: *std.mem.Allocator) error{OutOfMemory}!?*LinkedList(T) {
            if (values.len == 0) return null;

            const tail = values[1..];
            const allocated = try alloc.create(LinkedList(T));
            allocated.* = LinkedList(T) {
                .data = values[0],
                .next = try from_list(tail, alloc)
            };
            return allocated;
        }
    };
}

pub fn main() !void {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
     const alloc = &arena.allocator;

    // i32 is a type, not a value!
    const i32LinkedList = LinkedList(i32);

    const values: []const i32 = &[_]i32{1,2,3,4};
    const x = try i32LinkedList.from_list(values, alloc);
    var v = x.?;
    while (true) {
        v = v.next orelse break;
        std.debug.print("{}", .{v.data});
    }
}

        next: ?*const LinkedList(T),
        pub fn fromList(…) ?*const LinkedList(T) {
…
    const x = comptime i32LinkedList.from_list(values);
    var v = x.?;
    while (true) {
        v = v.next orelse break;
        std.debug.print("{}", .{v.data});
    }

const std = @import("std");

fn LinkedList(comptime T: type) type {
    return struct {
        data: T,
        next: ?*LinkedList(T),

        pub fn from_list(values: []const T) ?*LinkedList(T) {
            if (values.len == 0) return null;

            const tail = values[1..];
            return &LinkedList(T) {
                .data = values[0],
                .next = from_list(tail)
            };
        }
    };
}

pub fn main() void {
    // i32 is a type, not a value!
    const i32LinkedList = LinkedList(i32);

    const values: []const i32 = &[_]i32{1,2,3,4};
    const x = i32LinkedList.from_list(values);
    std.debug.print("{}", .{x});
}

const std = @import("std");

pub fn main() !u8 {
    // an arena allocator only frees memory at the very end when deinit is called.
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const alloc = &arena.allocator;

    const stdout_w = std.io.getStdOut().writer();
    const stdin_r = std.io.getStdIn().reader();

    const args = try std.process.argsAlloc(alloc);
    // defer std.process.argsFree(args) // this is not necessary because the arena will free automatically

    for (args[1..]) |arg| {
        if (std.mem.eql(u8, arg, "--help")) {
            try stdout_w.writeAll(
                \\Usage:
                \\    io [options…]
                \\Options:
                \\    --help: Print this message
            );
            return 0;
        }
        try stdout_w.writeAll("Unknown arg, see --help");
        return 1;
    }

    try stdout_w.writeAll("What is your name? ");
    const name = try stdin_r.readUntilDelimiterAlloc(alloc, '\n', 200);
    // defer alloc.free(name);
    // the last argument is max_bytes. this should be set to a reasonable length, or std.math.maxInt(usize)
    // if you want your program to fill up all the memory when someone gives it a huge file.

    try stdout_w.print("Hi {}! My name is zig!\n", .{name});

    return 0;
}

const std = @import("std");

pub const io_mode = .evented; // this variable is read by lib/std/start.zig and sets a variable at comptime to make stdlib functions use async/await

fn reader(num: *i32) !void {
    const stdin = std.io.getStdIn().reader();
    const stdout = std.io.getStdOut().writer();

    while (true) {
        try stdin.skipUntilDelimiterOrEof('\n');
        try stdout.print("{}\n", .{@atomicLoad(i32, num, .Unordered)});
    }
}

fn spin(num: *i32) void {
    while (true) {
        std.time.sleep(1 * std.time.ns_per_s);
        @atomicStore(i32, num, @atomicLoad(i32, num, .Unordered) + 1, .Unordered);
    }
}

pub fn main() !void {
    var num: i32 = 0;
    var reader_frame = async reader(&num);
    var spin_frame = async spin(&num);

    await spin_frame;
    try await reader_frame;
}