mirror of
https://codeberg.org/andyscott/ziglings.git
synced 2024-11-08 19:20:47 -05:00
Merge pull request #22 from quexxon/apply-zig-fmt
Apply `zig fmt` to exercises and generate remaining patch files
This commit is contained in:
commit
a2b6b68a25
81 changed files with 422 additions and 196 deletions
|
@ -2,7 +2,7 @@
|
|||
// Oh no! This program is supposed to print "Hello world!" but it needs
|
||||
// your help!
|
||||
//
|
||||
//
|
||||
//
|
||||
// Zig functions are private by default but the main() function should
|
||||
// be public.
|
||||
//
|
||||
|
@ -19,4 +19,3 @@ const std = @import("std");
|
|||
fn main() void {
|
||||
std.debug.print("Hello world!\n", .{});
|
||||
}
|
||||
|
||||
|
|
|
@ -24,7 +24,7 @@
|
|||
// const bar: u16 = 2000;
|
||||
//
|
||||
// You can do just about any combination of these that you can think of:
|
||||
//
|
||||
//
|
||||
// u32 can hold 0 to 4,294,967,295
|
||||
// i64 can hold −9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
|
||||
//
|
||||
|
@ -47,5 +47,5 @@ pub fn main() void {
|
|||
// is a string. The string may contain placeholders '{}', and the
|
||||
// second parameter is an "anonymous list literal" (don't worry
|
||||
// about this for now!) with the values to be printed.
|
||||
std.debug.print("{} {} {}\n", .{n, pi, negative_eleven});
|
||||
std.debug.print("{} {} {}\n", .{ n, pi, negative_eleven });
|
||||
}
|
||||
|
|
|
@ -46,6 +46,7 @@ pub fn main() void {
|
|||
// Use the len property to get the length of the array:
|
||||
const length = some_primes.???;
|
||||
|
||||
std.debug.print("First: {}, Fourth: {}, Length: {}\n",
|
||||
.{first, fourth, length});
|
||||
std.debug.print("First: {}, Fourth: {}, Length: {}\n", .{
|
||||
first, fourth, length,
|
||||
});
|
||||
}
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
//
|
||||
// Now that we've learned about arrays, we can talk about strings.
|
||||
//
|
||||
//
|
||||
// We've already seen Zig string literals: "Hello world.\n"
|
||||
//
|
||||
// Zig stores strings as arrays of bytes.
|
||||
|
@ -33,8 +33,7 @@ pub fn main() void {
|
|||
const major_tom = major ??? tom;
|
||||
|
||||
// That's all the problems. Let's see our results:
|
||||
std.debug.print("d={u} {s}{s}\n",.{d, laugh, major_tom});
|
||||
//
|
||||
std.debug.print("d={u} {s}{s}\n", .{ d, laugh, major_tom });
|
||||
// Keen eyes will notice that we've put 'u' and 's' inside the '{}'
|
||||
// placeholders in the format string above. This tells the
|
||||
// print() function to format the values as a UTF-8 character and
|
||||
|
|
|
@ -8,17 +8,17 @@
|
|||
// \\Line One
|
||||
// \\Line Two
|
||||
// ;
|
||||
//
|
||||
//
|
||||
// See if you can make this program print some song lyrics.
|
||||
//
|
||||
const std = @import("std");
|
||||
|
||||
pub fn main() void {
|
||||
const lyrics =
|
||||
const lyrics =
|
||||
Ziggy played guitar
|
||||
Jamming good with Andrew Kelley
|
||||
And the Spiders from Mars
|
||||
;
|
||||
|
||||
std.debug.print("{s}\n",.{lyrics});
|
||||
std.debug.print("{s}\n", .{lyrics});
|
||||
}
|
||||
|
|
|
@ -11,7 +11,7 @@
|
|||
//
|
||||
// a == b means "a equals b"
|
||||
// a < b means "a is less than b"
|
||||
// a !=b means "a does not equal b"
|
||||
// a != b means "a does not equal b"
|
||||
//
|
||||
// The important thing about Zig's "if" is that it *only* accepts
|
||||
// boolean values. It won't coerce numbers or other types of data
|
||||
|
|
|
@ -14,4 +14,3 @@ pub fn main() void {
|
|||
|
||||
std.debug.print("With the discount, the price is ${}.\n", .{price});
|
||||
}
|
||||
|
||||
|
|
|
@ -13,7 +13,7 @@
|
|||
// a == b means "a equals b"
|
||||
// a < b means "a is less than b"
|
||||
// a > b means "a is greater than b"
|
||||
// a !=b means "a does not equal b"
|
||||
// a != b means "a does not equal b"
|
||||
//
|
||||
const std = @import("std");
|
||||
|
||||
|
@ -21,7 +21,7 @@ pub fn main() void {
|
|||
var n: u32 = 2;
|
||||
|
||||
// Please use a condition that is true UNTIL "n" reaches 1024:
|
||||
while ( ??? ){
|
||||
while (???) {
|
||||
// Print the current number
|
||||
std.debug.print("{} ", .{n});
|
||||
|
||||
|
|
|
@ -5,9 +5,9 @@
|
|||
//
|
||||
// Example:
|
||||
//
|
||||
// while (condition) : (continue expression){
|
||||
// while (condition) : (continue expression) {
|
||||
//
|
||||
// if(other condition) continue;
|
||||
// if (other condition) continue;
|
||||
//
|
||||
// }
|
||||
//
|
||||
|
@ -21,11 +21,11 @@ pub fn main() void {
|
|||
|
||||
// I want to print every number between 1 and 20 that is NOT
|
||||
// divisible by 3 or 5.
|
||||
while (n <= 20) : (n+=1) {
|
||||
while (n <= 20) : (n += 1) {
|
||||
// The '%' symbol is the "modulo" operator and it
|
||||
// returns the remainder after division.
|
||||
if(n % 3 == 0) ???;
|
||||
if(n % 5 == 0) ???;
|
||||
if (n % 3 == 0) ???;
|
||||
if (n % 5 == 0) ???;
|
||||
std.debug.print("{} ", .{n});
|
||||
}
|
||||
|
||||
|
|
|
@ -1,9 +1,9 @@
|
|||
//
|
||||
// You can force a loop to exit immediately with a "break" statement:
|
||||
//
|
||||
// while (condition) : (continue expression){
|
||||
// while (condition) : (continue expression) {
|
||||
//
|
||||
// if(other condition) break;
|
||||
// if (other condition) break;
|
||||
//
|
||||
// }
|
||||
//
|
||||
|
@ -17,8 +17,8 @@ pub fn main() void {
|
|||
|
||||
// Oh dear! This while loop will go forever!?
|
||||
// Please fix this so the print statement below gives the desired output.
|
||||
while (true) : (n+=1) {
|
||||
if(???) ???;
|
||||
while (true) : (n += 1) {
|
||||
if (???) ???;
|
||||
}
|
||||
|
||||
// Result: we want n=4
|
||||
|
|
|
@ -16,13 +16,12 @@ pub fn main() void {
|
|||
std.debug.print("A Dramatic Story: ", .{});
|
||||
|
||||
for (???) |???| {
|
||||
if(scene == 'h') std.debug.print(":-) ", .{});
|
||||
if(scene == 's') std.debug.print(":-( ", .{});
|
||||
if(scene == 'n') std.debug.print(":-| ", .{});
|
||||
if (scene == 'h') std.debug.print(":-) ", .{});
|
||||
if (scene == 's') std.debug.print(":-( ", .{});
|
||||
if (scene == 'n') std.debug.print(":-| ", .{});
|
||||
}
|
||||
|
||||
std.debug.print("The End.\n", .{});
|
||||
}
|
||||
//
|
||||
// Note that "for" loops also work on things called "slices"
|
||||
// which we'll see later.
|
||||
|
|
|
@ -19,10 +19,10 @@ function main() void {
|
|||
??? (i <= stop_at) : (i += 1) {
|
||||
if (i % 3 == 0) std.debug.print("Fizz", .{});
|
||||
if (i % 5 == 0) std.debug.print("Buzz", .{});
|
||||
if ( !(i % 3 == 0) and !(i % 5 == 0) ) {
|
||||
if (!(i % 3 == 0) and !(i % 5 == 0)) {
|
||||
std.debug.print("{}", .{???});
|
||||
}
|
||||
std.debug.print(", ", .{});
|
||||
}
|
||||
std.debug.print("\n",.{});
|
||||
std.debug.print("\n", .{});
|
||||
}
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
// writing one of our own:
|
||||
//
|
||||
// fn foo(n: u8) u8 {
|
||||
// return n+1;
|
||||
// return n + 1;
|
||||
// }
|
||||
//
|
||||
// The foo() function above takes a number "n" and returns a number that is
|
||||
|
@ -19,11 +19,10 @@ const std = @import("std");
|
|||
pub fn main() void {
|
||||
// The new function deepThought() should return the number 42. See below.
|
||||
const answer: u8 = deepThought();
|
||||
|
||||
|
||||
std.debug.print("Answer to the Ultimate Question: {}\n", .{answer});
|
||||
}
|
||||
|
||||
//
|
||||
// Please define the deepThought() function below.
|
||||
//
|
||||
// We're just missing a couple things. One thing we're NOT missing is the
|
||||
|
|
|
@ -3,11 +3,11 @@
|
|||
// example that takes two parameters. As you can see, parameters
|
||||
// are declared just like any other types ("name": "type"):
|
||||
//
|
||||
// fn myFunction( number: u8, is_lucky: bool ) {
|
||||
// fn myFunction(number: u8, is_lucky: bool) {
|
||||
// ...
|
||||
// }
|
||||
//
|
||||
const std = @import( "std" );
|
||||
const std = @import("std");
|
||||
|
||||
pub fn main() void {
|
||||
std.debug.print("Powers of two: {} {} {} {}\n", .{
|
||||
|
@ -18,7 +18,6 @@ pub fn main() void {
|
|||
});
|
||||
}
|
||||
|
||||
//
|
||||
// Please give this function the correct input parameter(s).
|
||||
// You'll need to figure out the parameter name and type that we're
|
||||
// expecting. The output type has already been specified for you.
|
||||
|
|
|
@ -5,16 +5,15 @@
|
|||
//
|
||||
// Both of these are simply labeled "loop" below.
|
||||
//
|
||||
const std = @import( "std" );
|
||||
const std = @import("std");
|
||||
|
||||
pub fn main() void {
|
||||
const my_numbers = [4]u16{ 5,6,7,8 };
|
||||
const my_numbers = [4]u16{ 5, 6, 7, 8 };
|
||||
|
||||
printPowersOfTwo(my_numbers);
|
||||
std.debug.print("\n", .{});
|
||||
}
|
||||
|
||||
//
|
||||
// You won't see this every day: a function that takes an array with
|
||||
// exactly four u16 numbers. This is not how you would normally pass
|
||||
// an array to a function. We'll learn about slices and pointers in
|
||||
|
@ -28,7 +27,6 @@ fn printPowersOfTwo(numbers: [4]u16) ??? {
|
|||
}
|
||||
}
|
||||
|
||||
//
|
||||
// This function bears a striking resemblance to twoToThe() in the last
|
||||
// exercise. But don't be fooled! This one does the math without the aid
|
||||
// of the standard library!
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
// In Zig, an error is a value. Errors are named so we can identify
|
||||
// things that can go wrong. Errors are created in "error sets", which
|
||||
// are just a collection of named errors.
|
||||
//
|
||||
//
|
||||
// We have the start of an error set, but we're missing the condition
|
||||
// "TooSmall". Please add it where needed!
|
||||
const MyNumberError = error{
|
||||
|
@ -16,13 +16,13 @@ const MyNumberError = error{
|
|||
const std = @import("std");
|
||||
|
||||
pub fn main() void {
|
||||
var nums = [_]u8{2,3,4,5,6};
|
||||
var nums = [_]u8{ 2, 3, 4, 5, 6 };
|
||||
|
||||
for (nums) |n| {
|
||||
std.debug.print("{}", .{n});
|
||||
|
||||
const number_error = numberFail(n);
|
||||
|
||||
|
||||
if (number_error == MyNumberError.TooBig) {
|
||||
std.debug.print(">4. ", .{});
|
||||
}
|
||||
|
@ -40,7 +40,7 @@ pub fn main() void {
|
|||
// Notice how this function can return any member of the MyNumberError
|
||||
// error set.
|
||||
fn numberFail(n: u8) MyNumberError {
|
||||
if(n > 4) return MyNumberError.TooBig;
|
||||
if(n < 4) return MyNumberError.TooSmall; // <---- this one is free!
|
||||
if (n > 4) return MyNumberError.TooBig;
|
||||
if (n < 4) return MyNumberError.TooSmall; // <---- this one is free!
|
||||
return MyNumberError.TooFour;
|
||||
}
|
||||
|
|
|
@ -16,7 +16,7 @@
|
|||
//
|
||||
const std = @import("std");
|
||||
|
||||
const MyNumberError = error{ TooSmall };
|
||||
const MyNumberError = error{TooSmall};
|
||||
|
||||
pub fn main() void {
|
||||
var my_number: ??? = 5;
|
||||
|
@ -27,4 +27,3 @@ pub fn main() void {
|
|||
|
||||
std.debug.print("I compiled!", .{});
|
||||
}
|
||||
|
||||
|
|
|
@ -8,13 +8,13 @@
|
|||
//
|
||||
const std = @import("std");
|
||||
|
||||
const MyNumberError = error{ TooSmall };
|
||||
const MyNumberError = error{TooSmall};
|
||||
|
||||
pub fn main() void {
|
||||
var a: u32 = addTwenty(44) catch 22;
|
||||
var b: u32 = addTwenty(4) ??? 22;
|
||||
var b: u32 = addTwenty(4) ??? 22;
|
||||
|
||||
std.debug.print("a={}, b={}", .{a,b});
|
||||
std.debug.print("a={}, b={}", .{ a, b });
|
||||
}
|
||||
|
||||
// Please provide the return type from this function.
|
||||
|
|
|
@ -23,9 +23,9 @@ pub fn main() void {
|
|||
// that makeJustRight() returns a error union (for now).
|
||||
var a: u32 = makeJustRight(44) catch 0;
|
||||
var b: u32 = makeJustRight(14) catch 0;
|
||||
var c: u32 = makeJustRight(4) catch 0;
|
||||
var c: u32 = makeJustRight(4) catch 0;
|
||||
|
||||
std.debug.print("a={}, b={}, c={}", .{a,b,c});
|
||||
std.debug.print("a={}, b={}, c={}", .{ a, b, c });
|
||||
}
|
||||
|
||||
// In this silly example we've split the responsibility of making
|
||||
|
@ -37,7 +37,9 @@ pub fn main() void {
|
|||
// detectProblems() Returns the number or an error.
|
||||
//
|
||||
fn makeJustRight(n: u32) MyNumberError!u32 {
|
||||
return fixTooBig(n) catch |err| { return err; };
|
||||
return fixTooBig(n) catch |err| {
|
||||
return err;
|
||||
};
|
||||
}
|
||||
|
||||
fn fixTooBig(n: u32) MyNumberError!u32 {
|
||||
|
@ -45,14 +47,14 @@ fn fixTooBig(n: u32) MyNumberError!u32 {
|
|||
if (err == MyNumberError.TooBig) {
|
||||
return 20;
|
||||
}
|
||||
|
||||
|
||||
return err;
|
||||
};
|
||||
}
|
||||
|
||||
fn fixTooSmall(n: u32) MyNumberError!u32 {
|
||||
// Oh dear, this is missing a lot! But don't worry, it's nearly
|
||||
// identical to fixTooBig() above.
|
||||
// identical to fixTooBig() above.
|
||||
//
|
||||
// If we get a TooSmall error, we should return 10.
|
||||
// If we get any other error, we should return that error.
|
||||
|
@ -65,4 +67,3 @@ fn detectProblems(n: u32) MyNumberError!u32 {
|
|||
if (n > 20) return MyNumberError.TooBig;
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
|
@ -17,13 +17,12 @@ const MyNumberError = error{
|
|||
pub fn main() void {
|
||||
var a: u32 = addFive(44) catch 0;
|
||||
var b: u32 = addFive(14) catch 0;
|
||||
var c: u32 = addFive(4) catch 0;
|
||||
var c: u32 = addFive(4) catch 0;
|
||||
|
||||
std.debug.print("a={}, b={}, c={}", .{a,b,c});
|
||||
std.debug.print("a={}, b={}, c={}", .{ a, b, c });
|
||||
}
|
||||
|
||||
fn addFive(n: u32) MyNumberError!u32 {
|
||||
//
|
||||
// This function needs to return any error which might come back from detect().
|
||||
// Please use a "try" statement rather than a "catch".
|
||||
//
|
||||
|
@ -37,4 +36,3 @@ fn detect(n: u32) MyNumberError!u32 {
|
|||
if (n > 20) return MyNumberError.TooBig;
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
|
@ -9,7 +9,6 @@ pub fn main() void {
|
|||
|
||||
for (animals) |a| printAnimal(a);
|
||||
|
||||
|
||||
std.debug.print("done.\n", .{});
|
||||
}
|
||||
|
||||
|
@ -21,9 +20,18 @@ fn printAnimal(animal: u8) void {
|
|||
|
||||
std.debug.print(") ", .{}); // <---- how!?
|
||||
|
||||
if (animal == 'g'){ std.debug.print("Goat", .{}); return; }
|
||||
if (animal == 'c'){ std.debug.print("Cat", .{}); return; }
|
||||
if (animal == 'd'){ std.debug.print("Dog", .{}); return; }
|
||||
if (animal == 'g') {
|
||||
std.debug.print("Goat", .{});
|
||||
return;
|
||||
}
|
||||
if (animal == 'c') {
|
||||
std.debug.print("Cat", .{});
|
||||
return;
|
||||
}
|
||||
if (animal == 'd') {
|
||||
std.debug.print("Dog", .{});
|
||||
return;
|
||||
}
|
||||
|
||||
std.debug.print("Unknown", .{});
|
||||
}
|
||||
|
|
|
@ -15,7 +15,6 @@
|
|||
//
|
||||
const std = @import("std");
|
||||
|
||||
//
|
||||
var counter: u32 = 0;
|
||||
|
||||
const MyErr = error{ GetFail, IncFail };
|
||||
|
@ -25,8 +24,8 @@ pub fn main() void {
|
|||
var a: u32 = makeNumber() catch return;
|
||||
var b: u32 = makeNumber() catch return;
|
||||
|
||||
std.debug.print("Numbers: {}, {}\n", .{a,b});
|
||||
}
|
||||
std.debug.print("Numbers: {}, {}\n", .{ a, b });
|
||||
}
|
||||
|
||||
fn makeNumber() MyErr!u32 {
|
||||
std.debug.print("Getting number...", .{});
|
||||
|
@ -35,7 +34,7 @@ fn makeNumber() MyErr!u32 {
|
|||
// function exits with an error:
|
||||
std.debug.print("failed!\n", .{});
|
||||
|
||||
var num = try getNumber(); // <-- This could fail!
|
||||
var num = try getNumber(); // <-- This could fail!
|
||||
|
||||
num = try increaseNumber(num); // <-- This could ALSO fail!
|
||||
|
||||
|
@ -52,7 +51,7 @@ fn getNumber() MyErr!u32 {
|
|||
fn increaseNumber(n: u32) MyErr!u32 {
|
||||
// I fail after the first time you run me!
|
||||
if (counter > 0) return MyErr.IncFail;
|
||||
|
||||
|
||||
// Sneaky, weird global stuff.
|
||||
counter += 1;
|
||||
|
||||
|
|
|
@ -21,8 +21,6 @@
|
|||
// alert();
|
||||
// return GameError.TooManyPlayers;
|
||||
// }
|
||||
//
|
||||
//
|
||||
//
|
||||
const std = @import("std");
|
||||
|
||||
|
@ -31,15 +29,15 @@ pub fn main() void {
|
|||
|
||||
for (lang_chars) |c| {
|
||||
switch (c) {
|
||||
1 => std.debug.print("A", .{}),
|
||||
2 => std.debug.print("B", .{}),
|
||||
3 => std.debug.print("C", .{}),
|
||||
4 => std.debug.print("D", .{}),
|
||||
5 => std.debug.print("E", .{}),
|
||||
6 => std.debug.print("F", .{}),
|
||||
7 => std.debug.print("G", .{}),
|
||||
8 => std.debug.print("H", .{}),
|
||||
9 => std.debug.print("I", .{}),
|
||||
1 => std.debug.print("A", .{}),
|
||||
2 => std.debug.print("B", .{}),
|
||||
3 => std.debug.print("C", .{}),
|
||||
4 => std.debug.print("D", .{}),
|
||||
5 => std.debug.print("E", .{}),
|
||||
6 => std.debug.print("F", .{}),
|
||||
7 => std.debug.print("G", .{}),
|
||||
8 => std.debug.print("H", .{}),
|
||||
9 => std.debug.print("I", .{}),
|
||||
10 => std.debug.print("J", .{}),
|
||||
// ... we don't need everything in between ...
|
||||
25 => std.debug.print("Y", .{}),
|
||||
|
|
|
@ -16,15 +16,15 @@ pub fn main() void {
|
|||
|
||||
for (lang_chars) |c| {
|
||||
var real_char: u8 = switch (c) {
|
||||
1 => 'A',
|
||||
2 => 'B',
|
||||
3 => 'C',
|
||||
4 => 'D',
|
||||
5 => 'E',
|
||||
6 => 'F',
|
||||
7 => 'G',
|
||||
8 => 'H',
|
||||
9 => 'I',
|
||||
1 => 'A',
|
||||
2 => 'B',
|
||||
3 => 'C',
|
||||
4 => 'D',
|
||||
5 => 'E',
|
||||
6 => 'F',
|
||||
7 => 'G',
|
||||
8 => 'H',
|
||||
9 => 'I',
|
||||
10 => 'J',
|
||||
// ...
|
||||
25 => 'Y',
|
||||
|
|
|
@ -16,7 +16,7 @@
|
|||
//
|
||||
// WE know there are only three operations but Zig doesn't. Use the
|
||||
// unreachable statement to make the switch complete. Or ELSE. :-)
|
||||
//
|
||||
//
|
||||
const std = @import("std");
|
||||
|
||||
pub fn main() void {
|
||||
|
@ -26,9 +26,15 @@ pub fn main() void {
|
|||
|
||||
for (operations) |op| {
|
||||
switch (op) {
|
||||
1 => { current_value += 1; },
|
||||
2 => { current_value -= 1; },
|
||||
3 => { current_value *= current_value; },
|
||||
1 => {
|
||||
current_value += 1;
|
||||
},
|
||||
2 => {
|
||||
current_value -= 1;
|
||||
},
|
||||
3 => {
|
||||
current_value *= current_value;
|
||||
},
|
||||
}
|
||||
|
||||
std.debug.print("{} ", .{current_value});
|
||||
|
|
|
@ -23,7 +23,7 @@ const MyNumberError = error{
|
|||
const std = @import("std");
|
||||
|
||||
pub fn main() void {
|
||||
var nums = [_]u8{2,3,4,5,6};
|
||||
var nums = [_]u8{ 2, 3, 4, 5, 6 };
|
||||
|
||||
for (nums) |num| {
|
||||
std.debug.print("{}", .{num});
|
||||
|
@ -32,7 +32,7 @@ pub fn main() void {
|
|||
if (n) |value| {
|
||||
std.debug.print("=4. ", .{});
|
||||
} else |err| switch (err) {
|
||||
MyNumberError.TooBig => std.debug.print(">4. ", .{}),
|
||||
MyNumberError.TooBig => std.debug.print(">4. ", .{}),
|
||||
// Please add a match for TooSmall here and have it print: "<4. "
|
||||
}
|
||||
}
|
||||
|
@ -43,7 +43,7 @@ pub fn main() void {
|
|||
// This time we'll have numberMaybeFail() return an error union rather
|
||||
// than a straight error.
|
||||
fn numberMaybeFail(n: u8) MyNumberError!u8 {
|
||||
if(n > 4) return MyNumberError.TooBig;
|
||||
if(n < 4) return MyNumberError.TooSmall;
|
||||
if (n > 4) return MyNumberError.TooBig;
|
||||
if (n < 4) return MyNumberError.TooSmall;
|
||||
return n;
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
const std = @import("std");
|
||||
|
||||
const NumError = error{ IllegalNumber };
|
||||
const NumError = error{IllegalNumber};
|
||||
|
||||
pub fn main() void {
|
||||
const stdout = std.io.getStdOut().writer();
|
||||
|
@ -19,6 +19,6 @@ pub fn main() void {
|
|||
|
||||
// Just don't modify this function. It's "perfect" the way it is. :-)
|
||||
fn getNumber() NumError!u32 {
|
||||
if( false ) return NumError.IllegalNumber;
|
||||
if (false) return NumError.IllegalNumber;
|
||||
return 42;
|
||||
}
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
// 1. Having to remember op codes by number is no good.
|
||||
// 2. We had to use "unreachable" because Zig had no way of knowing
|
||||
// how many valid op codes there were.
|
||||
//
|
||||
//
|
||||
// An "enum" is a Zig construct that lets you give names to numeric
|
||||
// values and store them in a set. They look a lot like error sets:
|
||||
//
|
||||
|
@ -16,11 +16,11 @@
|
|||
//
|
||||
// Let's use an enum in place of the numbers we were using in the
|
||||
// previous version!
|
||||
//
|
||||
//
|
||||
const std = @import("std");
|
||||
|
||||
// Please complete the enum!
|
||||
const Ops = enum{ ??? };
|
||||
const Ops = enum { ??? };
|
||||
|
||||
pub fn main() void {
|
||||
const operations = [_]Ops{
|
||||
|
@ -29,16 +29,22 @@ pub fn main() void {
|
|||
Ops.inc,
|
||||
Ops.pow,
|
||||
Ops.dec,
|
||||
Ops.dec
|
||||
Ops.dec,
|
||||
};
|
||||
|
||||
var current_value: u32 = 0;
|
||||
|
||||
for (operations) |op| {
|
||||
switch (op) {
|
||||
Ops.inc => { current_value += 1; },
|
||||
Ops.dec => { current_value -= 1; },
|
||||
Ops.pow => { current_value *= current_value; },
|
||||
Ops.inc => {
|
||||
current_value += 1;
|
||||
},
|
||||
Ops.dec => {
|
||||
current_value -= 1;
|
||||
},
|
||||
Ops.pow => {
|
||||
current_value *= current_value;
|
||||
},
|
||||
// No "else" needed! Why is that?
|
||||
}
|
||||
|
||||
|
|
|
@ -16,7 +16,7 @@ const std = @import("std");
|
|||
|
||||
// Zig lets us write integers in hexadecimal format:
|
||||
//
|
||||
// 0xf (is the value 15 in hex)
|
||||
// 0xf (is the value 15 in hex)
|
||||
//
|
||||
// Web browsers let us specify colors using a hexadecimal
|
||||
// number where each byte represents the brightness of the
|
||||
|
@ -26,10 +26,10 @@ const std = @import("std");
|
|||
// #RRGGBB
|
||||
//
|
||||
// Please define and use a pure blue value Color:
|
||||
const Color = enum(u32){
|
||||
red = 0xff0000,
|
||||
const Color = enum(u32) {
|
||||
red = 0xff0000,
|
||||
green = 0x00ff00,
|
||||
blue = ???,
|
||||
blue = ???,
|
||||
};
|
||||
|
||||
pub fn main() void {
|
||||
|
@ -53,9 +53,9 @@ pub fn main() void {
|
|||
\\ <span style="color: #{x:0>6}">Green</span>
|
||||
\\ <span style="color: #{}">Blue</span>
|
||||
\\</p>
|
||||
, .{
|
||||
@enumToInt(Color.red),
|
||||
@enumToInt(Color.green),
|
||||
@enumToInt(???), // Oops! We're missing something!
|
||||
});
|
||||
, .{
|
||||
@enumToInt(Color.red),
|
||||
@enumToInt(Color.green),
|
||||
@enumToInt(???), // Oops! We're missing something!
|
||||
});
|
||||
}
|
||||
|
|
|
@ -23,7 +23,7 @@
|
|||
const std = @import("std");
|
||||
|
||||
// We'll use an enum to specify the character class.
|
||||
const Class = enum{
|
||||
const Class = enum {
|
||||
wizard,
|
||||
thief,
|
||||
bard,
|
||||
|
@ -32,7 +32,7 @@ const Class = enum{
|
|||
|
||||
// Please add a new property to this struct called "health" and make
|
||||
// it a u8 integer type.
|
||||
const Character = struct{
|
||||
const Character = struct {
|
||||
class: Class,
|
||||
gold: u32,
|
||||
experience: u32,
|
||||
|
@ -41,8 +41,8 @@ const Character = struct{
|
|||
pub fn main() void {
|
||||
// Please initialize Glorp with 100 health.
|
||||
var glorp_the_wise = Character{
|
||||
.class = Class.wizard,
|
||||
.gold = 20,
|
||||
.class = Class.wizard,
|
||||
.gold = 20,
|
||||
.experience = 10,
|
||||
};
|
||||
|
||||
|
@ -54,6 +54,6 @@ pub fn main() void {
|
|||
|
||||
std.debug.print("Your wizard has {} health and {} gold.", .{
|
||||
glorp_the_wise.health,
|
||||
glorp_the_wise.gold
|
||||
glorp_the_wise.gold,
|
||||
});
|
||||
}
|
||||
|
|
|
@ -2,20 +2,20 @@
|
|||
// Grouping values in structs is not merely convenient. It also allows
|
||||
// us to treat the values as a single item when storing them, passing
|
||||
// them to functions, etc.
|
||||
//
|
||||
//
|
||||
// This exercise demonstrates how we can store structs in an array and
|
||||
// how doing so lets us print them all (both) using a loop.
|
||||
//
|
||||
const std = @import("std");
|
||||
|
||||
const Class = enum{
|
||||
const Class = enum {
|
||||
wizard,
|
||||
thief,
|
||||
bard,
|
||||
warrior,
|
||||
};
|
||||
|
||||
const Character = struct{
|
||||
const Character = struct {
|
||||
class: Class,
|
||||
gold: u32,
|
||||
health: u8,
|
||||
|
@ -27,9 +27,9 @@ pub fn main() void {
|
|||
|
||||
// Glorp the Wise
|
||||
chars[0] = Character{
|
||||
.class = Class.wizard,
|
||||
.gold = 20,
|
||||
.health = 100,
|
||||
.class = Class.wizard,
|
||||
.gold = 20,
|
||||
.health = 100,
|
||||
.experience = 10,
|
||||
};
|
||||
|
||||
|
@ -45,7 +45,8 @@ pub fn main() void {
|
|||
|
||||
// Printing all RPG characters in a loop:
|
||||
for (chars) |c, num| {
|
||||
std.debug.print("Character {} - G:{} H:{} XP:{}\n",
|
||||
.{num+1, c.gold, c.health, c.experience});
|
||||
std.debug.print("Character {} - G:{} H:{} XP:{}\n", .{
|
||||
num + 1, c.gold, c.health, c.experience,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
//
|
||||
// var foo: u8 = 5; // foo is 5
|
||||
// var bar: *u8 = &foo; // bar is a pointer
|
||||
//
|
||||
//
|
||||
// What is a pointer? It's a reference to a value. In this example
|
||||
// bar is a reference to the memory space that current contains the
|
||||
// value 5.
|
||||
|
@ -16,7 +16,7 @@
|
|||
// &foo a reference to foo
|
||||
// bar a pointer to the value at foo
|
||||
// bar.* the value 5 (the dereferenced value "at" bar)
|
||||
//
|
||||
//
|
||||
// We'll see why pointers are useful in a moment. For now, see if you
|
||||
// can make this example work!
|
||||
//
|
||||
|
@ -32,5 +32,5 @@ pub fn main() void {
|
|||
// (See the "cheatsheet" above for ideas.)
|
||||
num2 = ???;
|
||||
|
||||
std.debug.print("num1: {}, num2: {}\n", .{num1, num2});
|
||||
std.debug.print("num1: {}, num2: {}\n", .{ num1, num2 });
|
||||
}
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
//
|
||||
// var foo: u8 = 5;
|
||||
// const bar: u8 = 5;
|
||||
//
|
||||
//
|
||||
// Then:
|
||||
//
|
||||
// &foo is of type "*u8"
|
||||
|
@ -23,5 +23,5 @@ pub fn main() void {
|
|||
const a: u8 = 12;
|
||||
const b: *u8 = &a; // fix this!
|
||||
|
||||
std.debug.print("a: {}, b: {}\n", .{a, b.*});
|
||||
std.debug.print("a: {}, b: {}\n", .{ a, b.* });
|
||||
}
|
||||
|
|
|
@ -16,7 +16,7 @@
|
|||
// var p4: *u8 = &unlocked;
|
||||
// const p5: *const u8 = &unlocked;
|
||||
// var p6: *const u8 = &unlocked;
|
||||
//
|
||||
//
|
||||
// Here p3 and p4 can both be used to change the value they point to but
|
||||
// p3 cannot point at anything else.
|
||||
// What's interesting is that p5 and p6 act like p1 and p2, but point to
|
||||
|
@ -32,10 +32,10 @@ pub fn main() void {
|
|||
// Please define pointer "p" so that it can point to EITHER foo or
|
||||
// bar AND change the value it points to!
|
||||
??? p: ??? = undefined;
|
||||
|
||||
|
||||
p = &foo;
|
||||
p.* += 1;
|
||||
p = &bar;
|
||||
p.* += 1;
|
||||
std.debug.print("foo={}, bar={}\n", .{foo, bar});
|
||||
std.debug.print("foo={}, bar={}\n", .{ foo, bar });
|
||||
}
|
||||
|
|
|
@ -12,7 +12,6 @@ pub fn main() void {
|
|||
makeFive(&num);
|
||||
std.debug.print("num: {}, ", .{num});
|
||||
|
||||
|
||||
// Now something interesting. Let's pass a reference to a
|
||||
// specific array value:
|
||||
makeFive(&more_nums[2]);
|
||||
|
|
|
@ -34,33 +34,32 @@
|
|||
//
|
||||
const std = @import("std");
|
||||
|
||||
const Class = enum{
|
||||
const Class = enum {
|
||||
wizard,
|
||||
thief,
|
||||
bard,
|
||||
warrior,
|
||||
};
|
||||
|
||||
const Character = struct{
|
||||
const Character = struct {
|
||||
class: Class,
|
||||
gold: u32,
|
||||
health: u8 = 100, // <--- You can also fields a default value!
|
||||
health: u8 = 100, // <--- You can also provide fields a default value!
|
||||
experience: u32,
|
||||
};
|
||||
|
||||
pub fn main() void {
|
||||
var glorp = Character{
|
||||
.class = Class.wizard,
|
||||
.gold = 10,
|
||||
.class = Class.wizard,
|
||||
.gold = 10,
|
||||
.experience = 20,
|
||||
};
|
||||
|
||||
// FIX ME!
|
||||
// Please pass our Character "glorp" to printCharacter():
|
||||
printCharacter( ??? );
|
||||
printCharacter(???);
|
||||
}
|
||||
|
||||
|
||||
// Note how this function's "c" parameter is a pointer to a Character struct.
|
||||
fn printCharacter(c: *Character) void {
|
||||
|
||||
|
@ -68,9 +67,9 @@ fn printCharacter(c: *Character) void {
|
|||
// don't have to write the full enum name. Zig understands that ".wizard"
|
||||
// means "Class.wizard" when we switch on a Class enum value:
|
||||
const class_name = switch (c.class) {
|
||||
.wizard => "Wizard",
|
||||
.thief => "Thief",
|
||||
.bard => "Bard",
|
||||
.wizard => "Wizard",
|
||||
.thief => "Thief",
|
||||
.bard => "Bard",
|
||||
.warrior => "Warrior",
|
||||
};
|
||||
|
||||
|
|
|
@ -4,13 +4,13 @@
|
|||
//
|
||||
// Are holding hands
|
||||
// By holding tails."
|
||||
//
|
||||
//
|
||||
// from Holding Hands
|
||||
// by Lenore M. Link
|
||||
//
|
||||
//
|
||||
const std = @import("std"); // single quotes
|
||||
|
||||
const Elephant = struct{
|
||||
const Elephant = struct {
|
||||
letter: u8,
|
||||
tail: *Elephant = undefined,
|
||||
visited: bool = false,
|
||||
|
|
|
@ -31,7 +31,7 @@ pub fn main() void {
|
|||
// integer value from deepThought() OR the number 42:
|
||||
var answer: u8 = result;
|
||||
|
||||
std.debug.print("The Ultimate Answer: {}.\n",.{answer});
|
||||
std.debug.print("The Ultimate Answer: {}.\n", .{answer});
|
||||
}
|
||||
|
||||
fn deepThought() ?u8 {
|
||||
|
@ -39,7 +39,6 @@ fn deepThought() ?u8 {
|
|||
// But we'll leave this as-is. Sorry Deep Thought.
|
||||
return null;
|
||||
}
|
||||
//
|
||||
// Blast from the past:
|
||||
//
|
||||
// Optionals are a lot like error union types which can either
|
||||
|
|
|
@ -1 +1,12 @@
|
|||
|
||||
37c37
|
||||
< const n: u8 = 50;
|
||||
---
|
||||
> var n: u8 = 50;
|
||||
40c40
|
||||
< const pi: u8 = 314159;
|
||||
---
|
||||
> const pi: u32 = 314159;
|
||||
42c42
|
||||
< const negative_eleven: u8 = -11;
|
||||
---
|
||||
> const negative_eleven: i8 = -11;
|
||||
|
|
|
@ -1 +1,12 @@
|
|||
|
||||
30c30
|
||||
< const some_primes = [_]u8{ 1, 3, 5, 7, 11, 13, 17, 19 };
|
||||
---
|
||||
> var some_primes = [_]u8{ 1, 3, 5, 7, 11, 13, 17, 19 };
|
||||
43c43
|
||||
< const fourth = some_primes[???];
|
||||
---
|
||||
> const fourth = some_primes[3];
|
||||
47c47
|
||||
< const length = some_primes.???;
|
||||
---
|
||||
> const length = some_primes.len;
|
||||
|
|
|
@ -1 +1,8 @@
|
|||
|
||||
23c23
|
||||
< const leet = ???;
|
||||
---
|
||||
> const leet = le ++ et;
|
||||
28c28
|
||||
< const bit_pattern = [_]u8{ ??? } ** 3;
|
||||
---
|
||||
> const bit_pattern = [_]u8{ 1, 0, 0, 1 } ** 3;
|
||||
|
|
|
@ -1 +1,12 @@
|
|||
|
||||
22c22
|
||||
< const d: u8 = ziggy[???];
|
||||
---
|
||||
> const d: u8 = ziggy[4];
|
||||
26c26
|
||||
< const laugh = "ha " ???;
|
||||
---
|
||||
> const laugh = "ha " ** 3;
|
||||
33c33
|
||||
< const major_tom = major ??? tom;
|
||||
---
|
||||
> const major_tom = major ++ " " ++ tom;
|
||||
|
|
|
@ -1 +1,8 @@
|
|||
|
||||
18,20c18,20
|
||||
< Ziggy played guitar
|
||||
< Jamming good with Andrew Kelley
|
||||
< And the Spiders from Mars
|
||||
---
|
||||
> \\Ziggy played guitar
|
||||
> \\Jamming good with Andrew Kelley
|
||||
> \\And the Spiders from Mars
|
||||
|
|
|
@ -1 +1,14 @@
|
|||
|
||||
16c16
|
||||
< const x: u8 = 1;
|
||||
---
|
||||
> var x: u8 = 1;
|
||||
27c27
|
||||
< lang[???] = letters[x];
|
||||
---
|
||||
> lang[1] = letters[x];
|
||||
29,30c29,30
|
||||
< x = ???;
|
||||
< lang[2] = letters[???];
|
||||
---
|
||||
> x = 5;
|
||||
> lang[2] = letters[x];
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
26c26
|
||||
< if (foo) {
|
||||
---
|
||||
> if (foo == 1) {
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
13c13
|
||||
< var price: u8 = if ???;
|
||||
---
|
||||
> var price: u8 = if (discount) 17 else 20;
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
24c24
|
||||
< while (???) {
|
||||
---
|
||||
> while (n < 1024) {
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
28c28
|
||||
< while (n < 1000) : ??? {
|
||||
---
|
||||
> while (n < 1000) : (n *= 2) {
|
||||
|
|
|
@ -1 +1,6 @@
|
|||
|
||||
27,28c27,28
|
||||
< if (n % 3 == 0) ???;
|
||||
< if (n % 5 == 0) ???;
|
||||
---
|
||||
> if (n % 3 == 0) continue;
|
||||
> if (n % 5 == 0) continue;
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
21c21
|
||||
< if (???) ???;
|
||||
---
|
||||
> if (n == 4) break;
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
18c18
|
||||
< for (???) |???| {
|
||||
---
|
||||
> for (story) |scene| {
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
27c27
|
||||
< for (bits) |bit, ???| {
|
||||
---
|
||||
> for (bits) |bit, i| {
|
||||
|
|
|
@ -1 +1,16 @@
|
|||
|
||||
12c12
|
||||
< const std = import standard library;
|
||||
---
|
||||
> const std = @import("std");
|
||||
14c14
|
||||
< function main() void {
|
||||
---
|
||||
> pub fn main() void {
|
||||
19c19
|
||||
< ??? (i <= stop_at) : (i += 1) {
|
||||
---
|
||||
> while (i <= stop_at) : (i += 1) {
|
||||
23c23
|
||||
< std.debug.print("{}", .{???});
|
||||
---
|
||||
> std.debug.print("{}", .{i});
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
31c31
|
||||
< ??? deepThought() ??? {
|
||||
---
|
||||
> fn deepThought() u8 {
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
25c25
|
||||
< fn twoToThe(???) u32 {
|
||||
---
|
||||
> fn twoToThe(my_number: u32) u32 {
|
||||
|
|
|
@ -1 +1,18 @@
|
|||
|
||||
24,25c24,25
|
||||
< fn printPowersOfTwo(numbers: [4]u16) ??? {
|
||||
< loop (numbers) |n| {
|
||||
---
|
||||
> fn printPowersOfTwo(numbers: [4]u16) void {
|
||||
> for (numbers) |n| {
|
||||
34c34
|
||||
< fn twoToThe(number: u16) ??? {
|
||||
---
|
||||
> fn twoToThe(number: u16) u16 {
|
||||
38c38
|
||||
< loop (n < number) : (n += 1) {
|
||||
---
|
||||
> while (n < number) : (n += 1) {
|
||||
42c42
|
||||
< return ???;
|
||||
---
|
||||
> return total;
|
||||
|
|
|
@ -1 +1,8 @@
|
|||
|
||||
12c12
|
||||
< ???,
|
||||
---
|
||||
> TooSmall,
|
||||
29c29
|
||||
< if (???) {
|
||||
---
|
||||
> if (number_error == MyNumberError.TooSmall) {
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
22c22
|
||||
< var my_number: ??? = 5;
|
||||
---
|
||||
> var my_number: MyNumberError!u8 = 5;
|
||||
|
|
|
@ -1 +1,8 @@
|
|||
|
||||
15c15
|
||||
< var b: u32 = addTwenty(4) ??? 22;
|
||||
---
|
||||
> var b: u32 = addTwenty(4) catch 22;
|
||||
22c22
|
||||
< fn addTwenty(n: u32) ??? {
|
||||
---
|
||||
> fn addTwenty(n: u32) MyNumberError!u32 {
|
||||
|
|
|
@ -1 +1,10 @@
|
|||
|
||||
62c62,68
|
||||
< return detectProblems(n) ???
|
||||
---
|
||||
> return detectProblems(n) catch |err| {
|
||||
> if (err == MyNumberError.TooSmall) {
|
||||
> return 10;
|
||||
> }
|
||||
>
|
||||
> return err;
|
||||
> };
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
29c29
|
||||
< var x = detect(n);
|
||||
---
|
||||
> var x = try detect(n);
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
22c22
|
||||
< stdout.print("Hello world!\n", .{});
|
||||
---
|
||||
> try stdout.print("Hello world!\n", .{});
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
23c23
|
||||
< std.debug.print("Two\n", .{});
|
||||
---
|
||||
> defer std.debug.print("Two\n", .{});
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
21c21
|
||||
< std.debug.print(") ", .{}); // <---- how!?
|
||||
---
|
||||
> defer std.debug.print(") ", .{}); // <---- how!?
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
35c34
|
||||
< std.debug.print("failed!\n", .{});
|
||||
---
|
||||
> errdefer std.debug.print("failed!\n", .{});
|
||||
|
|
|
@ -1 +1,2 @@
|
|||
|
||||
48a49
|
||||
> else => std.debug.print("?", .{}),
|
||||
|
|
|
@ -1 +1,2 @@
|
|||
|
||||
33a34
|
||||
> else => '!',
|
||||
|
|
|
@ -1 +1,2 @@
|
|||
|
||||
37a38
|
||||
> else => unreachable,
|
||||
|
|
|
@ -1 +1,2 @@
|
|||
|
||||
36a37
|
||||
> MyNumberError.TooSmall => std.debug.print("<4. ", .{}),
|
||||
|
|
|
@ -1 +1,8 @@
|
|||
|
||||
12c12
|
||||
< pub fn main() void {
|
||||
---
|
||||
> pub fn main() !void {
|
||||
15c15
|
||||
< const my_num: u32 = getNumber();
|
||||
---
|
||||
> const my_num: u32 = try getNumber();
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
23c23
|
||||
< const Ops = enum { ??? };
|
||||
---
|
||||
> const Ops = enum { dec, inc, pow };
|
||||
|
|
|
@ -1 +1,12 @@
|
|||
|
||||
32c32
|
||||
< blue = ???,
|
||||
---
|
||||
> blue = 0x0000ff,
|
||||
54c54
|
||||
< \\ <span style="color: #{}">Blue</span>
|
||||
---
|
||||
> \\ <span style="color: #{x:0>6}">Blue</span>
|
||||
59c59
|
||||
< @enumToInt(???), // Oops! We're missing something!
|
||||
---
|
||||
> @enumToInt(Color.blue), // Oops! We're missing something!
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
38a39
|
||||
> health: u8,
|
||||
46a48
|
||||
> .health = 100,
|
||||
|
|
|
@ -1 +1,7 @@
|
|||
|
||||
44a45,50
|
||||
> chars[1] = Character{
|
||||
> .class = Class.bard,
|
||||
> .gold = 10,
|
||||
> .health = 100,
|
||||
> .experience = 20,
|
||||
> };
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
33c33
|
||||
< num2 = ???;
|
||||
---
|
||||
> num2 = num1_pointer.*;
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
24c24
|
||||
< const b: *u8 = &a; // fix this!
|
||||
---
|
||||
> const b: *const u8 = &a; // fix this!
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
34c34
|
||||
< ??? p: ??? = undefined;
|
||||
---
|
||||
> var p: *u8 = undefined;
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
31c31
|
||||
< ??? = 5; // fix me!
|
||||
---
|
||||
> x.* = 5; // fix me!
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
60c60
|
||||
< printCharacter(???);
|
||||
---
|
||||
> printCharacter(&glorp);
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
21a22
|
||||
> var elephantB = Elephant{ .letter = 'B' };
|
||||
27a29
|
||||
> elephantB.tail = &elephantC;
|
||||
|
|
|
@ -1 +1,4 @@
|
|||
|
||||
32c32
|
||||
< var answer: u8 = result;
|
||||
---
|
||||
> var answer: u8 = result orelse 42;
|
||||
|
|
Loading…
Reference in a new issue