# A complete Dotty (Scala 3) “given” example

I’ll write more about Scala/Dotty givens in future blog posts, but for today, here’s a complete Dotty given/using example, which compiles with Dotty 0.24 in May, 2020:

```/**
* source code from these two links, updated to the dotty 0.24
* syntax in may, 2020:
* https://dotty.epfl.ch/docs/reference/contextual/givens.html
* https://stackoverflow.com/questions/59456843/how-to-use-given-in-dotty
*/
trait Ord[T]:
def compare(x: T, y: T): Int
def (x: T) < (y: T) = compare(x, y) < 0
def (x: T) > (y: T) = compare(x, y) > 0

given intOrd as Ord[Int]:
def compare(x: Int, y: Int) =
if (x < y) -1 else if (x > y) +1 else 0

given listOrd[T](using ord: Ord[T]) as Ord[List[T]]:
def compare(xs: List[T], ys: List[T]): Int = (xs, ys) match
case (Nil, Nil) => 0
case (Nil, _) => -1
case (_, Nil) => +1
case (x :: xs1, y :: ys1) =>
val fst = ord.compare(x, y)
if (fst != 0) fst else compare(xs1, ys1)

def whichIsBigger[T](x: T, y: T)(using ord: Ord[T]): String =
ord.compare(x, y) match
case -1 => s"\$x is less than \$y"
case 0  => s"\$x and \$y are equal"
case 1  => s"\$x is greater than \$y"

@main def main =
println(whichIsBigger(2, 1))```

As noted in the comments, the source code comes from the two links shown. All I did was update the `whichIsBigger` function to use `using` instead of `given`, and then I converted all of the code to use the Scala 3 (Dotty) significant indentation syntax, which I prefer.

## Dotty extension methods

Also, if this code looks unusual:

`def (x: T) > (y: T) = compare(x, y) > 0`

It may help to know that it is a Dotty/Scala 3 extension method. It’s the Dotty way to declare that you’re adding `>` as a method to the `T` data type.

As a point of comparison, a few months ago I wrote this Dotty extension method:

`def (s: String) makeInt(radix: Int): Int = Integer.parseInt(s, radix)`

If you look at the two methods next to each other you’ll see that they are declared the same way:

```def (x: T)      >      (y: T)            = compare(x, y) > 0
• The method name `>` compared to the name `makeInt`
• The `>` method doesn’t have its return type declared
In summary, if you wanted to see a Dotty `given`/`using` example, along with a Dotty extension method, I hope this is helpful.