The get function takes:

• An accessor,
• A datastructure with type super and returns the value accessed by that combinator.

get (foo << bar) myRecord 

The set function takes:

• An accessor,
• A value of the type sub,
• A datastructure with type super and it returns the data structure, with the accessible field changed to be the set value.

set (foo << bar) "Hi!" myRecord

The over function takes:

• An accessor,
• A function (sub -> sub),
• A datastructure with type super and it returns the data structure, with the accessible field changed by applying the function to the existing value.

over (foo << qux) (+1) myRecord

This function lets you build an accessor for containers that have a 1:1 relation with what they contain, such as a record and one of its fields:

foo : Relation field sub wrap -> Relation {rec | foo : field} sub wrap
foo =
  makeOneToOne
    .foo
    \change rec -> {rec | foo = change rec.foo }

This function lets you build an accessor for containers that have a 1:N relation with what they contain, such as List (0-N cardinality) or Maybe (0-1). E.g.:

onEach : Relation elem sub wrap -> Relation (List elem) sub (List wrap)
onEach =
  makeOneToN
    List.map
    List.map

n.b. implementing those is usually considerably simpler than the type suggests.

A Relation super sub wrap is a type describing how to interact with a sub data when given a super data.

The wrap exists because some types can't ensure that get will return a sub. For instance, Maybe sub may not actually contain a sub. Therefore, get returns a wrap which, in that example, will be Maybe sub

Implementation: A relation is a banal record storing a get function and an over function.