Merge pull request #21 from cristiantroy/main

Fix typos

book/src/constants.md

@@ -34,5 +34,5 @@ pub fn add_constant(&mut self, value: Field, span: Span) -> CellVar {
 
 Note that the `Value` keep track of the constant as well.
 
-Warning: gadgets must all handle constants gracefuly.
+Warning: gadgets must all handle constants gracefully.
 That is, they must constrain constants themselves (by calling `CircuitWriter::add_constant`).

book/src/literals.md

@@ -32,7 +32,7 @@ Approach 1. is not elegant, because it means that it is not clear from the signa
 The user of the function will only get warned when trying to compile the program.
 
 Approach 2. is interesting, because we already have such a type internally to track literals: a `BigInt`.
-The name is a bit misleading in the case of array accesses, because we additionaly enforce that it is NOT a big integer, but rather a 32-bit integer (`u32` in Rust).
+The name is a bit misleading in the case of array accesses, because we additionally enforce that it is NOT a big integer, but rather a 32-bit integer (`u32` in Rust).
 
 ## Implementing a literal type
 

book/src/public-outputs.md

@@ -2,7 +2,7 @@
 
 Public outputs are usually part of the public inputs in Plonk.
 
-In noname, public ouputs are treated differently than the public inputs for one reason: unlike (real) public inputs they cannot be computed directly during witness generation (proving).
+In noname, public outputs are treated differently than the public inputs for one reason: unlike (real) public inputs they cannot be computed directly during witness generation (proving).
 
 This is because public inputs are listed first in the circuit. During witness generation, we go through each rows and evaluate the values of the cells to construct the execution trace. 
 When we reach the public output part of the public input, we do not yet have enough information to construct the values.

book/src/spans.md

@@ -9,7 +9,7 @@ pub struct Span(pub usize, pub usize);
 which represents a location in the original source code:
 
 * the first number is the offset in the source code file
-* the second numebr if the length of the span (e.g. 1 character)
+* the second number if the length of the span (e.g. 1 character)
 
 We start tracking spans in the lexer, and then pass them around to the parser, and then to the compiler. Even gates and wirings have spans associated with them so that we can easily debug those.
 

src/cli/cmd_build_and_check.rs

@@ -86,7 +86,7 @@ pub fn cmd_build(args: CmdBuild) -> miette::Result<()> {
         "could not write prover params to `{prover_params}`"
     ))?;
 
-    println!("successfuly built");
+    println!("successfully built");
 
     //
     Ok(())
@@ -268,7 +268,7 @@ pub fn cmd_test(args: CmdTest) -> miette::Result<()> {
     let compiled_circuit = compile(&sources, tast, !args.no_double)?;
 
     let (prover_index, verifier_index) = compile_to_indexes(compiled_circuit)?;
-    println!("successfuly compiled");
+    println!("successfully compiled");
 
     // print ASM
     let asm = prover_index.asm(&sources, args.debug);

src/parser/types.rs

@@ -1056,7 +1056,7 @@ impl Stmt {
                 kind: TokenKind::Keyword(Keyword::If),
                 span: _,
             }) => {
-                // TODO: wait, this should be implemented as an expresssion! not a statement
+                // TODO: wait, this should be implemented as an expression! not a statement
                 panic!("if statements are not implemented yet. Use if expressions instead (e.g. `x = if cond {{ 1 }} else {{ 2 }};`)");
             }