Pick/Select fields by name

Issues a warning when a key is not in the input Type

 > data A = A { a :: Int, b :: Int }
 > pick ["a", "c"] <:> toType ''A

 data _ = { a :: Int }

Remove fields by name

Issues a warning when a key is not in the input Type

 > data A = A { a :: Int, b :: Int }
 > omit ["b", "c"] <:> toType ''A

 data _ = { a :: Int }

Creates a type from a list of keys and a ToFieldType

Issues a log if some keys are duplicated

 > record ["a", "b"] [t|Int|]

 data _ = { a :: Int, b :: Int }

Keep the fields present in both types

If keys overlap, prefer the type of the left type

 > data A = A { a :: Int, b :: Int }
 > data B = B { b :: String, c :: Void }
 > intersection <:> toType ''A  : toType ''B

 data _ = { b :: Int }

Keep the fields present in both types

If keys overlap, prefer the type of the right type

 > data A = A { a :: Int, b :: Int }
 > data B = B { b :: String, c :: Void }
 > intersection' <:> toType ''A  : toType ''B

 data _ = { b :: String }

Merge two types together

If keys overlap, prefer the type of the left type

 > data A = A { a :: Int, b :: Int }
 > data B = B { b :: String, c :: Void }
 > union <:> toType ''A  : toType ''B

 data _ = { a :: Int, b :: Int, c :: Void }

Merge two types together

If keys overlap, prefer the type of the right type

 > data A = A { a :: Int, b :: Int }
 > data B = B { b :: String, c :: Void }
 > union <:> toType ''A  : toType ''B

 data _ = { a :: Int, b :: String, c :: Void }

Mark fields are required

 > data A = A { a :: Maybe Int, b :: Int }
 > require ["a"] <:> toType ''A

 data _ = { a :: Int, b :: Int }

Marks all fields as Maybe

Fields that already have a Maybe type will not be changed.

 > data A = A { a :: Int, b :: Maybe Int }
 > partial <:> toType ''A

 data _ = { a :: Maybe Int, b :: Maybe Int }

Similar to partial. Marks all fields as Maybe

Fields that already have a Maybe type will be wrapped in a Maybe

 > data A = A { a :: Int, b :: Maybe Int }
 > partial' <:> toType ''A

 data _ = { a :: Maybe Int, b :: Maybe (Maybe Int) }

Replaces the first type parameter with the given type

Issues a warning if there are no type variable

 data A x = { a :: Maybe x }

 > apply [t|Int|] <:> toType ''A

 data _ = { a :: Maybe Int }

Applies multiple type arguments

Issues a warning if too many arguments are given

 data A a b = { a :: Maybe a, b :: b }

 > applyMany ([t|Int|], [t|String|]) <:> toType ''A

 data _ = { a :: Maybe Int, b :: String }

Variant of intersection where user can decide which value to keep (the left object's or the right's) in case of overlap

Variant of union where user can decide which value to keep (the left object's or the right's) in case of overlap

Selector for functions like intersectionWithSelector

Get the names of the fields in in type

 > data A = A { a :: Int, b :: Int }
 > keysOf <:> toType ''A

 ["a", "b"]