Record.Studio

class Keys :: Row Type -> Constraintclass Keys (r :: Row Type)  where

Members

• keys :: (Proxy r) -> Array String

Instances

• (RowToList r rl, KeysRL rl) => Keys r

recordKeys :: forall r. Keys r => Record r -> Array String

data MapRecord a b

Constructors

• MapRecord (a -> b)

Instances

• (IsSymbol sym, Lacks sym rb, Cons sym b rb rc) => FoldingWithIndex (MapRecord a b) (Proxy sym) (Builder (Record ra) (Record rb)) a (Builder (Record ra) (Record rc))
• (IsSymbol sym, Lacks sym rb, RowToList x xRL, Cons sym (Record y) rb rc, FoldlRecord (MapRecord a b) (Builder (Record ()) (Record ())) xRL x (Builder (Record ()) (Record y))) => FoldingWithIndex (MapRecord a b) (Proxy sym) (Builder (Record ra) (Record rb)) (Record x) (Builder (Record ra) (Record rc))
• (IsSymbol sym, Lacks sym rb, Cons sym x rb rc) => FoldingWithIndex (MapRecord a b) (Proxy sym) (Builder (Record ra) (Record rb)) x (Builder (Record ra) (Record rc))

mapRecord :: forall a b rin rout. HFoldlWithIndex (MapRecord a b) (Builder (Record ()) (Record ())) (Record rin) (Builder (Record ()) (Record rout)) => (a -> b) -> Record rin -> Record rout

Recursively maps a record using a function f.

let
  f :: Int -> String
  f i = show (i + 1)
mapRecord  f { a : { b : 10, c : { d: 20, e : Just "hello" }}, f : 30 }
-- { a : { b : "11", c : { d: "21", e : Just "hello" }, f : "31" }

data MapRecordKind :: forall k. (k -> Type) -> (k -> Type) -> Typedata MapRecordKind f g

Constructors

• MapRecordKind (f ~> g)

Instances

• (IsSymbol sym, Lacks sym rb, Cons sym (g a) rb rc) => FoldingWithIndex (MapRecordKind f g) (Proxy sym) (Builder (Record ra) (Record rb)) (f a) (Builder (Record ra) (Record rc))
• (IsSymbol sym, Lacks sym rb, RowToList x xRL, Cons sym (Record y) rb rc, FoldlRecord (MapRecordKind f g) (Builder (Record ()) (Record ())) xRL x (Builder (Record ()) (Record y))) => FoldingWithIndex (MapRecordKind f g) (Proxy sym) (Builder (Record ra) (Record rb)) (Record x) (Builder (Record ra) (Record rc))
• (IsSymbol sym, Lacks sym rb, Cons sym x rb rc) => FoldingWithIndex (MapRecordKind f g) (Proxy sym) (Builder (Record ra) (Record rb)) x (Builder (Record ra) (Record rc))

mapRecordKind :: forall f g rin rout. HFoldlWithIndex (MapRecordKind f g) (Builder (Record ()) (Record ())) (Record rin) (Builder (Record ()) (Record rout)) => (f ~> g) -> Record rin -> Record rout

Recursively mapK a record using a natural transformation. E.g.

let
  nt :: Either String ~> Maybe
  nt = hush
mapRecordKind { a : { b : { c : { d: Right 10, e : Left "hello" }, f : Right true }
-- Just { a : { b : { c : { d: Just 10, e : Nothing }, f : Just true }

mergeFlipped :: forall r1 r2 r3 r4. Union r1 r2 r3 => Nub r3 r4 => Record r2 -> Record r1 -> Record r4

Like merge but with its arguments flipped. I.e. merges two records with the seconds record's labels taking precedence in the case of overlaps.

For example:

mergeFlipped { x: 1, y: "y" } { y: 2, z: true }
 = { x: 1, y: 2, z: true }

Operator alias for Record.Studio.Merge.mergeFlipped (right-associative / precedence 1)

record1 // record2 is equivalent to JS's { ...record1, ...record2 }

class SameKeys :: Row Type -> Row Type -> Constraintclass SameKeys (r1 :: Row Type) (r2 :: Row Type) 

Instances

• (RowToList r1 rl1, RowToList r2 rl2, SameKeysRL rl1 rl2) => SameKeys r1 r2

data SequenceRecord :: (Type -> Type) -> Typedata SequenceRecord (f :: Type -> Type)

Constructors

• SequenceRecord

Instances

• (Applicative f, IsSymbol sym, Lacks sym rb, Cons sym a rb rc) => FoldingWithIndex (SequenceRecord f) (Proxy sym) (f (Builder (Record ra) (Record rb))) (f a) (f (Builder (Record ra) (Record rc)))
• (Applicative f, IsSymbol sym, Lacks sym rb, RowToList x xRL, Cons sym (Record y) rb rc, FoldlRecord (SequenceRecord f) (f (Builder (Record ()) (Record ()))) xRL x (f (Builder (Record ()) (Record y)))) => FoldingWithIndex (SequenceRecord f) (Proxy sym) (f (Builder (Record ra) (Record rb))) (Record x) (f (Builder (Record ra) (Record rc)))
• (Applicative f, IsSymbol sym, Lacks sym rb, Cons sym x rb rc) => FoldingWithIndex (SequenceRecord f) (Proxy sym) (f (Builder (Record ra) (Record rb))) x (f (Builder (Record ra) (Record rc)))

sequenceRecord :: forall f rin rout. Applicative f => HFoldlWithIndex (SequenceRecord f) (f (Builder (Record ()) (Record ()))) (Record rin) (f (Builder (Record ()) (Record rout))) => Record rin -> f (Record rout)

Recursively sequence a record. E.g.

sequenceRecord { a : { b : { c : { d: Just 10, e : Just "hello" }, f : Just true }
-- Just { a : { b : { c : { d: 10, e : "hello" }, f : true }

shrink :: forall a b r. Union b r a => Keys b => Record a -> Record b