ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-06 15:48:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

add backticks on variables, code review comments

Browse Source
This commit is contained in:
Jon Lipstate
2023-03-28 11:07:33 -07:00
parent 203ae32b79
commit 6dce07790a
4 changed files with 127 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/strings/conversion.odin
+7 -9
View File
@@ -136,15 +136,15 @@ to_upper :: proc(s: string, allocator := context.allocator) -> string {
return to_string(b) return to_string(b)
} }
/* /*
Checks if the rune `c` is a delimiter (' ', '-', or '_'). Checks if the rune `r` is a delimiter (' ', '-', or '_').
**Inputs** **Inputs**
- c: Rune to check for delimiter status. - r: Rune to check for delimiter status.
**Returns** True if `c` is a delimiter, false otherwise. **Returns** True if `r` is a delimiter, false otherwise.
*/ */
is_delimiter :: proc(c: rune) -> bool { is_delimiter :: proc(r: rune) -> bool {
return c == '-' || c == '_' || is_space(c) return r == '-' || r == '_' || is_space(r)
} }
/* /*
Checks if the rune `r` is a non-alphanumeric or space character. Checks if the rune `r` is a non-alphanumeric or space character.
@@ -195,7 +195,7 @@ Example:
my_callback :: proc(w: io.Writer, prev, curr, next: rune) { my_callback :: proc(w: io.Writer, prev, curr, next: rune) {
fmt.println("my_callback", curr) // <-- Custom logic here fmt.println("my_callback", curr) // <-- Custom logic here
} }
s := "hello world" s := "hello"
b: strings.Builder b: strings.Builder
strings.builder_init_len(&b, len(s)) strings.builder_init_len(&b, len(s))
w := strings.to_writer(&b) w := strings.to_writer(&b)
@@ -521,9 +521,7 @@ to_ada_case :: proc(s: string, allocator := context.allocator) -> string {
string_case_iterator(w, s, proc(w: io.Writer, prev, curr, next: rune) { string_case_iterator(w, s, proc(w: io.Writer, prev, curr, next: rune) {
if !is_delimiter(curr) { if !is_delimiter(curr) {
if is_delimiter(prev) || if is_delimiter(prev) || prev == 0 || (unicode.is_lower(prev) && unicode.is_upper(curr)) {
prev == 0 ||
(unicode.is_lower(prev) && unicode.is_upper(curr)) {
if prev != 0 { if prev != 0 {
io.write_rune(w, '_') io.write_rune(w, '_')
} }
core/strings/intern.odin
+7 -7
View File
@@ -47,9 +47,9 @@ intern_destroy :: proc(m: ^Intern) {
delete(m.entries) delete(m.entries)
} }
/* /*
Returns the interned string for the given text, is set in the map if it didnt exist yet. Returns an interned copy of the given text, adding it to the map if not already present.
*MAY Allocate using the Intern's Allocator* *Allocate using the Intern's Allocator (First time string is seen only)*
**Inputs** **Inputs**
- m: A pointer to the Intern struct - m: A pointer to the Intern struct
@@ -64,17 +64,17 @@ intern_get :: proc(m: ^Intern, text: string) -> (str: string, err: runtime.Alloc
#no_bounds_check return string(entry.str[:entry.len]), nil #no_bounds_check return string(entry.str[:entry.len]), nil
} }
/* /*
Returns the interned C-String for the given text, is set in the map if it didnt exist yet. Returns an interned copy of the given text as a cstring, adding it to the map if not already present.
*MAY Allocate using the Intern's Allocator* *Allocate using the Intern's Allocator (First time string is seen only)*
**Inputs** **Inputs**
- m: A pointer to the Intern struct - m: A pointer to the Intern struct
- text: The string to be interned - text: The string to be interned
NOTE: The returned C-String lives as long as the map entry lives NOTE: The returned cstring lives as long as the map entry lives
**Returns** The interned C-String and an allocator error if any **Returns** The interned cstring and an allocator error if any
*/ */
intern_get_cstring :: proc(m: ^Intern, text: string) -> (str: cstring, err: runtime.Allocator_Error) { intern_get_cstring :: proc(m: ^Intern, text: string) -> (str: cstring, err: runtime.Allocator_Error) {
entry := _intern_get_entry(m, text) or_return entry := _intern_get_entry(m, text) or_return
@@ -84,7 +84,7 @@ intern_get_cstring :: proc(m: ^Intern, text: string) -> (str: cstring, err: runt
Internal function to lookup whether the text string exists in the map, returns the entry Internal function to lookup whether the text string exists in the map, returns the entry
Sets and allocates the entry if it wasn't set yet Sets and allocates the entry if it wasn't set yet
*MAY Allocate using the Intern's Allocator* *Allocate using the Intern's Allocator (First time string is seen only)*
**Inputs** **Inputs**
- m: A pointer to the Intern struct - m: A pointer to the Intern struct
core/strings/reader.odin
+21 -21
View File
@@ -5,7 +5,7 @@ import "core:unicode/utf8"
/* /*
io stream data for a string reader that can read based on bytes or runes io stream data for a string reader that can read based on bytes or runes
implements the vtable when using the io.Reader variants implements the vtable when using the `io.Reader` variants
"read" calls advance the current reading offset `i` "read" calls advance the current reading offset `i`
*/ */
Reader :: struct { Reader :: struct {
@@ -26,7 +26,7 @@ reader_init :: proc(r: ^Reader, s: string) {
r.prev_rune = -1 r.prev_rune = -1
} }
/* /*
Converts a Reader into an io.Stream Converts a Reader into an `io.Stream`
**Inputs** **Inputs**
- r: A pointer to a Reader struct - r: A pointer to a Reader struct
@@ -39,7 +39,7 @@ reader_to_stream :: proc(r: ^Reader) -> (s: io.Stream) {
return return
} }
/* /*
Initializes a string Reader and returns an io.Reader for the given string Initializes a string Reader and returns an `io.Reader` for the given string
**Inputs** **Inputs**
- r: A pointer to a Reader struct - r: A pointer to a Reader struct
@@ -53,13 +53,13 @@ to_reader :: proc(r: ^Reader, s: string) -> io.Reader {
return rr return rr
} }
/* /*
Initializes a string Reader and returns an io.Reader_At for the given string Initializes a string Reader and returns an `io.Reader_At` for the given string
**Inputs** **Inputs**
- r: A pointer to a Reader struct - r: A pointer to a Reader struct
- s: The input string to be read - s: The input string to be read
**Returns** An io.Reader_At for the given string **Returns** An `io.Reader_At` for the given string
*/ */
to_reader_at :: proc(r: ^Reader, s: string) -> io.Reader_At { to_reader_at :: proc(r: ^Reader, s: string) -> io.Reader_At {
reader_init(r, s) reader_init(r, s)
@@ -100,7 +100,7 @@ Reads len(p) bytes from the Reader's string and copies into the provided slice.
**Returns** **Returns**
- n: The number of bytes read - n: The number of bytes read
- err: An io.Error if an error occurs while reading, including .EOF, otherwise nil denotes success. - err: An `io.Error` if an error occurs while reading, including `.EOF`, otherwise `nil` denotes success.
*/ */
reader_read :: proc(r: ^Reader, p: []byte) -> (n: int, err: io.Error) { reader_read :: proc(r: ^Reader, p: []byte) -> (n: int, err: io.Error) {
if r.i >= i64(len(r.s)) { if r.i >= i64(len(r.s)) {
@@ -121,7 +121,7 @@ Reads len(p) bytes from the Reader's string and copies into the provided slice,
**Returns** **Returns**
- n: The number of bytes read - n: The number of bytes read
- err: An io.Error if an error occurs while reading, including .EOF, otherwise nil denotes success. - err: An `io.Error` if an error occurs while reading, including `.EOF`, otherwise `nil` denotes success.
*/ */
reader_read_at :: proc(r: ^Reader, p: []byte, off: i64) -> (n: int, err: io.Error) { reader_read_at :: proc(r: ^Reader, p: []byte, off: i64) -> (n: int, err: io.Error) {
if off < 0 { if off < 0 {
@@ -144,7 +144,7 @@ Reads and returns a single byte from the Reader's string
**Returns** **Returns**
- The byte read from the Reader - The byte read from the Reader
- err: An io.Error if an error occurs while reading, including .EOF, otherwise nil denotes success. - err: An `io.Error` if an error occurs while reading, including `.EOF`, otherwise `nil` denotes success.
*/ */
reader_read_byte :: proc(r: ^Reader) -> (byte, io.Error) { reader_read_byte :: proc(r: ^Reader) -> (byte, io.Error) {
r.prev_rune = -1 r.prev_rune = -1
@@ -161,7 +161,7 @@ Decrements the Reader's index (i) by 1
**Inputs** **Inputs**
- r: A pointer to a Reader struct - r: A pointer to a Reader struct
**Returns** An io.Error if `r.i <= 0` (.Invalid_Unread), otherwise nil denotes success. **Returns** An `io.Error` if `r.i <= 0` (`.Invalid_Unread`), otherwise `nil` denotes success.
*/ */
reader_unread_byte :: proc(r: ^Reader) -> io.Error { reader_unread_byte :: proc(r: ^Reader) -> io.Error {
if r.i <= 0 { if r.i <= 0 {
@@ -172,17 +172,17 @@ reader_unread_byte :: proc(r: ^Reader) -> io.Error {
return nil return nil
} }
/* /*
Reads and returns a single rune and its size from the Reader's string Reads and returns a single rune and its `size` from the Reader's string
**Inputs** **Inputs**
- r: A pointer to a Reader struct - r: A pointer to a Reader struct
**Returns** **Returns**
- ch: The rune read from the Reader - r: The rune read from the Reader
- size: The size of the rune in bytes - size: The size of the rune in bytes
- err: An io.Error if an error occurs while reading - err: An `io.Error` if an error occurs while reading
*/ */
reader_read_rune :: proc(r: ^Reader) -> (ch: rune, size: int, err: io.Error) { reader_read_rune :: proc(r: ^Reader) -> (rn: rune, size: int, err: io.Error) {
if r.i >= i64(len(r.s)) { if r.i >= i64(len(r.s)) {
r.prev_rune = -1 r.prev_rune = -1
return 0, 0, .EOF return 0, 0, .EOF
@@ -192,7 +192,7 @@ reader_read_rune :: proc(r: ^Reader) -> (ch: rune, size: int, err: io.Error) {
r.i += 1 r.i += 1
return rune(c), 1, nil return rune(c), 1, nil
} }
ch, size = utf8.decode_rune_in_string(r.s[r.i:]) rn, size = utf8.decode_rune_in_string(r.s[r.i:])
r.i += i64(size) r.i += i64(size)
return return
} }
@@ -204,7 +204,7 @@ Decrements the Reader's index (i) by the size of the last read rune
WARNING: May only be used once and after a valid `read_rune` call WARNING: May only be used once and after a valid `read_rune` call
**Returns** An io.Error if an error occurs while unreading (.Invalid_Unread), else nil denotes success. **Returns** An `io.Error` if an error occurs while unreading (`.Invalid_Unread`), else `nil` denotes success.
*/ */
reader_unread_rune :: proc(r: ^Reader) -> io.Error { reader_unread_rune :: proc(r: ^Reader) -> io.Error {
if r.i <= 0 { if r.i <= 0 {
@@ -223,11 +223,11 @@ Seeks the Reader's index to a new position
**Inputs** **Inputs**
- r: A pointer to a Reader struct - r: A pointer to a Reader struct
- offset: The new offset position - offset: The new offset position
- whence: The reference point for the new position (.Start, .Current, or .End) - whence: The reference point for the new position (`.Start`, `.Current`, or `.End`)
**Returns** **Returns**
- The absolute offset after seeking - The absolute offset after seeking
- err: An io.Error if an error occurs while seeking (.Invalid_Whence, .Invalid_Offset) - err: An `io.Error` if an error occurs while seeking (`.Invalid_Whence`, `.Invalid_Offset`)
*/ */
reader_seek :: proc(r: ^Reader, offset: i64, whence: io.Seek_From) -> (i64, io.Error) { reader_seek :: proc(r: ^Reader, offset: i64, whence: io.Seek_From) -> (i64, io.Error) {
r.prev_rune = -1 r.prev_rune = -1
@@ -250,7 +250,7 @@ reader_seek :: proc(r: ^Reader, offset: i64, whence: io.Seek_From) -> (i64, io.E
return abs, nil return abs, nil
} }
/* /*
Writes the remaining content of the Reader's string into the provided io.Writer Writes the remaining content of the Reader's string into the provided `io.Writer`
**Inputs** **Inputs**
- r: A pointer to a Reader struct - r: A pointer to a Reader struct
@@ -260,7 +260,7 @@ WARNING: Panics if writer writes more bytes than remainig length of string.
**Returns** **Returns**
- n: The number of bytes written - n: The number of bytes written
- err: An io.Error if an error occurs while writing (.Short_Write) - err: An io.Error if an error occurs while writing (`.Short_Write`)
*/ */
reader_write_to :: proc(r: ^Reader, w: io.Writer) -> (n: i64, err: io.Error) { reader_write_to :: proc(r: ^Reader, w: io.Writer) -> (n: i64, err: io.Error) {
r.prev_rune = -1 r.prev_rune = -1
@@ -281,10 +281,10 @@ reader_write_to :: proc(r: ^Reader, w: io.Writer) -> (n: i64, err: io.Error) {
return return
} }
/* /*
VTable containing implementations for various io.Stream methods VTable containing implementations for various `io.Stream` methods
This VTable is used by the Reader struct to provide its functionality This VTable is used by the Reader struct to provide its functionality
as an io.Stream. as an `io.Stream`.
*/ */
@(private) @(private)
_reader_vtable := io.Stream_VTable{ _reader_vtable := io.Stream_VTable{
core/strings/strings.odin
+92 -92
View File
@@ -43,7 +43,7 @@ clone_safe :: proc(s: string, allocator := context.allocator, loc := #caller_loc
return string(c[:len(s)]), nil return string(c[:len(s)]), nil
} }
/* /*
Clones a string and appends a nul byte to make it a cstring Clones a string and appends a `nul` byte to make it a cstring
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -52,7 +52,7 @@ Clones a string and appends a nul byte to make it a cstring
- allocator: (default: context.allocator) - allocator: (default: context.allocator)
- loc: The caller location for debugging purposes (default: #caller_location) - loc: The caller location for debugging purposes (default: #caller_location)
**Returns** A cloned cstring with an appended nul byte **Returns** A cloned cstring with an appended `nul` byte
*/ */
clone_to_cstring :: proc(s: string, allocator := context.allocator, loc := #caller_location) -> cstring { clone_to_cstring :: proc(s: string, allocator := context.allocator, loc := #caller_location) -> cstring {
c := make([]byte, len(s)+1, allocator, loc) c := make([]byte, len(s)+1, allocator, loc)
@@ -75,7 +75,7 @@ string_from_ptr :: proc(ptr: ^byte, len: int) -> string {
return transmute(string)mem.Raw_String{ptr, len} return transmute(string)mem.Raw_String{ptr, len}
} }
/* /*
Transmutes a raw pointer (nul-terminated) into a string. Non-allocating. Searches for a nul byte from 0..<len, otherwhise `len` will be the end size Transmutes a raw pointer (nul-terminated) into a string. Non-allocating. Searches for a nul byte from `0..<len`, otherwhise `len` will be the end size
NOTE: The created string is only valid as long as the pointer and length are valid. NOTE: The created string is only valid as long as the pointer and length are valid.
The string is truncated at the first nul byte encountered. The string is truncated at the first nul byte encountered.
@@ -109,7 +109,7 @@ Converts a string `str` to a cstring
**Inputs** **Inputs**
- str: The input string - str: The input string
WARNING: This is unsafe because the original string may not contain a nul byte. WARNING: This is unsafe because the original string may not contain a `nul` byte.
**Returns** The converted cstring **Returns** The converted cstring
*/ */
@@ -136,7 +136,7 @@ truncate_to_byte :: proc(str: string, b: byte) -> string {
return str[:n] return str[:n]
} }
/* /*
Truncates a string str at the first occurrence of rune r as a slice of the original, entire string if not found Truncates a string `str` at the first occurrence of rune `r` as a slice of the original, entire string if not found
**Inputs** **Inputs**
- str: The input string - str: The input string
@@ -152,16 +152,16 @@ truncate_to_rune :: proc(str: string, r: rune) -> string {
return str[:n] return str[:n]
} }
/* /*
Clones a byte array s and appends a nul byte Clones a byte array `s` and appends a `nul` byte
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
**Inputs** **Inputs**
- s: The byte array to be cloned - s: The byte array to be cloned
- allocator: (default: context.allocator) - allocator: (default: context.allocator)
- loc: The caller location for debugging purposes (default: #caller_location) - loc: The caller location for debugging purposes (default: `#caller_location`)
**Returns** A cloned string from the byte array with a nul byte **Returns** A cloned string from the byte array with a `nul` byte
*/ */
clone_from_bytes :: proc(s: []byte, allocator := context.allocator, loc := #caller_location) -> string { clone_from_bytes :: proc(s: []byte, allocator := context.allocator, loc := #caller_location) -> string {
c := make([]byte, len(s)+1, allocator, loc) c := make([]byte, len(s)+1, allocator, loc)
@@ -170,14 +170,14 @@ clone_from_bytes :: proc(s: []byte, allocator := context.allocator, loc := #call
return string(c[:len(s)]) return string(c[:len(s)])
} }
/* /*
Clones a cstring s as a string Clones a cstring `s` as a string
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
**Inputs** **Inputs**
- s: The cstring to be cloned - s: The cstring to be cloned
- allocator: (default: context.allocator) - allocator: (default: context.allocator)
- loc: The caller location for debugging purposes (default: #caller_location) - loc: The caller location for debugging purposes (default: `#caller_location`)
**Returns** A cloned string from the cstring **Returns** A cloned string from the cstring
*/ */
@@ -185,7 +185,7 @@ clone_from_cstring :: proc(s: cstring, allocator := context.allocator, loc := #c
return clone(string(s), allocator, loc) return clone(string(s), allocator, loc)
} }
/* /*
Clones a string from a byte pointer ptr and a byte length len Clones a string from a byte pointer `ptr` and a byte length `len`
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -193,7 +193,7 @@ Clones a string from a byte pointer ptr and a byte length len
- ptr: A pointer to the start of the byte sequence - ptr: A pointer to the start of the byte sequence
- len: The length of the byte sequence - len: The length of the byte sequence
- allocator: (default: context.allocator) - allocator: (default: context.allocator)
- loc: The caller location for debugging purposes (default: #caller_location) - loc: The caller location for debugging purposes (default: `#caller_location`)
NOTE: Same as `string_from_ptr`, but perform an additional `clone` operation NOTE: Same as `string_from_ptr`, but perform an additional `clone` operation
@@ -203,7 +203,7 @@ clone_from_ptr :: proc(ptr: ^byte, len: int, allocator := context.allocator, loc
s := string_from_ptr(ptr, len) s := string_from_ptr(ptr, len)
return clone(s, allocator, loc) return clone(s, allocator, loc)
} }
// Overloaded procedure to clone from a string, []byte, cstring or a ^byte + length // Overloaded procedure to clone from a string, `[]byte`, `cstring` or a `^byte` + length
clone_from :: proc{ clone_from :: proc{
clone, clone,
clone_from_bytes, clone_from_bytes,
@@ -211,7 +211,7 @@ clone_from :: proc{
clone_from_ptr, clone_from_ptr,
} }
/* /*
Clones a string from a nul-terminated cstring ptr and a byte length len Clones a string from a nul-terminated cstring `ptr` and a byte length `len`
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -219,7 +219,7 @@ Clones a string from a nul-terminated cstring ptr and a byte length len
- ptr: A pointer to the start of the nul-terminated cstring - ptr: A pointer to the start of the nul-terminated cstring
- len: The byte length of the cstring - len: The byte length of the cstring
- allocator: (default: context.allocator) - allocator: (default: context.allocator)
- loc: The caller location for debugging purposes (default: #caller_location) - loc: The caller location for debugging purposes (default: `#caller_location`)
NOTE: Truncates at the first nul byte encountered or the byte length. NOTE: Truncates at the first nul byte encountered or the byte length.
@@ -232,25 +232,25 @@ clone_from_cstring_bounded :: proc(ptr: cstring, len: int, allocator := context.
} }
/* /*
Compares two strings, returning a value representing which one comes first lexicographically. Compares two strings, returning a value representing which one comes first lexicographically.
-1 for lhs; 1 for rhs, or 0 if they are equal. -1 for `lhs`; 1 for `rhs`, or 0 if they are equal.
**Inputs** **Inputs**
- lhs: First string for comparison - lhs: First string for comparison
- rhs: Second string for comparison - rhs: Second string for comparison
**Returns** -1 if lhs comes first, 1 if rhs comes first, or 0 if they are equal **Returns** -1 if `lhs` comes first, 1 if `rhs` comes first, or 0 if they are equal
*/ */
compare :: proc(lhs, rhs: string) -> int { compare :: proc(lhs, rhs: string) -> int {
return mem.compare(transmute([]byte)lhs, transmute([]byte)rhs) return mem.compare(transmute([]byte)lhs, transmute([]byte)rhs)
} }
/* /*
Returns the byte offset of the rune r in the string s, -1 when not found Returns the byte offset of the rune `r` in the string `s`, -1 when not found
**Inputs** **Inputs**
- s: The input string - s: The input string
- r: The rune to search for - r: The rune to search for
**Returns** The byte offset of the rune r in the string s, or -1 if not found **Returns** The byte offset of the rune `r` in the string `s`, or -1 if not found
*/ */
contains_rune :: proc(s: string, r: rune) -> int { contains_rune :: proc(s: string, r: rune) -> int {
for c, offset in s { for c, offset in s {
@@ -261,7 +261,7 @@ contains_rune :: proc(s: string, r: rune) -> int {
return -1 return -1
} }
/* /*
Returns true when the string substr is contained inside the string s Returns true when the string `substr` is contained inside the string `s`
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -296,13 +296,13 @@ Output:
true true
false false
**Returns** true if substr is contained inside the string s, false otherwise **Returns** `true` if `substr` is contained inside the string `s`, `false` otherwise
*/ */
contains :: proc(s, substr: string) -> bool { contains :: proc(s, substr: string) -> bool {
return index(s, substr) >= 0 return index(s, substr) >= 0
} }
/* /*
Returns true when the string s contains any of the characters inside the string chars Returns `true` when the string `s` contains any of the characters inside the string `chars`
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -327,13 +327,13 @@ Output:
true true
false false
**Returns** true if the string s contains any of the characters in chars, false otherwise **Returns** `true` if the string `s` contains any of the characters in `chars`, `false` otherwise
*/ */
contains_any :: proc(s, chars: string) -> bool { contains_any :: proc(s, chars: string) -> bool {
return index_any(s, chars) >= 0 return index_any(s, chars) >= 0
} }
/* /*
Returns the UTF-8 rune count of the string s Returns the UTF-8 rune count of the string `s`
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -353,13 +353,13 @@ Output:
4 4
5 5
**Returns** The UTF-8 rune count of the string s **Returns** The UTF-8 rune count of the string `s`
*/ */
rune_count :: proc(s: string) -> int { rune_count :: proc(s: string) -> int {
return utf8.rune_count_in_string(s) return utf8.rune_count_in_string(s)
} }
/* /*
Returns whether the strings u and v are the same alpha characters, ignoring different casings Returns whether the strings `u` and `v` are the same alpha characters, ignoring different casings
Works with UTF-8 string content Works with UTF-8 string content
**Inputs** **Inputs**
@@ -385,7 +385,7 @@ Output:
true true
false false
**Returns** True if the strings u and v are the same alpha characters (ignoring case), false **Returns** `true` if the strings `u` and `v` are the same alpha characters (ignoring case)
*/ */
equal_fold :: proc(u, v: string) -> bool { equal_fold :: proc(u, v: string) -> bool {
s, t := u, v s, t := u, v
@@ -430,7 +430,7 @@ equal_fold :: proc(u, v: string) -> bool {
return s == t return s == t
} }
/* /*
Returns the prefix length common between strings a and b Returns the prefix length common between strings `a` and `b`
**Inputs** **Inputs**
- a: The first input string - a: The first input string
@@ -455,7 +455,7 @@ Output:
2 2
0 0
**Returns** The prefix length common between strings a and b **Returns** The prefix length common between strings `a` and `b`
*/ */
prefix_length :: proc(a, b: string) -> (n: int) { prefix_length :: proc(a, b: string) -> (n: int) {
_len := min(len(a), len(b)) _len := min(len(a), len(b))
@@ -481,10 +481,10 @@ prefix_length :: proc(a, b: string) -> (n: int) {
return return
} }
/* /*
Determines if a string s starts with a given prefix Determines if a string `s` starts with a given `prefix`
**Inputs** **Inputs**
- s: The string to check for the prefix - s: The string to check for the `prefix`
- prefix: The prefix to look for - prefix: The prefix to look for
Example: Example:
@@ -506,13 +506,13 @@ Output:
true true
false false
**Returns** true if the string s starts with the prefix, otherwise false **Returns** `true` if the string `s` starts with the `prefix`, otherwise `false`
*/ */
has_prefix :: proc(s, prefix: string) -> bool { has_prefix :: proc(s, prefix: string) -> bool {
return len(s) >= len(prefix) && s[0:len(prefix)] == prefix return len(s) >= len(prefix) && s[0:len(prefix)] == prefix
} }
/* /*
Determines if a string s ends with a given suffix Determines if a string `s` ends with a given `suffix`
Example: Example:
@@ -532,16 +532,16 @@ Output:
true true
**Inputs** **Inputs**
- s: The string to check for the suffix - s: The string to check for the `suffix`
- suffix: The suffix to look for - suffix: The suffix to look for
**Returns** true if the string s ends with the suffix, otherwise false **Returns** `true` if the string `s` ends with the `suffix`, otherwise `false`
*/ */
has_suffix :: proc(s, suffix: string) -> bool { has_suffix :: proc(s, suffix: string) -> bool {
return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
} }
/* /*
Joins a slice of strings a with a sep string Joins a slice of strings `a` with a `sep` string
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -568,7 +568,7 @@ Output:
- sep: The separator string - sep: The separator string
- allocator: (default is context.allocator) - allocator: (default is context.allocator)
**Returns** A combined string from the slice of strings a separated with the sep string **Returns** A combined string from the slice of strings `a` separated with the `sep` string
*/ */
join :: proc(a: []string, sep: string, allocator := context.allocator) -> string { join :: proc(a: []string, sep: string, allocator := context.allocator) -> string {
if len(a) == 0 { if len(a) == 0 {
@@ -589,7 +589,7 @@ join :: proc(a: []string, sep: string, allocator := context.allocator) -> string
return string(b) return string(b)
} }
/* /*
Joins a slice of strings a with a sep string, returns an error on allocation failure Joins a slice of strings `a` with a `sep` string, returns an error on allocation failure
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -599,8 +599,8 @@ Joins a slice of strings a with a sep string, returns an error on allocation fai
- allocator: (default is context.allocator) - allocator: (default is context.allocator)
**Returns** **Returns**
- str: A combined string from the slice of strings a separated with the sep string - str: A combined string from the slice of strings `a` separated with the `sep` string
- err: An error if allocation failed, otherwise nil - err: An error if allocation failed, otherwise `nil`
*/ */
join_safe :: proc(a: []string, sep: string, allocator := context.allocator) -> (str: string, err: mem.Allocator_Error) { join_safe :: proc(a: []string, sep: string, allocator := context.allocator) -> (str: string, err: mem.Allocator_Error) {
if len(a) == 0 { if len(a) == 0 {
@@ -778,7 +778,7 @@ Splits the input string `s` into a slice of substrings separated by the specifie
- s: The input string to split - s: The input string to split
- sep: The separator string - sep: The separator string
- sep_save: A flag determining if the separator should be saved in the resulting substrings - sep_save: A flag determining if the separator should be saved in the resulting substrings
- n: The maximum number of substrings to return, returns nil without alloc when n=0 - n: The maximum number of substrings to return, returns `nil` without alloc when `n=0`
- allocator: An optional custom allocator (default is context.allocator) - allocator: An optional custom allocator (default is context.allocator)
**Returns** A slice of substrings **Returns** A slice of substrings
@@ -861,7 +861,7 @@ split :: proc(s, sep: string, allocator := context.allocator) -> []string {
return _split(s, sep, 0, -1, allocator) return _split(s, sep, 0, -1, allocator)
} }
/* /*
Splits a string into parts based on a separator. if n < count of seperators, the remainder of the string is returned in the last entry. Splits a string into parts based on a separator. If n < count of seperators, the remainder of the string is returned in the last entry.
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -921,7 +921,7 @@ split_after :: proc(s, sep: string, allocator := context.allocator) -> []string
return _split(s, sep, len(sep), -1, allocator) return _split(s, sep, len(sep), -1, allocator)
} }
/* /*
Splits a string into a total of 'n' parts after the separator. Splits a string into a total of `n` parts after the separator.
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -946,13 +946,13 @@ Output:
["aaa.", "bbb.", "ccc.ddd.eee"] ["aaa.", "bbb.", "ccc.ddd.eee"]
**Returns** A slice of strings with 'n' parts or fewer if there weren't **Returns** A slice of strings with `n` parts or fewer if there weren't
*/ */
split_after_n :: proc(s, sep: string, n: int, allocator := context.allocator) -> []string { split_after_n :: proc(s, sep: string, n: int, allocator := context.allocator) -> []string {
return _split(s, sep, len(sep), n, allocator) return _split(s, sep, len(sep), n, allocator)
} }
/* /*
Searches for the first occurrence of 'sep' in the given string and returns the substring Searches for the first occurrence of `sep` in the given string and returns the substring
up to (but not including) the separator, as well as a boolean indicating success. up to (but not including) the separator, as well as a boolean indicating success.
*Used Internally - Private Function* *Used Internally - Private Function*
@@ -1124,7 +1124,7 @@ _trim_cr :: proc(s: string) -> string {
return s return s
} }
/* /*
Splits the input string at every line break '\n'. Splits the input string at every line break `\n`.
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -1158,7 +1158,7 @@ split_lines :: proc(s: string, allocator := context.allocator) -> []string {
return lines return lines
} }
/* /*
Splits the input string at every line break '\n' for n parts. Splits the input string at every line break `\n` for `n` parts.
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -1193,7 +1193,7 @@ split_lines_n :: proc(s: string, n: int, allocator := context.allocator) -> []st
return lines return lines
} }
/* /*
Splits the input string at every line break '\n' leaving the '\n' in the resulting strings. Splits the input string at every line break `\n` leaving the `\n` in the resulting strings.
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -1227,7 +1227,7 @@ split_lines_after :: proc(s: string, allocator := context.allocator) -> []string
return lines return lines
} }
/* /*
Splits the input string at every line break '\n' leaving the '\n' in the resulting strings. Splits the input string at every line break `\n` leaving the `\n` in the resulting strings.
Only runs for n parts. Only runs for n parts.
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -1263,7 +1263,7 @@ split_lines_after_n :: proc(s: string, n: int, allocator := context.allocator) -
return lines return lines
} }
/* /*
Splits the input string at every line break '\n'. Splits the input string at every line break `\n`.
Returns the current split string every iteration until the string is consumed. Returns the current split string every iteration until the string is consumed.
**Inputs** **Inputs**
@@ -1293,7 +1293,7 @@ split_lines_iterator :: proc(s: ^string) -> (line: string, ok: bool) {
return _trim_cr(line), true return _trim_cr(line), true
} }
/* /*
Splits the input string at every line break '\n'. Splits the input string at every line break `\n`.
Returns the current split string with line breaks included every iteration until the string is consumed. Returns the current split string with line breaks included every iteration until the string is consumed.
**Inputs** **Inputs**
@@ -1327,7 +1327,7 @@ split_lines_after_iterator :: proc(s: ^string) -> (line: string, ok: bool) {
return _trim_cr(line), true return _trim_cr(line), true
} }
/* /*
Returns the byte offset of the first byte c in the string s it finds, -1 when not found. Returns the byte offset of the first byte `c` in the string s it finds, -1 when not found.
NOTE: Can't find UTF-8 based runes. NOTE: Can't find UTF-8 based runes.
**Inputs** **Inputs**
@@ -1353,7 +1353,7 @@ Output:
-1 -1
-1 -1
**Returns** The byte offset of the first occurrence of c in s, or -1 if not found. **Returns** The byte offset of the first occurrence of `c` in `s`, or -1 if not found.
*/ */
index_byte :: proc(s: string, c: byte) -> int { index_byte :: proc(s: string, c: byte) -> int {
for i := 0; i < len(s); i += 1 { for i := 0; i < len(s); i += 1 {
@@ -1652,7 +1652,7 @@ index_any :: proc(s, chars: string) -> int {
return -1 return -1
} }
/* /*
Finds the last occurrence of any character in 'chars' within 's'. Iterates in reverse. Finds the last occurrence of any character in `chars` within `s`. Iterates in reverse.
**Inputs** **Inputs**
- s: The string to search in - s: The string to search in
@@ -1730,7 +1730,7 @@ last_index_any :: proc(s, chars: string) -> int {
return -1 return -1
} }
/* /*
Finds the first occurrence of any substring in 'substrs' within 's' Finds the first occurrence of any substring in `substrs` within `s`
**Inputs** **Inputs**
- s: The string to search in - s: The string to search in
@@ -1768,7 +1768,7 @@ index_multi :: proc(s: string, substrs: []string) -> (idx: int, width: int) {
return return
} }
/* /*
Counts the number of non-overlapping occurrences of 'substr' in 's' Counts the number of non-overlapping occurrences of `substr` in `s`
**Inputs** **Inputs**
- s: The string to search in - s: The string to search in
@@ -1795,7 +1795,7 @@ Output:
1 1
0 0
**Returns** The number of occurrences of 'substr' in 's', returns the rune_count + 1 of the string `s` on empty `substr` **Returns** The number of occurrences of `substr` in `s`, returns the rune_count + 1 of the string `s` on empty `substr`
*/ */
count :: proc(s, substr: string) -> int { count :: proc(s, substr: string) -> int {
if len(substr) == 0 { // special case if len(substr) == 0 { // special case
@@ -1832,13 +1832,13 @@ count :: proc(s, substr: string) -> int {
return n return n
} }
/* /*
Repeats the string 's' 'count' times, concatenating the result Repeats the string `s` `count` times, concatenating the result
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
**Inputs** **Inputs**
- s: The string to repeat - s: The string to repeat
- count: The number of times to repeat 's' - count: The number of times to repeat `s`
- allocator: (default is context.allocator) - allocator: (default is context.allocator)
WARNING: Panics if count < 0 WARNING: Panics if count < 0
@@ -1874,14 +1874,14 @@ repeat :: proc(s: string, count: int, allocator := context.allocator) -> string
return string(b) return string(b)
} }
/* /*
Replaces all occurrences of 'old' in 's' with 'new' Replaces all occurrences of `old` in `s` with `new`
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
**Inputs** **Inputs**
- s: The string to modify - s: The string to modify
- old: The substring to replace - old: The substring to replace
- new: The substring to replace 'old' with - new: The substring to replace `old` with
- allocator: The allocator to use for the new string (default is context.allocator) - allocator: The allocator to use for the new string (default is context.allocator)
Example: Example:
@@ -1915,7 +1915,7 @@ Replaces n instances of old in the string s with the new string
- s: The input string - s: The input string
- old: The substring to be replaced - old: The substring to be replaced
- new: The replacement string - new: The replacement string
- n: The number of instances to replace (if n < 0, no limit on the number of replacements) - n: The number of instances to replace (if `n < 0`, no limit on the number of replacements)
- allocator: (default: context.allocator) - allocator: (default: context.allocator)
Example: Example:
@@ -1979,14 +1979,14 @@ replace :: proc(s, old, new: string, n: int, allocator := context.allocator) ->
return return
} }
/* /*
Removes the key string n times from the s string Removes the key string `n` times from the `s` string
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
**Inputs** **Inputs**
- s: The input string - s: The input string
- key: The substring to be removed - key: The substring to be removed
- n: The number of instances to remove (if n < 0, no limit on the number of removes) - n: The number of instances to remove (if `n < 0`, no limit on the number of removes)
- allocator: (default: context.allocator) - allocator: (default: context.allocator)
Example: Example:
@@ -2014,7 +2014,7 @@ remove :: proc(s, key: string, n: int, allocator := context.allocator) -> (outpu
return replace(s, key, "", n, allocator) return replace(s, key, "", n, allocator)
} }
/* /*
Removes all the key string instances from the s string Removes all the `key` string instances from the `s` string
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -2045,7 +2045,7 @@ Output:
remove_all :: proc(s, key: string, allocator := context.allocator) -> (output: string, was_allocation: bool) { remove_all :: proc(s, key: string, allocator := context.allocator) -> (output: string, was_allocation: bool) {
return remove(s, key, -1, allocator) return remove(s, key, -1, allocator)
} }
// Returns true if the r rune is an ASCII space character ('\t', '\n', '\v', '\f', '\r', ' ') // Returns true if is an ASCII space character ('\t', '\n', '\v', '\f', '\r', ' ')
@(private) _ascii_space := [256]bool{'\t' = true, '\n' = true, '\v' = true, '\f' = true, '\r' = true, ' ' = true} @(private) _ascii_space := [256]bool{'\t' = true, '\n' = true, '\v' = true, '\f' = true, '\r' = true, ' ' = true}
// Returns true when the `r` rune is '\t', '\n', '\v', '\f', '\r' or ' ' // Returns true when the `r` rune is '\t', '\n', '\v', '\f', '\r' or ' '
@@ -2055,7 +2055,7 @@ is_ascii_space :: proc(r: rune) -> bool {
} }
return false return false
} }
// Returns true if the r rune is any ASCII or UTF-8 based whitespace character // Returns true if the `r` rune is any ASCII or UTF-8 based whitespace character
is_space :: proc(r: rune) -> bool { is_space :: proc(r: rune) -> bool {
if r < 0x2000 { if r < 0x2000 {
switch r { switch r {
@@ -2073,17 +2073,17 @@ is_space :: proc(r: rune) -> bool {
} }
return false return false
} }
// Returns true if the `r` rune is a null byte (0x0) // Returns true if the `r` rune is a null byte (`0x0`)
is_null :: proc(r: rune) -> bool { is_null :: proc(r: rune) -> bool {
return r == 0x0000 return r == 0x0000
} }
/* /*
Find the index of the first rune r in string s for which procedure p returns the same as truth, or -1 if no such rune appears. Find the index of the first rune `r` in string `s` for which procedure `p` returns the same as truth, or -1 if no such rune appears.
**Inputs** **Inputs**
- s: The input string - s: The input string
- p: A procedure that takes a rune and returns a boolean - p: A procedure that takes a rune and returns a boolean
- truth: The boolean value to be matched (default: true) - truth: The boolean value to be matched (default: `true`)
Example: Example:
@@ -2153,7 +2153,7 @@ last_index_proc_with_state :: proc(s: string, p: proc(rawptr, rune) -> bool, sta
return -1 return -1
} }
/* /*
Trims the input string s from the left until the procedure p returns false Trims the input string `s` from the left until the procedure `p` returns false
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -2185,12 +2185,12 @@ trim_left_proc :: proc(s: string, p: proc(rune) -> bool) -> string {
return s[i:] return s[i:]
} }
/* /*
Trims the input string s from the left until the procedure p with state returns false Trims the input string `s` from the left until the procedure `p` with state returns false
**Inputs** **Inputs**
- s: The input string - s: The input string
- p: A procedure that takes a raw pointer and a rune and returns a boolean - p: A procedure that takes a raw pointer and a rune and returns a boolean
- state: The raw pointer to be passed to the procedure p - state: The raw pointer to be passed to the procedure `p`
**Returns** The trimmed string as a slice of the original **Returns** The trimmed string as a slice of the original
*/ */
@@ -2202,7 +2202,7 @@ trim_left_proc_with_state :: proc(s: string, p: proc(rawptr, rune) -> bool, stat
return s[i:] return s[i:]
} }
/* /*
Trims the input string s from the right until the procedure p returns false Trims the input string `s` from the right until the procedure `p` returns `false`
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -2237,12 +2237,12 @@ trim_right_proc :: proc(s: string, p: proc(rune) -> bool) -> string {
return s[0:i] return s[0:i]
} }
/* /*
Trims the input string s from the right until the procedure p with state returns false Trims the input string `s` from the right until the procedure `p` with state returns `false`
**Inputs** **Inputs**
- s: The input string - s: The input string
- p: A procedure that takes a raw pointer and a rune and returns a boolean - p: A procedure that takes a raw pointer and a rune and returns a boolean
- state: The raw pointer to be passed to the procedure p - state: The raw pointer to be passed to the procedure `p`
**Returns** The trimmed string as a slice of the original, empty when no match **Returns** The trimmed string as a slice of the original, empty when no match
*/ */
@@ -2270,7 +2270,7 @@ is_in_cutset :: proc(state: rawptr, r: rune) -> bool {
return false return false
} }
/* /*
Trims the cutset string from the s string Trims the cutset string from the `s` string
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -2286,7 +2286,7 @@ trim_left :: proc(s: string, cutset: string) -> string {
return trim_left_proc_with_state(s, is_in_cutset, &state) return trim_left_proc_with_state(s, is_in_cutset, &state)
} }
/* /*
Trims the cutset string from the s string from the right Trims the cutset string from the `s` string from the right
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -2302,7 +2302,7 @@ trim_right :: proc(s: string, cutset: string) -> string {
return trim_right_proc_with_state(s, is_in_cutset, &state) return trim_right_proc_with_state(s, is_in_cutset, &state)
} }
/* /*
Trims the cutset string from the s string, both from left and right Trims the cutset string from the `s` string, both from left and right
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -2379,7 +2379,7 @@ trim_null :: proc(s: string) -> string {
return trim_right_null(trim_left_null(s)) return trim_right_null(trim_left_null(s))
} }
/* /*
Trims a prefix string from the start of the s string and returns the trimmed string Trims a `prefix` string from the start of the `s` string and returns the trimmed string
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -2409,7 +2409,7 @@ trim_prefix :: proc(s, prefix: string) -> string {
return s return s
} }
/* /*
Trims a suffix string from the end of the s string and returns the trimmed string Trims a `suffix` string from the end of the `s` string and returns the trimmed string
**Inputs** **Inputs**
- s: The input string - s: The input string
@@ -2439,7 +2439,7 @@ trim_suffix :: proc(s, suffix: string) -> string {
return s return s
} }
/* /*
Splits the input string s by all possible substrs and returns an allocated array of strings Splits the input string `s` by all possible `substrs` and returns an allocated array of strings
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -2508,7 +2508,7 @@ split_multi :: proc(s: string, substrs: []string, allocator := context.allocator
return results[:] return results[:]
} }
/* /*
Splits the input string s by all possible substrs in an iterator fashion. The full string is returned if no match. Splits the input string `s` by all possible `substrs` in an iterator fashion. The full string is returned if no match.
**Inputs** **Inputs**
- it: A pointer to the input string - it: A pointer to the input string
@@ -2621,7 +2621,7 @@ scrub :: proc(s: string, replacement: string, allocator := context.allocator) ->
return to_string(b) return to_string(b)
} }
/* /*
Reverses the input string s Reverses the input string `s`
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -2730,7 +2730,7 @@ expand_tabs :: proc(s: string, tab_size: int, allocator := context.allocator) ->
return to_string(b) return to_string(b)
} }
/* /*
Splits the input string str by the separator sep string and returns 3 parts. The values are slices of the original string. Splits the input string `str` by the separator `sep` string and returns 3 parts. The values are slices of the original string.
**Inputs** **Inputs**
- str: The input string - str: The input string
@@ -2754,7 +2754,7 @@ Output:
testing t hi s out testing t hi s out
testing this out testing this out
**Returns** A tuple with head (before the split), match (the separator), and tail (the end of the split) strings **Returns** A tuple with `head` (before the split), `match` (the separator), and `tail` (the end of the split) strings
*/ */
partition :: proc(str, sep: string) -> (head, match, tail: string) { partition :: proc(str, sep: string) -> (head, match, tail: string) {
i := index(str, sep) i := index(str, sep)
@@ -2871,7 +2871,7 @@ right_justify :: proc(str: string, length: int, pad: string, allocator := contex
return to_string(b) return to_string(b)
} }
/* /*
Writes a given pad string a specified number of times to an io.Writer Writes a given pad string a specified number of times to an `io.Writer`
**Inputs** **Inputs**
- w: The io.Writer to write the pad string to - w: The io.Writer to write the pad string to
@@ -2897,7 +2897,7 @@ write_pad_string :: proc(w: io.Writer, pad: string, pad_len, remains: int) {
} }
} }
/* /*
Splits a string into a slice of substrings at each instance of one or more consecutive white space characters, as defined by unicode.is_space Splits a string into a slice of substrings at each instance of one or more consecutive white space characters, as defined by `unicode.is_space`
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -2956,7 +2956,7 @@ fields :: proc(s: string, allocator := context.allocator) -> []string #no_bounds
return a return a
} }
/* /*
Splits a string into a slice of substrings at each run of unicode code points `r` satisfying the predicate f(r) Splits a string into a slice of substrings at each run of unicode code points `r` satisfying the predicate `f(r)`
*Allocates Using Provided Allocator* *Allocates Using Provided Allocator*
@@ -2965,7 +2965,7 @@ Splits a string into a slice of substrings at each run of unicode code points `r
- f: A predicate function to determine the split points - f: A predicate function to determine the split points
- allocator: (default is context.allocator) - allocator: (default is context.allocator)
NOTE: fields_proc makes no guarantee about the order in which it calls f(ch), it assumes that `f` always returns the same value for a given ch NOTE: fields_proc makes no guarantee about the order in which it calls `f(r)`, it assumes that `f` always returns the same value for a given `r`
**Returns** A slice of substrings of the input string, or an empty slice if all code points in the input string satisfy the predicate or if the input string is empty **Returns** A slice of substrings of the input string, or an empty slice if all code points in the input string satisfy the predicate or if the input string is empty
*/ */
@@ -2996,7 +2996,7 @@ fields_proc :: proc(s: string, f: proc(rune) -> bool, allocator := context.alloc
return substrings[:] return substrings[:]
} }
/* /*
Retrieves the first non-space substring from a mutable string reference and advances the reference. s is advanced from any space after the substring, or be an empty string if the substring was the remaining characters Retrieves the first non-space substring from a mutable string reference and advances the reference. `s` is advanced from any space after the substring, or be an empty string if the substring was the remaining characters
**Inputs** **Inputs**
- s: A mutable string reference to be iterated - s: A mutable string reference to be iterated
@@ -3038,7 +3038,7 @@ Computes the Levenshtein edit distance between two strings
*Allocates Using Provided Allocator (deletion occurs internal to proc)* *Allocates Using Provided Allocator (deletion occurs internal to proc)*
NOTE: Does not perform internal allocation if Length of String b in Runes is Smaller Than 64 NOTE: Does not perform internal allocation if length of string `b`, in runes, is smaller than 64
**Inputs** **Inputs**
- a, b: The two strings to compare - a, b: The two strings to compare