Alter example doc syntax, more list docs

Author: lpil

src/gleam/atom.gleam

@@ -28,10 +28,12 @@ pub type FromStringError {
 ///
 /// ## Examples
 ///
-/// ```
-/// from_string("ok") == Ok(create_from_string("ok"))
-/// from_string("some_new_atom") == Error(AtomNotLoaded)
-/// ```
+///    > from_string("ok")
+///    Ok(create_from_string("ok"))
+///
+///    > from_string("some_new_atom")
+///    Error(AtomNotLoaded)
+///
 ///
 pub external fn from_string(String) -> Result(Atom, FromStringError) =
   "gleam_stdlib" "atom_from_string";
@@ -53,10 +55,9 @@ pub external fn create_from_string(String) -> Atom =
 ///
 /// ## Examples
 ///
-/// ```
-/// let ok_atom = create_from_string("ok")
-/// to_string(ok_atom) == "ok"
-/// ```
+///    > let ok_atom = create_from_string("ok")
+///    > to_string(ok_atom)
+///    "ok"
 ///
 pub external fn to_string(Atom) -> String =
   "gleam_stdlib" "atom_to_string";

src/gleam/bool.gleam

@@ -14,9 +14,9 @@ pub type Bool =
 /// Returns the opposite Bool value
 ///
 /// ## Examples
-/// ```gleam
-/// negate(True) == False
-/// ```
+///    > negate(True)
+///    False
+///
 ///
 pub fn negate(bool: Bool) -> Bool {
   case bool {
@@ -28,10 +28,10 @@ pub fn negate(bool: Bool) -> Bool {
 /// Compares two bools and returns the first values Order to the second.
 ///
 /// ## Examples
-/// ```gleam
 /// import gleam/order
-/// compare(True, False) == order.Gt
-/// ```
+///    > compare(True, False)
+///    order.Gt
+///
 ///
 pub fn compare(a: Bool, b: Bool) -> Order {
   case a, b {
@@ -45,11 +45,15 @@ pub fn compare(a: Bool, b: Bool) -> Order {
 /// Returns `True` if either Bool value is `True`.
 ///
 /// ## Examples
-/// ```gleam
-/// max(True, False) == True
-/// max(False, True) === True
-/// max(False, False) === False
-/// ```
+///    > max(True, False)
+///    True
+///
+///    > max(False, True)
+///    True
+///
+///    > max(False, False)
+///    False
+///
 ///
 pub fn max(a: Bool, b: Bool) -> Bool {
   case a {
@@ -61,11 +65,15 @@ pub fn max(a: Bool, b: Bool) -> Bool {
 /// Returns `False` if either Bool value is `False`.
 ///
 /// ## Examples
-/// ```gleam
-/// max(True, False) == False
-/// max(False, True) === False
-/// max(False, False) === False
-/// ```
+///    > max(True, False)
+///    False
+///
+///    > max(False, True)
+///    False
+///
+///    > max(False, False)
+///    False
+///
 ///
 pub fn min(a: Bool, b: Bool) -> Bool {
   case a {
@@ -77,10 +85,12 @@ pub fn min(a: Bool, b: Bool) -> Bool {
 /// Returns a numeric representation of the value:
 ///
 /// ## Examples
-/// ```gleam
-/// to_int(True) == 1
-/// to_int(False) == 0
-/// ```
+///    > to_int(True)
+///    1
+///
+///    > to_int(False)
+///    0
+///
 ///
 pub fn to_int(bool: Bool) -> Int {
   case bool {

src/gleam/dynamic.gleam

@@ -21,63 +21,75 @@ pub external fn unsafe_coerce(a) -> b = "gleam_stdlib" "identity";
 /// Safely cast a Dynamic value into a String.
 ///
 /// ## Examples
-/// ```gleam
-/// string(from("Hello")) == Ok("Hello")
-/// string(from(123)) == Error("Expected a String, got `123`")
-/// ```
+///    > string(from("Hello"))
+///    Ok("Hello")
+///
+///    > string(from(123))
+///    Error("Expected a String, got `123`")
+///
 pub external fn string(from: Dynamic) -> Result(String, String)
   = "gleam_stdlib" "decode_string"
 
 /// Safely cast a Dynamic value into a String.
 ///
 /// ## Examples
-/// ```gleam
-/// int(from(123)) == Ok(123)
-/// int(from("Hello")) == Error("Expected an Int, got `\"Hello World\"`")
-/// ```
+///    > int(from(123))
+///    Ok(123)
+///
+///    > int(from("Hello"))
+///    Error("Expected an Int, got `\"Hello World\"`")
+///
 pub external fn int(from: Dynamic) -> Result(Int, String)
   = "gleam_stdlib" "decode_int"
 
 /// Safely cast a Dynamic value into a Float.
 ///
 /// ## Examples
-/// ```gleam
-/// float(from(2.0)) == Ok(2.0)
-/// float(from(123)) == Error("Expected a Float, got `123`")
-/// ```
+///    > float(from(2.0))
+///    Ok(2.0)
+///
+///    > float(from(123))
+///    Error("Expected a Float, got `123`")
+///
 pub external fn float(from: Dynamic) -> Result(Float, String)
   = "gleam_stdlib" "decode_float"
 
 /// Safely cast a Dynamic value into an Atom.
 ///
 /// ## Examples
-/// ```gleam
 /// import gleam/atom
-/// atom(from(atom.create_from_string("hello"))) == OK("hello")
-/// atom(from(123)) == Error("Expected an Atom, got `123`")
-/// ```
+///    > atom(from(atom.create_from_string("hello")))
+///    OK("hello")
+///
+///    > atom(from(123))
+///    Error("Expected an Atom, got `123`")
+///
 pub external fn atom(from: Dynamic) -> Result(atom.Atom, String)
   = "gleam_stdlib" "decode_atom"
 
 /// Safely cast a Dynamic value into a Bool.
 ///
 /// ## Examples
-/// ```gleam
-/// bool(from(True)) == Ok(True)
-/// bool(from(123)) == Error("Expected a Bool, got `123`")
-/// ```
+///    > bool(from(True))
+///    Ok(True)
+///
+///    > bool(from(123))
+///    Error("Expected a Bool, got `123`")
+///
 pub external fn bool(from: Dynamic) -> Result(Bool, String)
   = "gleam_stdlib" "decode_bool"
 
 /// Safely cast a Dynamic value into a String.
 ///
 /// ## Examples
-/// ```gleam
 /// import gleam/result
 /// let f = fn() { 1 }
-/// thunk(from(f)) |> result.is_ok == True
-/// thunk(from(123)) == Error("Expected a zero arity function, got `123`")
-/// ```
+///    > thunk(from(f)) |> result.is_ok
+///    True
+///
+///    > thunk(from(123))
+///    Error("Expected a zero arity function, got `123`")
+///
 pub external fn thunk(from: Dynamic) -> Result(fn() -> Dynamic, String)
   = "gleam_stdlib" "decode_thunk"
 
@@ -87,10 +99,12 @@ external fn list_dynamic(from: Dynamic) -> Result(List(Dynamic), String)
 /// Safely cast a Dynamic value into a List of some type.
 ///
 /// ## Examples
-/// ```gleam
-/// list(from(["a", "b", "c"]), string) == Ok(["a", "b", "c"])
-/// list(from([1, 2, 3]), string) == Error("Expected a List, got `[1, 2, 3]`")
-/// ```
+///    > list(from(["a", "b", "c"]), string)
+///    Ok(["a", "b", "c"])
+///
+///    > list(from([1, 2, 3]), string)
+///    Error("Expected a List, got `[1, 2, 3]`")
+///
 pub fn list(
   from dynamic: Dynamic,
   containing decoder_type: fn(Dynamic) -> Result(inner, String),
@@ -104,20 +118,24 @@ pub fn list(
 /// This will not succeed on a record.
 ///
 /// ## Examples
-/// ```gleam
 /// import gleam/map
-/// field(from(map.new("Hello", "World")), "Hello") == Ok(Dynamic)
-/// field(from(123)) == Error("Expected a map with key `\"Hello\"`, got `123`")
-/// ```
+///    > field(from(map.new("Hello", "World")), "Hello")
+///    Ok(Dynamic)
+///
+///    > field(from(123))
+///    Error("Expected a map with key `\"Hello\"`, got `123`")
+///
 pub external fn field(from: Dynamic, named: a) -> Result(Dynamic, String)
   = "gleam_stdlib" "decode_field"
 
 /// Returns an element of a Dynamic value representing a tuple if it exists.
 ///
 /// ## Examples
-/// ```gleam
-/// element(from(tuple(1, 2)), 0) == Ok(Dynamic)
-/// element(from(tuple(1, 2)), 2) == Error("Element position is out-of-bounds")
-/// ```
+///    > element(from(tuple(1, 2)), 0)
+///    Ok(Dynamic)
+///
+///    > element(from(tuple(1, 2)), 2)
+///    Error("Element position is out-of-bounds")
+///
 pub external fn element(from: Dynamic, position: Int) -> Result(Dynamic, String)
   = "gleam_stdlib" "decode_element"

src/gleam/float.gleam

@@ -8,10 +8,12 @@ pub type Float =
 /// Attempts to parse the String as a Float if possible
 ///
 /// ## Examples
-/// ```gleam
-/// parse("2.3") == Some(2.3)
-/// parse("ABC") == None
-/// ```
+///    > parse("2.3")
+///    Some(2.3)
+///
+///    > parse("ABC")
+///    None
+///
 ///
 pub external fn parse(String) -> Option(Float)
   = "gleam_stdlib" "parse_float";
@@ -20,9 +22,9 @@ pub external fn parse(String) -> Option(Float)
 /// `Float` value
 ///
 /// ## Examples
-/// ```gleam
-/// to_string(2.3) == "2.3"
-/// ```
+///    > to_string(2.3)
+///    "2.3"
+///
 ///
 pub fn to_string(f: Float) -> String {
   f
@@ -34,9 +36,9 @@ pub fn to_string(f: Float) -> String {
 /// Compares two `Floats`, returning an `Order`
 ///
 /// ## Examples
-/// ```gleam
-/// compare(2.0, 2.3) == Lt
-/// ```
+///    > compare(2.0, 2.3)
+///    Lt
+///
 ///
 pub fn compare(a: Float, b: Float) -> Order {
   case a == b {
@@ -52,9 +54,9 @@ pub fn compare(a: Float, b: Float) -> Order {
 /// Compares two `Floats`, returning the smaller of the two
 ///
 /// ## Examples
-/// ```gleam
-/// min(2.0, 2.3) == 2.0
-/// ```
+///    > min(2.0, 2.3)
+///    2.0
+///
 ///
 pub fn min(a: Float, b: Float) -> Float {
   case a <. b {
@@ -66,9 +68,9 @@ pub fn min(a: Float, b: Float) -> Float {
 /// Compares two `Floats`, returning the larger of the two
 ///
 /// ## Examples
-/// ```gleam
-/// max(2.0, 2.3) == 2.3
-/// ```
+///    > max(2.0, 2.3)
+///    2.3
+///
 ///
 pub fn max(a: Float, b: Float) -> Float {
   case a >. b {
@@ -80,36 +82,38 @@ pub fn max(a: Float, b: Float) -> Float {
 /// Rounds the value to the next highest whole number as a Float
 ///
 /// ## Examples
-/// ```gleam
-/// ceiling(2.3) == 3.0
-/// ```
+///    > ceiling(2.3)
+///    3.0
+///
 ///
 pub external fn ceiling(Float) -> Float = "math" "ceil";
 
 /// Rounds the value to the next lowest whole number as a Float
 ///
 /// ## Examples
-/// ```gleam
-/// floor(2.3) == 2.0
-/// ```
+///    > floor(2.3)
+///    2.0
+///
 ///
 pub external fn floor(Float) -> Float = "math" "floor";
 
 /// Rounds the value to the nearest whole number as an Int
 ///
 /// ## Examples
-/// ```gleam
-/// round(2.3) == 2
-/// round(2.5) == 3
-/// ```
+///    > round(2.3)
+///    2
+///
+///    > round(2.5)
+///    3
+///
 ///
 pub external fn round(Float) -> Int = "erlang" "round";
 
 /// Returns the value as an Int, truncating all decimal digits.
 ///
 /// ## Examples
-/// ```gleam
-/// truncate(2.4343434847383438) == 2
-/// ```
+///    > truncate(2.4343434847383438)
+///    2
+///
 ///
 pub external fn truncate(Float) -> Int = "erlang" "trunc";