transform into odin-site parsable format

core/strings/ascii_set.odin

@@ -12,10 +12,10 @@ Ascii_Set :: distinct [8]u32
 /*
 Creates an Ascii_Set with unique characters from the input string.
 
-Inputs:
+**Inputs**
 - chars: A string containing characters to include in the Ascii_Set.
 
-Returns:
+**Returns**
 - as: An Ascii_Set with unique characters from the input string.
 - ok: false if any character in the input string is not a valid ASCII character.
 */
@@ -33,11 +33,11 @@ ascii_set_make :: proc(chars: string) -> (as: Ascii_Set, ok: bool) #no_bounds_ch
 /*
 Determines if a given char is contained within an Ascii_Set.
 
-Inputs:
+**Inputs**
 - as: The Ascii_Set to search.
 - c: The char to check for in the Ascii_Set.
 
-Returns: A boolean indicating if the byte is contained in the Ascii_Set (true) or not (false).
+**Returns** A boolean indicating if the byte is contained in the Ascii_Set (true) or not (false).
 */
 ascii_set_contains :: proc(as: Ascii_Set, c: byte) -> bool #no_bounds_check {
 	return as[c>>5] & (1<<(c&31)) != 0

core/strings/builder.odin

@@ -7,10 +7,10 @@ import "core:io"
 /*
 Type definition for a procedure that flushes a Builder
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 
-Returns: A boolean indicating whether the Builder should be reset
+**Returns** A boolean indicating whether the Builder should be reset
 */
 Builder_Flush_Proc :: #type proc(b: ^Builder) -> (do_reset: bool)
 /*
@@ -26,10 +26,10 @@ Produces a Builder with a default length of 0 and cap of 16
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - allocator: (default is context.allocator)
 
-Returns: A new Builder
+**Returns** A new Builder
 */
 builder_make_none :: proc(allocator := context.allocator) -> Builder {
 	return Builder{buf=make([dynamic]byte, allocator)}
@@ -39,11 +39,11 @@ Produces a Builder with a specified length and cap of max(16,len) byte buffer
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - len: The desired length of the Builder's buffer
 - allocator: (default is context.allocator)
 
-Returns: A new Builder
+**Returns** A new Builder
 */
 builder_make_len :: proc(len: int, allocator := context.allocator) -> Builder {
 	return Builder{buf=make([dynamic]byte, len, allocator)}
@@ -53,12 +53,12 @@ Produces a Builder with a specified length and cap
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - len: The desired length of the Builder's buffer
 - cap: The desired capacity of the Builder's buffer, cap is max(cap, len)
 - allocator: (default is context.allocator)
 
-Returns: A new Builder
+**Returns** A new Builder
 */
 builder_make_len_cap :: proc(len, cap: int, allocator := context.allocator) -> Builder {
 	return Builder{buf=make([dynamic]byte, len, cap, allocator)}
@@ -75,11 +75,11 @@ It replaces the existing `buf`
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - allocator: (default is context.allocator)
 
-Returns: initialized ^Builder
+**Returns** initialized ^Builder
 */
 builder_init_none :: proc(b: ^Builder, allocator := context.allocator) -> ^Builder {
 	b.buf = make([dynamic]byte, allocator)
@@ -91,12 +91,12 @@ It replaces the existing `buf`
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - len: The desired length of the Builder's buffer
 - allocator: (default is context.allocator)
 
-Returns: Initialized ^Builder
+**Returns** Initialized ^Builder
 */
 builder_init_len :: proc(b: ^Builder, len: int, allocator := context.allocator) -> ^Builder {
 	b.buf = make([dynamic]byte, len, allocator)
@@ -106,19 +106,19 @@ builder_init_len :: proc(b: ^Builder, len: int, allocator := context.allocator)
 Initializes a Builder with a specified length and cap
 It replaces the existing `buf`
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - len: The desired length of the Builder's buffer
 - cap: The desired capacity of the Builder's buffer, actual max(len,cap)
 - allocator: (default is context.allocator)
 
-Returns: A pointer to the initialized Builder
+**Returns** A pointer to the initialized Builder
 */
 builder_init_len_cap :: proc(b: ^Builder, len, cap: int, allocator := context.allocator) -> ^Builder {
 	b.buf = make([dynamic]byte, len, cap, allocator)
 	return b
 }
-// overload simple `builder_init_*` with or without len / ap parameters
+// Overload simple `builder_init_*` with or without len / ap parameters
 builder_init :: proc{
 	builder_init_none,
 	builder_init_len,
@@ -159,10 +159,10 @@ _builder_stream_vtable := &_builder_stream_vtable_obj
 /*
 Returns an io.Stream from a Builder
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 
-Returns: An io.Stream
+**Returns** An io.Stream
 */
 to_stream :: proc(b: ^Builder) -> io.Stream {
 	return io.Stream{stream_vtable=_builder_stream_vtable, stream_data=b}
@@ -170,10 +170,10 @@ to_stream :: proc(b: ^Builder) -> io.Stream {
 /*
 Returns an io.Writer from a Builder
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 
-Returns: An io.Writer
+**Returns** An io.Writer
 */
 to_writer :: proc(b: ^Builder) -> io.Writer {
 	return io.to_writer(to_stream(b))
@@ -181,7 +181,7 @@ to_writer :: proc(b: ^Builder) -> io.Writer {
 /*
 Deletes and clears the Builder byte buffer content
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 */
 builder_destroy :: proc(b: ^Builder) {
@@ -191,7 +191,7 @@ builder_destroy :: proc(b: ^Builder) {
 /*
 Reserves the Builder byte buffer to a specific capacity, when it's higher than before
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - cap: The desired capacity for the Builder's buffer
 */
@@ -201,7 +201,7 @@ builder_grow :: proc(b: ^Builder, cap: int) {
 /*
 Clears the Builder byte buffer content (sets len to zero)
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 */
 builder_reset :: proc(b: ^Builder) {
@@ -212,17 +212,26 @@ Creates a Builder from a slice of bytes with the same slice length as its capaci
 
 *Uses Nil Allocator - Does NOT allocate*
 
-Inputs:
+**Inputs**
 - backing: A slice of bytes to be used as the backing buffer
 
 Example:
-```odin
+
-	bytes: [8]byte // <-- gets filled
+	import "core:fmt"
-	builder := strings.builder_from_bytes(bytes[:])
+	import "core:strings"
-	strings.write_byte(&builder, 'a') // -> "a"
+	strings_builder_from_bytes_example :: proc() {
-	strings.write_byte(&builder, 'b') // -> "ab"
+		bytes: [8]byte // <-- gets filled
-```
+		builder := strings.builder_from_bytes(bytes[:])
-Returns: A new Builder
+		fmt.println(strings.write_byte(&builder, 'a')) // -> "a"
+		fmt.println(strings.write_byte(&builder, 'b')) // -> "ab"
+	}
+
+Output:
+
+	a
+	ab
+
+**Returns** A new Builder
 */
 builder_from_bytes :: proc(backing: []byte) -> Builder {
 	s := transmute(runtime.Raw_Slice)backing
@@ -241,10 +250,10 @@ builder_from_slice :: builder_from_bytes
 /*
 Casts the Builder byte buffer to a string and returns it
 
-Inputs:
+**Inputs**
 - b: A Builder
 
-Returns: The contents of the Builder's buffer, as a string
+**Returns** The contents of the Builder's buffer, as a string
 */
 to_string :: proc(b: Builder) -> string {
 	return string(b.buf[:])
@@ -252,10 +261,10 @@ to_string :: proc(b: Builder) -> string {
 /*
 Returns the length of the Builder's buffer, in bytes
 
-Inputs:
+**Inputs**
 - b: A Builder
 
-Returns: The length of the Builder's buffer
+**Returns** The length of the Builder's buffer
 */
 builder_len :: proc(b: Builder) -> int {
 	return len(b.buf)
@@ -263,10 +272,10 @@ builder_len :: proc(b: Builder) -> int {
 /*
 Returns the capacity of the Builder's buffer, in bytes
 
-Inputs:
+**Inputs**
 - b: A Builder
 
-Returns: The capacity of the Builder's buffer
+**Returns** The capacity of the Builder's buffer
 */
 builder_cap :: proc(b: Builder) -> int {
 	return cap(b.buf)
@@ -274,10 +283,10 @@ builder_cap :: proc(b: Builder) -> int {
 /*
 The free space left in the Builder's buffer, in bytes
 
-Inputs:
+**Inputs**
 - b: A Builder
 
-Returns: The available space left in the Builder's buffer
+**Returns** The available space left in the Builder's buffer
 */
 builder_space :: proc(b: Builder) -> int {
 	return cap(b.buf) - len(b.buf)
@@ -285,20 +294,29 @@ builder_space :: proc(b: Builder) -> int {
 /*
 Appends a byte to the Builder and returns the number of bytes appended
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - x: The byte to be appended
 
 Example:
-```odin
+
-	builder := strings.builder_make()
+	import "core:fmt"
-	strings.write_byte(&builder, 'a')        // 1
+	import "core:strings"
-	strings.write_byte(&builder, 'b')        // 1
+
-	fmt.println(strings.to_string(builder))  // -> ab
+	strings_write_byte_example :: proc() {
-```
+		builder := strings.builder_make()
+		strings.write_byte(&builder, 'a')        // 1
+		strings.write_byte(&builder, 'b')        // 1
+		fmt.println(strings.to_string(builder))  // -> ab
+	}
+
+**Output**
+
+	ab
+
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of bytes appended
+**Returns** The number of bytes appended
 */
 write_byte :: proc(b: ^Builder, x: byte) -> (n: int) {
 	n0 := len(b.buf)
@@ -309,20 +327,25 @@ write_byte :: proc(b: ^Builder, x: byte) -> (n: int) {
 /*
 Appends a slice of bytes to the Builder and returns the number of bytes appended
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - x: The slice of bytes to be appended
 
 Example:
-```odin
+
-	builder := strings.builder_make()
+	import "core:fmt"
-	bytes := [?]byte { 'a', 'b', 'c' }
+	import "core:strings"
-	strings.write_bytes(&builder, bytes[:]) // 3
+
-	fmt.println(strings.to_string(builder)) // -> abc
+	strings_write_bytes_example :: proc() {
-```
+		builder := strings.builder_make()
+		bytes := [?]byte { 'a', 'b', 'c' }
+		strings.write_bytes(&builder, bytes[:]) // 3
+		fmt.println(strings.to_string(builder)) // -> abc
+	}
+
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of bytes appended
+**Returns** The number of bytes appended
 */
 write_bytes :: proc(b: ^Builder, x: []byte) -> (n: int) {
 	n0 := len(b.buf)
@@ -333,20 +356,29 @@ write_bytes :: proc(b: ^Builder, x: []byte) -> (n: int) {
 /*
 Appends a single rune to the Builder and returns the number of bytes written and an `io.Error`
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - r: The rune to be appended
 
 Example:
-```odin
+
-	builder := strings.builder_make()
+	import "core:fmt"
-	strings.write_rune(&builder, 'ä')     // 2 None
+	import "core:strings"
-	strings.write_rune(&builder, 'b')       // 1 None
+
-	fmt.println(strings.to_string(builder)) // -> äb
+	strings_write_rune_example :: proc() {
-```
+		builder := strings.builder_make()
+		strings.write_rune(&builder, 'ä')     // 2 None
+		strings.write_rune(&builder, 'b')       // 1 None
+		fmt.println(strings.to_string(builder)) // -> äb
+	}
+
+Output:
+
+	äb
+
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of bytes written and an io.Error (if any)
+**Returns** The number of bytes written and an io.Error (if any)
 */
 write_rune :: proc(b: ^Builder, r: rune) -> (int, io.Error) {
 	return io.write_rune(to_writer(b), r)
@@ -354,21 +386,30 @@ write_rune :: proc(b: ^Builder, r: rune) -> (int, io.Error) {
 /*
 Appends a quoted rune to the Builder and returns the number of bytes written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - r: The rune to be appended
 
 Example:
-```odin
+
-	builder := strings.builder_make()
+	import "core:fmt"
-	strings.write_string(&builder, "abc")      // 3
+	import "core:strings"
-	strings.write_quoted_rune(&builder, 'ä') // 4
+
-	strings.write_string(&builder, "abc")      // 3
+	strings_write_quoted_rune_example :: proc() {
-	fmt.println(strings.to_string(builder))    // -> abc'ä'abc
+		builder := strings.builder_make()
-```
+		strings.write_string(&builder, "abc")      // 3
+		strings.write_quoted_rune(&builder, 'ä') // 4
+		strings.write_string(&builder, "abc")      // 3
+		fmt.println(strings.to_string(builder))    // -> abc'ä'abc
+	}
+
+Output:
+
+	abc'ä'abc
+
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of bytes written
+**Returns** The number of bytes written
 */
 write_quoted_rune :: proc(b: ^Builder, r: rune) -> (n: int) {
 	return io.write_quoted_rune(to_writer(b), r)
@@ -376,20 +417,29 @@ write_quoted_rune :: proc(b: ^Builder, r: rune) -> (n: int) {
 /*
 Appends a string to the Builder and returns the number of bytes written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - s: The string to be appended
 
 Example:
-```odin
+
-	builder := strings.builder_make()
+	import "core:fmt"
-	strings.write_string(&builder, "a")     // 1
+	import "core:strings"
-	strings.write_string(&builder, "bc")    // 2
+
-	fmt.println(strings.to_string(builder)) // -> abc
+	strings_write_string_example :: proc() {
-```
+		builder := strings.builder_make()
+		strings.write_string(&builder, "a")     // 1
+		strings.write_string(&builder, "bc")    // 2
+		fmt.println(strings.to_string(builder)) // -> abc
+	}
+
+Output:
+
+	abc
+
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of bytes written
+**Returns** The number of bytes written
 */
 write_string :: proc(b: ^Builder, s: string) -> (n: int) {
 	n0 := len(b.buf)
@@ -400,10 +450,10 @@ write_string :: proc(b: ^Builder, s: string) -> (n: int) {
 /*
 Pops and returns the last byte in the Builder or 0 when the Builder is empty
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 
-Returns: The last byte in the Builder or 0 if empty
+**Returns** The last byte in the Builder or 0 if empty
 */
 pop_byte :: proc(b: ^Builder) -> (r: byte) {
 	if len(b.buf) == 0 {
@@ -418,10 +468,10 @@ pop_byte :: proc(b: ^Builder) -> (r: byte) {
 /*
 Pops the last rune in the Builder and returns the popped rune and its rune width or (0, 0) if empty
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 
-Returns: The popped rune and its rune width or (0, 0) if empty
+**Returns** The popped rune and its rune width or (0, 0) if empty
 */
 pop_rune :: proc(b: ^Builder) -> (r: rune, width: int) {
 	if len(b.buf) == 0 {
@@ -436,22 +486,31 @@ pop_rune :: proc(b: ^Builder) -> (r: rune, width: int) {
 @(private)
 DIGITS_LOWER := "0123456789abcdefx"
 /*
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - str: The string to be quoted and appended
 - quote: The optional quote character (default is double quotes)
 
 Example:
-```odin
+
-	builder := strings.builder_make()
+	import "core:fmt"
-	strings.write_quoted_string(&builder, "a")        // 3
+	import "core:strings"
-	strings.write_quoted_string(&builder, "bc", '\'') // 4
+
-	strings.write_quoted_string(&builder, "xyz")      // 5
+	strings_write_quoted_string_example :: proc() {
-	fmt.println(strings.to_string(builder))           // -> "a"'bc'xyz"
+		builder := strings.builder_make()
-```
+		strings.write_quoted_string(&builder, "a")        // 3
+		strings.write_quoted_string(&builder, "bc", '\'') // 4
+		strings.write_quoted_string(&builder, "xyz")      // 5
+		fmt.println(strings.to_string(builder))           // -> "a"'bc'xyz"
+	}
+
+Output:
+
+	"a"'bc'xyz"
+
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of bytes written
+**Returns** The number of bytes written
 */
 write_quoted_string :: proc(b: ^Builder, str: string, quote: byte = '"') -> (n: int) {
 	n, _ = io.write_quoted_string(to_writer(b), str, quote)
@@ -460,14 +519,14 @@ write_quoted_string :: proc(b: ^Builder, str: string, quote: byte = '"') -> (n:
 /*
 Appends an encoded rune to the Builder and returns the number of bytes written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - r: The rune to be appended
 - write_quote: Optional boolean flag to write the quote character (default is true)
 
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of bytes written
+**Returns** The number of bytes written
 */
 write_encoded_rune :: proc(b: ^Builder, r: rune, write_quote := true) -> (n: int) {
 	n, _ = io.write_encoded_rune(to_writer(b), r, write_quote)
@@ -477,20 +536,20 @@ write_encoded_rune :: proc(b: ^Builder, r: rune, write_quote := true) -> (n: int
 /*
 Appends an escaped rune to the Builder and returns the number of bytes written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - r: The rune to be appended
 - quote: The quote character
 - html_safe: Optional boolean flag to encode '<', '>', '&' as digits (default is false)
 
-Examples:
+**Usage**
 - '\a' will be written as such
 - `r` and `quote` match and `quote` is `\\` - they will be written as two slashes
 - `html_safe` flag in case the runes '<', '>', '&' should be encoded as digits e.g. `\u0026`
 
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of bytes written
+**Returns** The number of bytes written
 */
 write_escaped_rune :: proc(b: ^Builder, r: rune, quote: byte, html_safe := false) -> (n: int) {
 	n, _ = io.write_escaped_rune(to_writer(b), r, quote, html_safe)
@@ -499,7 +558,7 @@ write_escaped_rune :: proc(b: ^Builder, r: rune, quote: byte, html_safe := false
 /*
 Writes a f64 value to the Builder and returns the number of characters written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - f: The f64 value to be appended
 - fmt: The format byte
@@ -509,7 +568,7 @@ Inputs:
 
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of characters written
+**Returns** The number of characters written
 */
 write_float :: proc(b: ^Builder, f: f64, fmt: byte, prec, bit_size: int, always_signed := false) -> (n: int) {
 	buf: [384]byte
@@ -524,7 +583,7 @@ write_float :: proc(b: ^Builder, f: f64, fmt: byte, prec, bit_size: int, always_
 /*
 Writes a f16 value to the Builder and returns the number of characters written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - f: The f16 value to be appended
 - fmt: The format byte
@@ -532,7 +591,7 @@ Inputs:
 
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of characters written
+**Returns** The number of characters written
 */
 write_f16 :: proc(b: ^Builder, f: f16, fmt: byte, always_signed := false) -> (n: int) {
 	buf: [384]byte
@@ -545,23 +604,32 @@ write_f16 :: proc(b: ^Builder, f: f16, fmt: byte, always_signed := false) -> (n:
 /*
 Writes a f32 value to the Builder and returns the number of characters written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - f: The f32 value to be appended
 - fmt: The format byte
 - always_signed: Optional boolean flag to always include the sign
 
 Example:
-```odin
+
-	builder := strings.builder_make()
+	import "core:fmt"
-	strings.write_f32(&builder, 3.14159, 'f') // 6
+	import "core:strings"
-	strings.write_string(&builder, " - ")     // 3
+
-	strings.write_f32(&builder, -0.123, 'e')  // 8
+	strings_write_f32_example :: proc() {
-	fmt.println(strings.to_string(builder))   // -> 3.14159012 - -1.23000003e-01
+		builder := strings.builder_make()
-```
+		strings.write_f32(&builder, 3.14159, 'f') // 6
+		strings.write_string(&builder, " - ")     // 3
+		strings.write_f32(&builder, -0.123, 'e')  // 8
+		fmt.println(strings.to_string(builder))   // -> 3.14159012 - -1.23000003e-01
+	}
+
+Output:
+
+	3.14159012 - -1.23000003e-01
+
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of characters written
+**Returns** The number of characters written
 */
 write_f32 :: proc(b: ^Builder, f: f32, fmt: byte, always_signed := false) -> (n: int) {
 	buf: [384]byte
@@ -574,7 +642,7 @@ write_f32 :: proc(b: ^Builder, f: f32, fmt: byte, always_signed := false) -> (n:
 /*
 Writes a f32 value to the Builder and returns the number of characters written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - f: The f32 value to be appended
 - fmt: The format byte
@@ -582,7 +650,7 @@ Inputs:
 
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of characters written
+**Returns** The number of characters written
 */
 write_f64 :: proc(b: ^Builder, f: f64, fmt: byte, always_signed := false) -> (n: int) {
 	buf: [384]byte
@@ -595,14 +663,14 @@ write_f64 :: proc(b: ^Builder, f: f64, fmt: byte, always_signed := false) -> (n:
 /*
 Writes a u64 value to the Builder and returns the number of characters written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - i: The u64 value to be appended
 - base: The optional base for the numeric representation
 
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of characters written
+**Returns** The number of characters written
 */
 write_u64 :: proc(b: ^Builder, i: u64, base: int = 10) -> (n: int) {
 	buf: [32]byte
@@ -612,14 +680,14 @@ write_u64 :: proc(b: ^Builder, i: u64, base: int = 10) -> (n: int) {
 /*
 Writes a i64 value to the Builder and returns the number of characters written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - i: The i64 value to be appended
 - base: The optional base for the numeric representation
 
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of characters written
+**Returns** The number of characters written
 */
 write_i64 :: proc(b: ^Builder, i: i64, base: int = 10) -> (n: int) {
 	buf: [32]byte
@@ -629,14 +697,14 @@ write_i64 :: proc(b: ^Builder, i: i64, base: int = 10) -> (n: int) {
 /*
 Writes a uint value to the Builder and returns the number of characters written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - i: The uint value to be appended
 - base: The optional base for the numeric representation
 
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of characters written
+**Returns** The number of characters written
 */
 write_uint :: proc(b: ^Builder, i: uint, base: int = 10) -> (n: int) {
 	return write_u64(b, u64(i), base)
@@ -644,14 +712,14 @@ write_uint :: proc(b: ^Builder, i: uint, base: int = 10) -> (n: int) {
 /*
 Writes a int value to the Builder and returns the number of characters written
 
-Inputs:
+**Inputs**
 - b: A pointer to the Builder
 - i: The int value to be appended
 - base: The optional base for the numeric representation
 
 NOTE: The backing dynamic array may be fixed in capacity or fail to resize, `n` states the number actually written.
 
-Returns: The number of characters written
+**Returns** The number of characters written
 */
 write_int :: proc(b: ^Builder, i: int, base: int = 10) -> (n: int) {
 	return write_i64(b, i64(i), base)

core/strings/conversion.odin

@@ -9,14 +9,14 @@ Converts invalid UTF-8 sequences in the input string `s` to the `replacement` st
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: Input string that may contain invalid UTF-8 sequences.
 - replacement: String to replace invalid UTF-8 sequences with.
 - allocator: (default: context.allocator).
 
 WARNING: Allocation does not occur when len(s) == 0
 
-Returns: A valid UTF-8 string with invalid sequences replaced by `replacement`.
+**Returns** A valid UTF-8 string with invalid sequences replaced by `replacement`.
 */
 to_valid_utf8 :: proc(s, replacement: string, allocator := context.allocator) -> string {
 	if len(s) == 0 {
@@ -76,15 +76,24 @@ Converts the input string `s` to all lowercase characters.
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: Input string to be converted.
 - allocator: (default: context.allocator).
 
 Example:
-```odin
+
-	strings.to_lower("TeST") -> test
+	import "core:fmt"
-```
+	import "core:strings"
-Returns: A new string with all characters converted to lowercase.
+
+	strings_to_lower_example :: proc() {
+		fmt.println(strings.to_lower("TeST"))
+	}
+
+Output:
+
+	test
+
+**Returns** A new string with all characters converted to lowercase.
 */
 to_lower :: proc(s: string, allocator := context.allocator) -> string {
 	b: Builder
@@ -99,15 +108,24 @@ Converts the input string `s` to all uppercase characters.
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: Input string to be converted.
 - allocator: (default: context.allocator).
 
 Example:
-```odin
+
-	strings.to_upper("Test") -> TEST
+	import "core:fmt"
-```
+	import "core:strings"
-Returns: A new string with all characters converted to uppercase.
+
+	strings_to_upper_example :: proc() {
+		fmt.println(strings.to_upper("Test"))
+	}
+
+Output:
+
+	TEST
+
+**Returns** A new string with all characters converted to uppercase.
 */
 to_upper :: proc(s: string, allocator := context.allocator) -> string {
 	b: Builder
@@ -120,10 +138,10 @@ to_upper :: proc(s: string, allocator := context.allocator) -> string {
 /*
 Checks if the rune `c` is a delimiter (' ', '-', or '_').
 
-Inputs:
+**Inputs**
 - c: Rune to check for delimiter status.
 
-Returns: True if `c` is a delimiter, false otherwise.
+**Returns** True if `c` is a delimiter, false otherwise.
 */
 is_delimiter :: proc(c: rune) -> bool {
 	return c == '-' || c == '_' || is_space(c)
@@ -131,10 +149,10 @@ is_delimiter :: proc(c: rune) -> bool {
 /*
 Checks if the rune `r` is a non-alphanumeric or space character.
 
-Inputs:
+**Inputs**
 - r: Rune to check for separator status.
 
-Returns: True if `r` is a non-alpha or `unicode.is_space` rune.
+**Returns** True if `r` is a non-alpha or `unicode.is_space` rune.
 */
 is_separator :: proc(r: rune) -> bool {
 	if r <= 0x7f {
@@ -161,23 +179,37 @@ is_separator :: proc(r: rune) -> bool {
 /*
 Iterates over a string, calling a callback for each rune with the previous, current, and next runes as arguments.
 
-Inputs:
+**Inputs**
 - w: An io.Writer to be used by the callback for writing output.
 - s: The input string to be iterated over.
 - callback: A procedure to be called for each rune in the string, with arguments (w: io.Writer, prev, curr, next: rune).
 The callback can utilize the provided io.Writer to write output during the iteration.
 
 Example:
-```odin
+
-	my_callback :: proc(w: io.Writer, prev, curr, next: rune) {
+	import "core:fmt"
-		fmt.println("my_callback", curr) // <-- Custom logic here
+	import "core:strings"
+	import "core:io"
+
+	strings_string_case_iterator_example :: proc() {
+		my_callback :: proc(w: io.Writer, prev, curr, next: rune) {
+			fmt.println("my_callback", curr) // <-- Custom logic here
+		}
+		s := "hello world"
+		b: strings.Builder
+		strings.builder_init_len(&b, len(s))
+		w := strings.to_writer(&b)
+		strings.string_case_iterator(w, s, my_callback)
 	}
-	s := "hello world"
+
-	b: strings.Builder
+Output:
-	strings.builder_init_len(&b, len(s))
+
-	w := strings.to_writer(&b)
+	my_callback h
-	strings.string_case_iterator(w, s, my_callback)
+	my_callback e
-```
+	my_callback l
+	my_callback l
+	my_callback o
+
 */
 string_case_iterator :: proc(
 	w: io.Writer,
@@ -209,11 +241,11 @@ Converts the input string `s` to "lowerCamelCase".
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: Input string to be converted.
 - allocator: (default: context.allocator).
 
-Returns: A "lowerCamelCase" formatted string.
+**Returns** A "lowerCamelCase" formatted string.
 */
 to_camel_case :: proc(s: string, allocator := context.allocator) -> string {
 	s := s
@@ -243,11 +275,11 @@ Converts the input string `s` to "UpperCamelCase" (PascalCase).
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: Input string to be converted.
 - allocator: (default: context.allocator).
 
-Returns: A "PascalCase" formatted string.
+**Returns** A "PascalCase" formatted string.
 */
 to_pascal_case :: proc(s: string, allocator := context.allocator) -> string {
 	s := s
@@ -275,19 +307,30 @@ Returns a string converted to a delimiter-separated case with configurable casin
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: The input string to be converted
 - delimiter: The rune to be used as the delimiter between words
 - all_upper_case: A boolean indicating if the output should be all uppercased (true) or lowercased (false)
 - allocator: (default: context.allocator).
 
 Example:
-```odin
+
-	strings.to_delimiter_case("Hello World", '_', false) // -> "hello_world"
+	import "core:fmt"
-	strings.to_delimiter_case("Hello World", ' ', true)  // -> "HELLO WORLD"
+	import "core:strings"
-	strings.to_delimiter_case("aBC", '_', false)         // -> "a_b_c"
+
-```
+	strings_to_delimiter_case_example :: proc() {
-Returns: The converted string
+		fmt.println(strings.to_delimiter_case("Hello World", '_', false))
+		fmt.println(strings.to_delimiter_case("Hello World", ' ', true))
+		fmt.println(strings.to_delimiter_case("aBC", '_', false))
+	}
+
+Output:
+
+	hello_world
+	HELLO WORLD
+	a_b_c
+
+**Returns** The converted string
 */
 to_delimiter_case :: proc(
 	s: string,
@@ -337,16 +380,27 @@ Converts a string to "snake_case" with all runes lowercased
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: The input string to be converted
 - allocator: (default: context.allocator).
 
 Example:
-```odin
+
-	strings.to_snake_case("HelloWorld")  // -> "hello_world"
+	import "core:fmt"
-	strings.to_snake_case("Hello World") // -> "hello_world"
+	import "core:strings"
+
+	strings_to_snake_case_example :: proc() {
+		fmt.println(strings.to_snake_case("HelloWorld"))
+		fmt.println(strings.to_snake_case("Hello World"))
+	}
+
+Output:
+
+	hello_world
+	hello_world
+
 ```
-Returns: The converted string
+**Returns** The converted string
 */
 to_snake_case :: proc(s: string, allocator := context.allocator) -> string {
 	return to_delimiter_case(s, '_', false, allocator)
@@ -358,15 +412,24 @@ Converts a string to "SNAKE_CASE" with all runes uppercased
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: The input string to be converted
 - allocator: (default: context.allocator).
 
 Example:
-```odin
+
-	strings.to_upper_snake_case("HelloWorld") // -> "HELLO_WORLD"
+	import "core:fmt"
-```
+	import "core:strings"
-Returns: The converted string
+
+	strings_to_upper_snake_case_example :: proc() {
+		fmt.println(strings.to_upper_snake_case("HelloWorld"))
+	}
+
+Output:
+
+	HELLO_WORLD
+
+**Returns** The converted string
 */
 to_upper_snake_case :: proc(s: string, allocator := context.allocator) -> string {
 	return to_delimiter_case(s, '_', true, allocator)
@@ -376,15 +439,24 @@ Converts a string to "kebab-case" with all runes lowercased
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: The input string to be converted
 - allocator: (default: context.allocator).
 
 Example:
-```odin
+
-	strings.to_kebab_case("HelloWorld") // -> "hello-world"
+	import "core:fmt"
-```
+	import "core:strings"
-Returns: The converted string
+
+	strings_to_kebab_case_example :: proc() {
+		fmt.println(strings.to_kebab_case("HelloWorld"))
+	}
+
+Output:
+
+	hello-world
+
+**Returns** The converted string
 */
 to_kebab_case :: proc(s: string, allocator := context.allocator) -> string {
 	return to_delimiter_case(s, '-', false, allocator)
@@ -394,15 +466,24 @@ Converts a string to "KEBAB-CASE" with all runes uppercased
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: The input string to be converted
 - allocator: (default: context.allocator).
 
 Example:
-```odin
+
-	strings.to_upper_kebab_case("HelloWorld") // -> "HELLO-WORLD"
+	import "core:fmt"
-```
+	import "core:strings"
-Returns: The converted string
+
+	strings_to_upper_kebab_case_example :: proc() {
+		fmt.println(strings.to_upper_kebab_case("HelloWorld"))
+	}
+
+Output:
+
+	HELLO-WORLD
+
+**Returns** The converted string
 */
 to_upper_kebab_case :: proc(s: string, allocator := context.allocator) -> string {
 	return to_delimiter_case(s, '-', true, allocator)
@@ -412,15 +493,24 @@ Converts a string to "Ada_Case"
 
 *Allocates Using Provided Allocator*
 
-Inputs:
+**Inputs**
 - s: The input string to be converted
 - allocator: (default: context.allocator).
 
 Example:
-```odin
+
-	strings.to_ada_case("HelloWorld") // -> "Hello_World"
+	import "core:fmt"
-```
+	import "core:strings"
-Returns: The converted string
+
+	strings_to_upper_kebab_case_example :: proc() {
+		fmt.println(strings.to_ada_case("HelloWorld"))
+	}
+
+Output:
+
+	Hello_World
+
+**Returns** The converted string
 */
 to_ada_case :: proc(s: string, allocator := context.allocator) -> string {
 	s := s

core/strings/intern.odin

@@ -25,7 +25,7 @@ Initializes the entries map and sets the allocator for the string entries
 
 *Allocates Using Provided Allocators*
 
-Inputs:
+**Inputs**
 - m: A pointer to the Intern struct to be initialized
 - allocator: The allocator for the Intern_Entry strings (Default: context.allocator)
 - map_allocator: The allocator for the map of entries (Default: context.allocator)
@@ -37,7 +37,7 @@ intern_init :: proc(m: ^Intern, allocator := context.allocator, map_allocator :=
 /*
 Frees the map and all its content allocated using the `.allocator`.
 
-Inputs:
+**Inputs**
 - m: A pointer to the Intern struct to be destroyed
 */
 intern_destroy :: proc(m: ^Intern) {
@@ -51,13 +51,13 @@ Returns the interned string for the given text, is set in the map if it didnt ex
 
 *MAY Allocate using the Intern's Allocator*
 
-Inputs:
+**Inputs**
 - m: A pointer to the Intern struct
 - text: The string to be interned
 
 NOTE: The returned string lives as long as the map entry lives.
 
-Returns: The interned string and an allocator error if any
+**Returns** The interned string and an allocator error if any
 */
 intern_get :: proc(m: ^Intern, text: string) -> (str: string, err: runtime.Allocator_Error) {
 	entry := _intern_get_entry(m, text) or_return
@@ -68,13 +68,13 @@ Returns the interned C-String for the given text, is set in the map if it didnt
 
 *MAY Allocate using the Intern's Allocator*
 
-Inputs:
+**Inputs**
 - m: A pointer to the Intern struct
 - text: The string to be interned
 
 NOTE: The returned C-String lives as long as the map entry lives
 
-Returns: The interned C-String and an allocator error if any
+**Returns** The interned C-String and an allocator error if any
 */
 intern_get_cstring :: proc(m: ^Intern, text: string) -> (str: cstring, err: runtime.Allocator_Error) {
 	entry := _intern_get_entry(m, text) or_return
@@ -86,11 +86,11 @@ Sets and allocates the entry if it wasn't set yet
 
 *MAY Allocate using the Intern's Allocator*
 
-Inputs:
+**Inputs**
 - m: A pointer to the Intern struct
 - text: The string to be looked up or interned
 
-Returns: The new or existing interned entry and an allocator error if any
+**Returns** The new or existing interned entry and an allocator error if any
 */
 _intern_get_entry :: proc(m: ^Intern, text: string) -> (new_entry: ^Intern_Entry, err: runtime.Allocator_Error) #no_bounds_check {
 	if prev, ok := m.entries[text]; ok {

core/strings/reader.odin

@@ -16,7 +16,7 @@ Reader :: struct {
 /*
 Initializes a string Reader with the provided string
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 - s: The input string to be read
 */
@@ -28,10 +28,10 @@ reader_init :: proc(r: ^Reader, s: string) {
 /*
 Converts a Reader into an io.Stream
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 
-Returns: An io.Stream for the given Reader
+**Returns** An io.Stream for the given Reader
 */
 reader_to_stream :: proc(r: ^Reader) -> (s: io.Stream) {
 	s.stream_data = r
@@ -41,11 +41,11 @@ reader_to_stream :: proc(r: ^Reader) -> (s: io.Stream) {
 /*
 Initializes a string Reader and returns an io.Reader for the given string
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 - s: The input string to be read
 
-Returns: An io.Reader for the given string
+**Returns** An io.Reader for the given string
 */
 to_reader :: proc(r: ^Reader, s: string) -> io.Reader {
 	reader_init(r, s)
@@ -55,11 +55,11 @@ to_reader :: proc(r: ^Reader, s: string) -> io.Reader {
 /*
 Initializes a string Reader and returns an io.Reader_At for the given string
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 - 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 {
 	reader_init(r, s)
@@ -69,10 +69,10 @@ to_reader_at :: proc(r: ^Reader, s: string) -> io.Reader_At {
 /*
 Returns the remaining length of the Reader
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 
-Returns: The remaining length of the Reader
+**Returns** The remaining length of the Reader
 */
 reader_length :: proc(r: ^Reader) -> int {
 	if r.i >= i64(len(r.s)) {
@@ -83,10 +83,10 @@ reader_length :: proc(r: ^Reader) -> int {
 /*
 Returns the length of the string stored in the Reader
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 
-Returns: The length of the string stored in the Reader
+**Returns** The length of the string stored in the Reader
 */
 reader_size :: proc(r: ^Reader) -> i64 {
 	return i64(len(r.s))
@@ -94,11 +94,11 @@ reader_size :: proc(r: ^Reader) -> i64 {
 /*
 Reads len(p) bytes from the Reader's string and copies into the provided slice.
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 - p: A byte slice to copy data into
 
-Returns:
+**Returns**
 - n: The number of bytes read
 - err: An io.Error if an error occurs while reading, including .EOF, otherwise nil denotes success.
 */
@@ -114,12 +114,12 @@ reader_read :: proc(r: ^Reader, p: []byte) -> (n: int, err: io.Error) {
 /*
 Reads len(p) bytes from the Reader's string and copies into the provided slice, at the specified offset from the current index.
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 - p: A byte slice to copy data into
 - off: The offset from which to read
 
-Returns:
+**Returns**
 - n: The number of bytes read
 - err: An io.Error if an error occurs while reading, including .EOF, otherwise nil denotes success.
 */
@@ -139,10 +139,10 @@ reader_read_at :: proc(r: ^Reader, p: []byte, off: i64) -> (n: int, err: io.Erro
 /*
 Reads and returns a single byte from the Reader's string
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 
-Returns:
+**Returns**
 - The byte read from the Reader
 - err: An io.Error if an error occurs while reading, including .EOF, otherwise nil denotes success.
 */
@@ -158,10 +158,10 @@ reader_read_byte :: proc(r: ^Reader) -> (byte, io.Error) {
 /*
 Decrements the Reader's index (i) by 1
 
-Inputs:
+**Inputs**
 - 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 {
 	if r.i <= 0 {
@@ -174,10 +174,10 @@ reader_unread_byte :: proc(r: ^Reader) -> io.Error {
 /*
 Reads and returns a single rune and its size from the Reader's string
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 
-Returns:
+**Returns**
 - ch: The rune read from the Reader
 - size: The size of the rune in bytes
 - err: An io.Error if an error occurs while reading
@@ -199,12 +199,12 @@ reader_read_rune :: proc(r: ^Reader) -> (ch: rune, size: int, err: io.Error) {
 /*
 Decrements the Reader's index (i) by the size of the last read rune
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 
 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 {
 	if r.i <= 0 {
@@ -220,12 +220,12 @@ reader_unread_rune :: proc(r: ^Reader) -> io.Error {
 /*
 Seeks the Reader's index to a new position
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 - offset: The new offset position
 - whence: The reference point for the new position (.Start, .Current, or .End)
 
-Returns:
+**Returns**
 - The absolute offset after seeking
 - err: An io.Error if an error occurs while seeking (.Invalid_Whence, .Invalid_Offset)
 */
@@ -252,13 +252,13 @@ reader_seek :: proc(r: ^Reader, offset: i64, whence: io.Seek_From) -> (i64, io.E
 /*
 Writes the remaining content of the Reader's string into the provided io.Writer
 
-Inputs:
+**Inputs**
 - r: A pointer to a Reader struct
 - w: The io.Writer to write the remaining content into
 
 WARNING: Panics if writer writes more bytes than remainig length of string.
 
-Returns:
+**Returns**
 - n: The number of bytes written
 - err: An io.Error if an error occurs while writing (.Short_Write)
 */