~tieong/ziglings

40656031c568b346b7eb47118be7c0dc04cc89b6 — Dave Gauer 2 years ago 7d29fd8 + c7868de
Merge branch 'main' of github.com:ratfactor/ziglings into main
M exercises/005_arrays2.zig => exercises/005_arrays2.zig +1 -1
@@ 33,7 33,7 @@ pub fn main() void {
    // have a little preview of Zig 'for' loops instead:
    //
    //    for (<item array>) |item| { <do something with item> }
    // 
    //
    // Don't worry, we'll cover looping properly in upcoming
    // lessons.
    //

M exercises/053_slices2.zig => exercises/053_slices2.zig +1 -1
@@ 31,5 31,5 @@ pub fn main() void {
}

fn printPhrase(part1: []u8, part2: []u8, part3: []u8) void {
    std.debug.print("'{s} {s} {s}.' ", .{part1, part2, part3});
    std.debug.print("'{s} {s} {s}.' ", .{ part1, part2, part3 });
}

M exercises/059_integers.zig => exercises/059_integers.zig +1 -1
@@ 23,6 23,6 @@ pub fn main() void {
        0b1101000, // binary
        0x66,      // hex
    };
        

    print("{s} is cool.\n", .{zig});
}

M exercises/060_floats.zig => exercises/060_floats.zig +2 -2
@@ 59,7 59,7 @@ pub fn main() void {
//         |  exponent     significand
//         |
//          sign
//    
//
// This example is the decimal number 3.140625, which happens to
// be the closest representation of Pi we can make with an f16
// due to the way IEEE-754 floating points store digits:


@@ 86,6 86,6 @@ pub fn main() void {
//
// Fun fact: sometimes you'll see the significand labeled as a
// "mantissa" but Donald E. Knuth says not to do that.
//     
//
// C compatibility fact: There is also a Zig floating point type
// specifically for working with C ABIs called c_longdouble.

M exercises/061_coercions.zig => exercises/061_coercions.zig +1 -1
@@ 22,7 22,7 @@
//    const arr: [3]u8 = [3]u8{5, 6, 7};
//    const s: []const u8 = &arr;  // to slice
//    const p: [*]const u8 = &arr; // to many-item pointer
//    
//
// 4. Single-item mutable pointers can coerce to single-item
//    pointers pointing to an array of length 1. (Interesting!)
//

M exercises/064_builtins.zig => exercises/064_builtins.zig +4 -4
@@ 1,7 1,7 @@
//
// The Zig compiler provides "builtin" functions. You've already
// gotten used to seeing an @import() at the top of every
// Ziglings exercise. 
// Ziglings exercise.
//
// We've also seen @intCast() in "016_for2.zig", "058_quiz7.zig";
// and @enumToInt() in "036_enums2.zig".


@@ 51,10 51,10 @@ pub fn main() void {
    //    1111 + 1 = 0000      Yes! (Real answer is 10000)
    //    0000 + 1 = 0001      Yes!
    //    0001 + 1 = 0010      Yes!
    // 
    //
    // Also, check out our fancy formatting! b:0>4 means, "print
    // as a binary number, zero-pad right-aligned four digits."
    print("{b:0>4} + {b:0>4} = {b:0>4} ({})", .{a, b, my_result, overflowed});
    print("{b:0>4} + {b:0>4} = {b:0>4} ({})", .{ a, b, my_result, overflowed });

    print(". Furthermore, ", .{});



@@ 70,5 70,5 @@ pub fn main() void {
    // this builtin to reverse the bits of a u8 integer.
    const input: u8 = 0b11110000;
    const tupni: u8 = @bitReverse(input);
    print("{b:0>8} backwards is {b:0>8}.\n", .{input, tupni});
    print("{b:0>8} backwards is {b:0>8}.\n", .{ input, tupni });
}

M exercises/065_builtins2.zig => exercises/065_builtins2.zig +8 -8
@@ 1,7 1,7 @@
//
// Zig has builtins for mathematical operations such as...
//
//      @sqrt        @sin          @cos 
//      @sqrt        @sin          @cos
//      @exp         @log          @floor
//
// ...and lots of type casting operations such as...


@@ 20,18 20,18 @@
// by exploring just THREE of Zig's MANY introspection abilities:
//
// 1. @This() type
// 
//
// Returns the innermost struct, enum, or union that a function
// call is inside.
//
// 2. @typeInfo(comptime T: type) @import("std").builtin.TypeInfo
// 
//
// Returns information about any type in a TypeInfo union which
// will contain different information depending on which type
// you're examining.
// 
//
// 3. @TypeOf(...) type
// 
//
// Returns the type common to all input parameters (each of which
// may be any expression). The type is resolved using the same
// "peer type resolution" process the compiler itself uses when


@@ 46,14 46,14 @@ const Narcissus = struct {
    me: *Narcissus = undefined,
    myself: *Narcissus = undefined,
    echo: void = undefined,
    

    fn fetchTheMostBeautifulType() type {
        return @This();
    }
};

pub fn main() void {
    var narcissus: Narcissus = Narcissus {};
    var narcissus: Narcissus = Narcissus{};

    // Oops! We cannot leave the 'me' and 'myself' fields
    // undefined. Please set them here:


@@ 70,7 70,7 @@ pub fn main() void {
    // fix this call:
    const T2 = narcissus.fetchTheMostBeautifulType();

    print("A {} loves all {}es. ", .{T1, T2});
    print("A {} loves all {}es. ", .{ T1, T2 });

    //   His final words as he was looking in
    //   those waters he habitually watched

M exercises/066_comptime.zig => exercises/066_comptime.zig +4 -4
@@ 27,10 27,10 @@
//
// Zig takes these concepts further by making these optimizations
// an integral part of the language itself!
// 
//
const print = @import("std").debug.print;

pub fn main() void  {
pub fn main() void {
    // ALL numeric literals in Zig are of type comptime_int or
    // comptime_float. They are of arbitrary size (as big or
    // little as you need).


@@ 46,7 46,7 @@ pub fn main() void  {
    const const_int = 12345;
    const const_float = 987.654;

    print("Immutable: {}, {d:.3}; ", .{const_int, const_float});
    print("Immutable: {}, {d:.3}; ", .{ const_int, const_float });

    // But something changes when we assign the exact same values
    // to identifiers mutably with "var".


@@ 69,7 69,7 @@ pub fn main() void  {
    var_int = 54321;
    var_float = 456.789;

    print("Mutable: {}, {d:.3}; ", .{var_int, var_float});
    print("Mutable: {}, {d:.3}; ", .{ var_int, var_float });

    // Bonus: Now that we're familiar with Zig's builtins, we can
    // also inspect the types to see what they are, no guessing

M exercises/067_comptime2.zig => exercises/067_comptime2.zig +3 -3
@@ 8,7 8,7 @@
//        --o--            comptime        *    |      ..    .
//     *    |       *  .        .    .   .    --*--  .     *  .
//  .     .    .    .   . . .      .        .   |   .    .  .
//        
//
// When placed before a variable declaration, 'comptime'
// guarantees that every usage of that variable will be performed
// at compile time.


@@ 30,7 30,7 @@
//
const print = @import("std").debug.print;

pub fn main() void  {
pub fn main() void {
    //
    // In this contrived example, we've decided to allocate some
    // arrays using a variable count! But something's missing...


@@ 49,7 49,7 @@ pub fn main() void  {
    count += 1;
    var a4: [count]u8 = .{'D'} ** count;

    print("{s} {s} {s} {s}\n", .{a1, a2, a3, a4});
    print("{s} {s} {s} {s}\n", .{ a1, a2, a3, a4 });

    // Builtin BONUS!
    //

M exercises/068_comptime3.zig => exercises/068_comptime3.zig +4 -4
@@ 61,10 61,10 @@ const Schooner = struct {
    }
};

pub fn main() void  {
    var whale = Schooner {.name = "Whale"};
    var shark = Schooner {.name = "Shark"};
    var minnow = Schooner {.name = "Minnow"};
pub fn main() void {
    var whale = Schooner{ .name = "Whale" };
    var shark = Schooner{ .name = "Shark" };
    var minnow = Schooner{ .name = "Minnow" };

    // Hey, we can't just pass this runtime variable as an
    // argument to the scaleMe() method. What would let us do

M exercises/069_comptime4.zig => exercises/069_comptime4.zig +3 -3
@@ 13,14 13,14 @@
//
const print = @import("std").debug.print;

pub fn main() void  {
pub fn main() void {
    // Here we declare arrays of three different types and sizes
    // at compile time from a function call. Neat!
    const s1 = makeSequence(u8, 3);  // creates a [3]u8
    const s2 = makeSequence(u32, 5); // creates a [5]u32
    const s3 = makeSequence(i64, 7); // creates a [7]i64

    print("s1={any}, s2={any}, s3={any}\n", .{s1, s2, s3});
    print("s1={any}, s2={any}, s3={any}\n", .{ s1, s2, s3 });
}

// This function is pretty wild because it executes at runtime


@@ 49,6 49,6 @@ fn makeSequence(comptime T: type, ??? size: usize) [???]T {
    while (i < size) : (i += 1) {
        sequence[i] = @intCast(T, i) + 1;
    }
    

    return sequence;
}

M exercises/070_comptime5.zig => exercises/070_comptime5.zig +1 -1
@@ 140,6 140,6 @@ fn isADuck(possible_duck: anytype) bool {
        // error, not a runtime panic or crash!
        possible_duck.quack();
    }
        

    return is_duck;
}

M exercises/072_comptime7.zig => exercises/072_comptime7.zig +2 -2
@@ 49,7 49,7 @@ pub fn main() void {
            '*' => value *= digit,
            else => unreachable,
        }
        // ...But it's quite a bit more exciting than it first appears. 
        // ...But it's quite a bit more exciting than it first appears.
        // The 'inline while' no longer exists at runtime and neither
        // does anything else not touched directly by runtime
        // code. The 'instructions' string, for example, does not


@@ 61,6 61,6 @@ pub fn main() void {
        // code at compile time. Guess we're compiler writers
        // now. See? The wizard hat was justified after all.
    }
    

    print("{}\n", .{value});
}

M exercises/073_comptime8.zig => exercises/073_comptime8.zig +1 -1
@@ 56,7 56,7 @@ fn getLlama(i: usize) u32 {
}

// Fun fact: this assert() function is identical to
// std.debug.assert() from the Zig Standard Library. 
// std.debug.assert() from the Zig Standard Library.
fn assert(ok: bool) void {
    if (!ok) unreachable;
}

M exercises/075_quiz8.zig => exercises/075_quiz8.zig +3 -3
@@ 54,12 54,12 @@ fn makePath(from: *Place, to: *Place, dist: u8) Path {

// Using our new function, these path definitions take up considerably less
// space in our program now!
const a_paths = [_]Path{ makePath(&a, &b, 2) };
const a_paths = [_]Path{makePath(&a, &b, 2)};
const b_paths = [_]Path{ makePath(&b, &a, 2), makePath(&b, &d, 1) };
const c_paths = [_]Path{ makePath(&c, &d, 3), makePath(&c, &e, 2) };
const d_paths = [_]Path{ makePath(&d, &b, 1), makePath(&d, &c, 3), makePath(&d, &f, 7) };
const e_paths = [_]Path{ makePath(&e, &c, 2), makePath(&e, &f, 1) };
const f_paths = [_]Path{ makePath(&f, &d, 7) };
const f_paths = [_]Path{makePath(&f, &d, 7)};
//
// But is it more readable? That could be argued either way.
//


@@ 69,7 69,7 @@ const f_paths = [_]Path{ makePath(&f, &d, 7) };
//
// For example, we could create our own "path language" and
// create Paths from that. Something like this, perhaps:
// 
//
//    a -> (b[2])
//    b -> (a[2] d[1])
//    c -> (d[3] e[2])

M exercises/077_sentinels2.zig => exercises/077_sentinels2.zig +2 -2
@@ 22,7 22,7 @@
// Versatility! Zig strings are compatible with C strings (which
// are null-terminated) AND can be coerced to a variety of other
// Zig types:
// 
//
//     const a: [5]u8 = "array".*;
//     const b: *const [16]u8 = "pointer to array";
//     const c: []const u8 = "slice";


@@ 50,7 50,7 @@ pub fn main() void {
    //
    // Luckily, the 'length' field makes it possible to still
    // work with this value.
    const foo = WeirdContainer {
    const foo = WeirdContainer{
        .data = "Weird Data!",
        .length = 11,
    };

M exercises/079_quoted_identifiers.zig => exercises/079_quoted_identifiers.zig +1 -1
@@ 13,7 13,7 @@
// past the authorities: the @"" identifier quoting syntax.
//
//     @"foo"
//     
//
// Please help us safely smuggle these fugitive identifiers into
// our program:
//

M exercises/082_anonymous_structs3.zig => exercises/082_anonymous_structs3.zig +1 -1
@@ 29,7 29,7 @@
// If a .{} thing is what the print function wants, do we need to
// break our "tuple" apart and put it in another one? No! It's
// redundant! This will print the same thing:
//     
//
//     print("{} {}\n", foo);
//
// Aha! So now we know that print() takes a "tuple". Things are

M exercises/084_async.zig => exercises/084_async.zig +1 -1
@@ 37,7 37,7 @@
//     fn bar() void {
//         fooThatSuspends();
//     }
//     
//
// 6. The main() function cannot be async!
//
// Given facts 3 and 4, how do we fix this program (broken by facts

M exercises/085_async2.zig => exercises/085_async2.zig +0 -1
@@ 26,4 26,3 @@ fn foo() void {
    suspend {}
    print("async!\n", .{});
}


M exercises/089_async6.zig => exercises/089_async6.zig +1 -1
@@ 44,7 44,7 @@ pub fn main() void {
    var com_title = com_frame;
    var org_title = org_frame;

    print(".com: {s}, .org: {s}.\n", .{com_title, org_title});
    print(".com: {s}, .org: {s}.\n", .{ com_title, org_title });
}

fn getPageTitle(url: []const u8) []const u8 {

M exercises/090_async7.zig => exercises/090_async7.zig +1 -1
@@ 10,7 10,7 @@
//     fn bar() void {
//         fooThatMightSuspend(true); // Now bar() is async!
//     }
// 
//
// But if you KNOW the function won't suspend, you can make a
// promise to the compiler with the 'nosuspend' keyword:
//