Наприклад, ви можете оголосити, що щось може бути `str` або `None`:

```python
from typing import Union


def say_hi(name: Union[str, None]):
        print(f"Hi {name}!")
```

У `typing` також є скорочення, щоб оголосити, що щось може бути `None`, - `Optional`.

Ось порада з моєї дуже «суб'єктивної» точки зору:

- 🚨 Уникайте використання `Optional[SomeType]`

	lex, err := sqlLexer.Lex(s)
	if err != nil {
		t.Fatal(err)
	}
	tokens, err := lexer.ConsumeAll(lex)
	if err != nil {
		t.Fatal(err)
	}
	// for i, t := range tokens {
	// 	fmt.Printf("%d: %#v\n", i, t)
	// }
	if len(tokens) != 7 {
		t.Fatalf("Expected 7 got %d", len(tokens))
	}
}

func TestSelectWhere(t *testing.T) {
	p := participle.MustBuild(
		&Select{},

Por ejemplo, podrías declarar que algo podría ser un `str` o `None`:

```python
from typing import Union


def say_hi(name: Union[str, None]):
        print(f"Hi {name}!")
```

`typing` también tiene un atajo para declarar que algo podría ser `None`, con `Optional`.

Aquí va un Consejo desde mi punto de vista muy subjetivo:

* 🚨 Evita usar `Optional[SomeType]`

For example, you could declare that something could be a `str` or `None`:

```python
from typing import Union


def say_hi(name: Union[str, None]):
        print(f"Hi {name}!")
```

`typing` also has a shortcut to declare that something could be `None`, with `Optional`.

Here's a tip from my very **subjective** point of view:

* 🚨 Avoid using `Optional[SomeType]`

            f"({len(block_a['content'])} vs {len(block_b['content'])})"
        )

    block_language = block_a["lang"].lower()
    if block_language in {"mermaid"}:
        if block_a != block_b:
            print(
                f"Skipping mermaid code block replacement (lines {start_line}-{end_line_no}). "
                "This should be checked manually."
            )

	listener = &httpListener{
		listeners:   listeners,
		acceptCh:    make(chan acceptResult, len(listeners)),
		opts:        opts,
		ctxDoneCh:   ctx.Done(),
		ctxCanceler: cancel,
	}
	opts.Trace(fmt.Sprintf("opening %d listeners", len(listener.listeners)))
	listener.start()

	return listener, listenErrs

# Code blocks { #code-blocks }

Some text

```python
# This is a sample Python code block
def hello_world():
    # Comment with indentation
    print("Hello, world!")  # Print greeting
```

Some more text

Missing code block...

And more text

```console
// Use the command "live" and pass the language code as a CLI argument
$ python ./scripts/docs.py live es

				tc.ResponseRecorder.LogErrBody = true
			}

			defer logger.AuditLog(r.Context(), w, r, mustGetClaimsFromToken(r))
			invalidReq := errorCodes.ToAPIErr(ErrInvalidRequest)
			invalidReq.Description = fmt.Sprintf("%s (%s)", invalidReq.Description, err)
			writeErrorResponse(r.Context(), w, invalidReq, r.URL)
			atomic.AddUint64(&globalHTTPStats.rejectedRequestsInvalid, 1)
			return
		}

# Code blocks { #code-blocks }

Some text

```python
# This is a sample Python code block
def hello_world():
    # Comment with indentation
    print("Hello, world!")  # Print greeting
```

Some more text

```toml
# Extra line
# This is a sample TOML code block
title = "TOML Example"  # Title of the document
```

And more text

```console
// Use the command "live" and pass the language code as a CLI argument

		b := BoolFlag(true)
		if s == "" {
			// Empty string is treated as valid.
			*bf = b
		} else if b, err = ParseBoolFlag(s); err == nil {
			*bf = b
		}
	}

	return err
}

// FormatBool prints stringified version of boolean.
func FormatBool(b bool) string {
	if b {
		return "on"
	}
	return "off"
}

// ParseBool returns the boolean value represented by the string.