Scala, Java, Unix, MacOS tutorials (page 142)

As a brief note, here’s some Scala source code that shows how to write a fold left (foldLeft) function using recursion:

After yesterday’s Scala nested Option + flatMap/for example, here’s another example of plowing through nested Options with flatMap. First, start with some nested options:

val o1 = Option(1)
val oo1 = Option(o1)
val ooo1 = Option(oo1)

Here are those same three lines, with the data type for each instance shown in the comments:

val o1 = Option(1)       // Option[Int]
val oo1 = Option(o1)     // Option[Option[Int]]
val ooo1 = Option(oo1)   // Option[Option[Option[Int]]]

With this setup, just like yesterday, I can dig my way through the Options to get to the enclosed value using flatMap calls:

ooo1 flatMap { oo1 =>
    oo1 flatMap { o1 =>
        o1
    }
}

Here’s what that code looks like in the Scala REPL:

scala> val o1 = Option(1)
o1: Option[Int] = Some(1)

scala> val oo1 = Option(o1)
oo1: Option[Option[Int]] = Some(Some(1))

scala> val ooo1 = Option(oo1)
ooo1: Option[Option[Option[Int]]] = Some(Some(Some(1)))

scala> ooo1 flatMap { oo1 =>
     |     oo1 flatMap { o1 =>
     |         o1
     |     }
     | }
res0: Option[Int] = Some(1)

As that shows, the final result of the flatMap calls is an Option[Int], specifically a Some(1).

Just like yesterday, you can also use for-expressions to get to the enclosed value, but for today I just wanted to show this as another flatMap example.

I’ll keep trying to make monads, flatMap, and for-expressions as easy as I can, but for now I hope that’s a simple example you can experiment. (At least the setup portion of it is simple.)

Here’s a little fun with Scala functions, including the use of andThen and compose:

scala> val add1 = (i: Int) => i + 1
add1: Int => Int = <function1>

scala> val double = (i: Int) => i * 2
double: Int => Int = <function1>

scala> val addThenDouble = add1 andThen double
addThenDouble: Int => Int = <function1>

scala> addThenDouble(1)
res0: Int = 4

scala> val doubleThenAdd = add1 compose double
doubleThenAdd: Int => Int = <function1>

scala> doubleThenAdd(1)
res1: Int = 3

(Inspired by the book, Functional and Reactive Domain Modeling, and my own book, Learning Functional Programming in Scala.)

As a note to self, I used code like this in a Scala + JavaFX application to add a ContextMenu to a TableView:

defaddContextMenuToTableView(
    tableView: TableView[Note],
    tableViewContextMenu: ContextMenu,
    addNoteMenuItem: MenuItem,
    deleteNoteMenuItem: MenuItem,
) = {
    tableViewContextMenu.getItems().add(addNoteMenuItem)
    tableViewContextMenu.getItems().add(deleteNoteMenuItem)
    tableView.addEventHandler(MouseEvent.MOUSE_CLICKED, new EventHandler[MouseEvent]() {
        override def handle(mouseEvent: MouseEvent): Unit = {
            if (mouseEvent.getButton == MouseButton.SECONDARY) {
                tableViewContextMenu.show(tableView, mouseEvent.getScreenX, mouseEvent.getScreenY)
            }
        }
    })
}

There wasn’t anything special about the buttons, they were regular JavaFX Buttons:

val addNoteButton = new Button("add note")
val deleteNoteButton = new Button("delete note")

I did this in my Notes application, but later decided not to use a popup menu for this purpose.