Add an example usage to the doc

Author: LPTK

docs/docs/reference/new-types/polymorphic-function-types.md

@@ -32,6 +32,51 @@ then take a list of type `List[A]`, and return a list of the same type `List[A]`
 
 [More details](https://github.com/lampepfl/dotty/pull/4672)
 
+
+### Example Usage
+
+Polymorphic function type are particularly useful
+when callers of a method are required to provide a
+function which has to be polymorphic,
+meaning that it should accept arbitrary types as part of its inputs.
+
+For instance, consider the situation where we have
+a data type to represent the expressions of a simple language
+(consisting only of variables and function application)
+in a strongly-typed way:
+
+```scala
+enum Expr[A]:
+  case Var(name: String)
+  case Apply[A, B](fun: Expr[B => A], arg: Expr[B]) extends Expr[A]
+```
+
+We would like to provide a way for users to map a function
+over all immediate subexpressions of a given `Expr`.
+This requires the given function to be polymorphic,
+since each subexpression may have a different type.
+Here is how to implement this using polymorphic function types:
+
+```scala
+def mapSubexpressions[A](e: Expr[A])(f: [B] => Expr[B] => Expr[B]): Expr[A] =
+  e match
+  case Apply(fun, arg) => Apply(f(fun), f(arg))
+  case Var(n) => Var(n)
+```
+
+And here is how to use this function to _wrap_ each subexpression
+in a given expression with a call to some `wrap` function,
+defined as a variable:
+
+```scala
+val e0 = Apply(Var("f"), Var("a"))
+val e1 = mapSubexpressions(e0)(
+  [B] => (se: Expr[B]) => Apply(Var[B => B]("wrap"), se))
+println(e1) // Apply(Apply(Var(wrap),Var(f)),Apply(Var(wrap),Var(a)))
+```
+
+
+
 ### Relationship With Type Lambdas
 
 Polymorphic function types are not to be confused with