Fresnel 0.0.5

Fresnel

Fresnel is an optics library for F#

Why Optics?

Optics make it easier to perform deeply nested get, set and modify operations on immutable data-structures. In a sense, they are the functional programming equivalent of getters and setters.

If you have ever found yourself doing something like this, then optics may help!

Move the rigid body with ID 1 by 10 units in the X direction

{
  world with
    Bodies =
      world.Bodies
      |> Map.change
        1
        (function
        | Some rigidBody ->
          {
            rigidBody with
              RigidBody.Bounds.Center.X = rigidBody.Bounds.Center.X + 10
          }
          |> Some
        | None -> None)
}

With optics:

world
|> World.bodies_ +-> Map.item_ 1 +-> RigidBody.bounds_ +-> Bounds.center_ +-> Point.x_ ^% fun x -> x + 10

Why Not Optics?

In order to work, the example above needs optics definitions for the types we are working with:

[<RequireQualifiedAccess>]
module World =

  let bodies_ : Lens<World, Map<int, RigidBody>> =
    {
      Get = fun x -> x.Bodies
      Set = fun v x -> { x with Bodies = v }
    }

[<RequireQualifiedAccess>]
module Point =

  let x_ : Lens<Point, int> =
    {
      Get = fun p -> p.X
      Set = fun x p -> { p with X = x }
    }

  let y_ : Lens<Point, int> =
    {
      Get = fun p -> p.Y
      Set = fun y p -> { p with Y = y }
    }

[<RequireQualifiedAccess>]
module Bounds =

  let center_ : Lens<Bounds, Point> =
    {
      Get = fun x -> x.Center
      Set = fun v x -> { x with Center = v }
    }

  let radius_ : Lens<Bounds, int> =
    {
      Get = fun x -> x.Radius
      Set = fun v x -> { x with Radius = v }
    }

[<RequireQualifiedAccess>]
module RigidBody =

  let bounds_ : Lens<RigidBody, Bounds> =
    {
      Get = fun x -> x.Bounds
      Set = fun v x -> { x with Bounds = v }
    }

Writing these is a mechanical exercise, and indeed it can be automated using a Myriad plugin. However, this is always more work than nothing; the balance of effort will depend on how much structure manipulation is needed.

Also consider the learning curve of a new set of terms and operators; teams will need to grok ^., ^=, ^% and +->. As with all abstractions, there is a conceptual overhead to optics.

Reach for optics when the standard approach is starting to creak!

Usage

Conventions

• Optics for a type are grouped into a module with the same name as the type
• Each optic is named after either it's record field name or DU case name with a _ suffix

For example:

type Circle =
  {
    Radius : int
  }

module Circle =

  let radius_ : Lens<Circle, int> =
    {
      Get = fun x -> x.Radius
      Set = fun v x -> { x with Radius = v }
    }

Design

Operators

The operators were chosen to minimize the number of parentheses required for common usages.

For example:

circle
|> Circle.center_ +-> Point.x_ ^= 99

Here the optic composition has precedence over the |> or set (^=) and so parentheses are not needed.

Alternatives

Aether

Fresnel is directly inspired by Aether. Aether is mature and stable library; if you are happy with Aether, then you should stick with that!

However, Fresnel aims to improve on Aether in a few respects:

• Optics are polymorphic, allowing data types to be changed through transformations
• Composition of optics uses only one operator, which requires a bit less thinking
• Operator symbols are slightly different, requiring fewer parentheses in common usages
• Parameter order is arguably more intuitive and plays better with |>
• Fable is supported out-of-the-box
• Optional (a.k.a "affine traversal") optic is included
• Traversal optic is included