Record.ExtraSrghma

class AppendSubrecordImpl :: forall k. k -> Row Type -> Row Type -> Constraintclass AppendSubrecordImpl rl bigger smaller  where

Members

• appendSubrecordImpl :: Record bigger -> Record smaller -> Record bigger

Instances

• AppendSubrecordImpl Nil bigger smaller
• (IsSymbol name, Cons name t trash smaller, Cons name t trash' bigger, Semigroup t, AppendSubrecordImpl tail bigger smaller) => AppendSubrecordImpl (Cons name t tail) bigger smaller

appendRecord :: forall rl bigger smaller. RowToList smaller rl => AppendSubrecordImpl rl bigger smaller => Record bigger -> Record smaller -> Record bigger

class OrdRecord :: forall k. k -> Row Type -> Constraintclass OrdRecord rl row | rl -> row where

Type class to compare two records field by field, following a known ordering of keys (a RowList).

Members

• compareRecordImpl :: Record row -> Record row -> Ordering

Instances

• (IsSymbol name, Ord ty, Cons name ty trash row, OrdRecord tail row) => OrdRecord (Cons name ty tail) row

  Compare two records by the current head field, and recurse on the tail if equal.

• OrdRecord Nil row

  Base case: comparing empty RowList always returns EQ.

compareRecord :: forall row rl. RowToList row rl => OrdRecord rl row => Record row -> Record row -> Ordering

Public interface for comparing two records deterministically by their keys. You must provide a type with an instance of RL.RowToList to determine key ordering.

class FoldlValues :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rowList fieldType) <= FoldlValues (rowList :: RowList Type) (row :: Row Type) fieldType | rowList -> row fieldType where

Members

• foldlValuesImpl :: forall accum. (accum -> fieldType -> accum) -> accum -> Record row -> accum

Instances

• (FoldlValues tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, RowToList row trash, Cons name fieldType tailRow row) => FoldlValues (Cons name fieldType tailRowList) row fieldType
• (Homogeneous row fieldType) => FoldlValues Nil row fieldType

class FoldlValues1 :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rowList fieldType) <= FoldlValues1 (rowList :: RowList Type) (row :: Row Type) fieldType | rowList -> row fieldType where

Members

• foldlValuesImpl1 :: (fieldType -> fieldType -> fieldType) -> Record row -> fieldType

Instances

• (FoldlValues tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, RowToList row trash, Cons name fieldType tailRow row) => FoldlValues1 (Cons name fieldType tailRowList) row fieldType

foldlValues1 :: forall row fieldType rowList. RowToList row rowList => FoldlValues1 rowList row fieldType => (fieldType -> fieldType -> fieldType) -> Record row -> fieldType

foldlValues :: forall accum row fieldType rowList. RowToList row rowList => FoldlValues rowList row fieldType => (accum -> fieldType -> accum) -> accum -> Record row -> accum

foldMapValuesL1 :: forall m row rowList fieldType row' rowList'. RowToList row rowList => RowToList row' rowList' => FoldlValues1 rowList' row' m => MapRecord rowList row fieldType m () row' => Semigroup m => (fieldType -> m) -> Record row -> m

foldMapValuesL :: forall accum row fieldType rowList. RowToList row rowList => FoldlValues rowList row fieldType => Monoid accum => (fieldType -> accum) -> Record row -> accum

class FoldlValuesWithIndex :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rowList fieldType) <= FoldlValuesWithIndex (rowList :: RowList Type) (row :: Row Type) fieldType | rowList -> row fieldType where

Members

• foldlValuesWithIndexImpl :: forall accum. (accum -> String -> fieldType -> accum) -> accum -> Record row -> accum

Instances

• (FoldlValuesWithIndex tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, RowToList row trash, Cons name fieldType tailRow row) => FoldlValuesWithIndex (Cons name fieldType tailRowList) row fieldType
• (Homogeneous row fieldType) => FoldlValuesWithIndex Nil row fieldType

class FoldlValuesWithIndex1 :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rowList fieldType) <= FoldlValuesWithIndex1 (rowList :: RowList Type) (row :: Row Type) fieldType | rowList -> row fieldType where

Members

• foldlValuesWithIndexImpl1 :: (fieldType -> String -> fieldType -> fieldType) -> Record row -> fieldType

Instances

• (FoldlValuesWithIndex tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, RowToList row trash, Cons name fieldType tailRow row) => FoldlValuesWithIndex1 (Cons name fieldType tailRowList) row fieldType

foldlValuesWithIndex1 :: forall row fieldType rowList. RowToList row rowList => FoldlValuesWithIndex1 rowList row fieldType => (fieldType -> String -> fieldType -> fieldType) -> Record row -> fieldType

foldlValuesWithIndex :: forall accum row fieldType rowList. RowToList row rowList => FoldlValuesWithIndex rowList row fieldType => (accum -> String -> fieldType -> accum) -> accum -> Record row -> accum

foldMapValuesWithIndexL1 :: forall fieldType row rowList row' rowList' m. RowToList row rowList => RowToList row' rowList' => FoldlValuesWithIndex1 rowList' row' m => MapValuesWithIndex rowList row fieldType m () row' => Monoid m => (String -> fieldType -> m) -> Record row -> m

foldMapValuesWithIndexL :: forall accum row fieldType rowList. RowToList row rowList => FoldlValuesWithIndex rowList row fieldType => Monoid accum => (String -> fieldType -> accum) -> Record row -> accum

class FoldrValues :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rowList fieldType) <= FoldrValues (rowList :: RowList Type) (row :: Row Type) fieldType | rowList -> row fieldType where

Members

• foldrValuesImpl :: forall accum. (fieldType -> accum -> accum) -> accum -> Record row -> accum

Instances

• (FoldrValues tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, RowToList row trash, Cons name fieldType tailRow row) => FoldrValues (Cons name fieldType tailRowList) row fieldType
• (Homogeneous row fieldType) => FoldrValues Nil row fieldType

class FoldrValues1 :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rowList fieldType) <= FoldrValues1 (rowList :: RowList Type) (row :: Row Type) fieldType | rowList -> row fieldType where

Members

• foldrValuesImpl1 :: (fieldType -> fieldType -> fieldType) -> Record row -> fieldType

Instances

• (FoldrValues tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, RowToList row trash, Cons name fieldType tailRow row) => FoldrValues1 (Cons name fieldType tailRowList) row fieldType

foldrValues1 :: forall row fieldType rowList. RowToList row rowList => FoldrValues1 rowList row fieldType => (fieldType -> fieldType -> fieldType) -> Record row -> fieldType

Fold over the values of a record, applying the function to each field, but no initial accumulator.

foldrValues :: forall accum row fieldType rowList. RowToList row rowList => FoldrValues rowList row fieldType => (fieldType -> accum -> accum) -> accum -> Record row -> accum

foldMapValuesR1 :: forall m row rowList fieldType row' rowList'. RowToList row rowList => RowToList row' rowList' => FoldrValues1 rowList' row' m => MapRecord rowList row fieldType m () row' => Semigroup m => (fieldType -> m) -> Record row -> m

foldMapValuesR :: forall accum row fieldType rowList. RowToList row rowList => FoldrValues rowList row fieldType => Monoid accum => (fieldType -> accum) -> Record row -> accum

class FoldrValuesLazy :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rl fieldType) <= FoldrValuesLazy rl row fieldType | row -> fieldType where

Members

• foldrValuesLazyImpl :: forall accum. Lazy accum => (fieldType -> accum -> accum) -> accum -> Record row -> accum

Instances

• (FoldrValuesLazy tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, RowToList row trash, Cons name fieldType tailRow row) => FoldrValuesLazy (Cons name fieldType tailRowList) row fieldType
• (Homogeneous row fieldType) => FoldrValuesLazy Nil row fieldType

class FoldrValuesLazy1 :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rowList fieldType) <= FoldrValuesLazy1 (rowList :: RowList Type) (row :: Row Type) fieldType | rowList -> row fieldType where

Members

• foldrValuesLazyImpl1 :: (fieldType -> fieldType -> fieldType) -> Record row -> fieldType

Instances

• (FoldrValuesLazy tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, Lazy fieldType, RowToList row trash, Cons name fieldType tailRow row) => FoldrValuesLazy1 (Cons name fieldType tailRowList) row fieldType

foldrValuesLazy1 :: forall row fieldType rowList. RowToList row rowList => Lazy fieldType => FoldrValuesLazy1 rowList row fieldType => (fieldType -> fieldType -> fieldType) -> Record row -> fieldType

Fold over the values of a record, applying the function to each field, but no initial accumulator.

foldrValuesLazy :: forall accum row fieldType rowList. Lazy accum => RowToList row rowList => FoldrValuesLazy rowList row fieldType => (fieldType -> accum -> accum) -> accum -> Record row -> accum

foldMapValuesLazyR1 :: forall m row rowList fieldType row' rowList'. RowToList row rowList => RowToList row' rowList' => Lazy m => FoldrValuesLazy1 rowList' row' m => MapRecord rowList row fieldType m () row' => Semigroup m => (fieldType -> m) -> Record row -> m

foldMapValuesLazyR :: forall accum row fieldType rowList. Lazy accum => RowToList row rowList => FoldrValuesLazy rowList row fieldType => Monoid accum => (fieldType -> accum) -> Record row -> accum

class FoldrValuesWithIndex :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rowList fieldType) <= FoldrValuesWithIndex (rowList :: RowList Type) (row :: Row Type) fieldType | rowList -> row fieldType where

Members

• foldrValuesWithIndexImpl :: forall accum. (String -> fieldType -> accum -> accum) -> accum -> Record row -> accum

Instances

• (FoldrValuesWithIndex tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, RowToList row trash, Cons name fieldType tailRow row) => FoldrValuesWithIndex (Cons name fieldType tailRowList) row fieldType
• (Homogeneous row fieldType) => FoldrValuesWithIndex Nil row fieldType

class FoldrValuesWithIndex1 :: RowList Type -> Row Type -> Type -> Constraintclass (Homogeneous row fieldType, HomogeneousRowList rowList fieldType) <= FoldrValuesWithIndex1 (rowList :: RowList Type) (row :: Row Type) fieldType | rowList -> row fieldType where

Members

• foldrValuesWithIndexImpl1 :: (String -> fieldType -> fieldType -> fieldType) -> Record row -> fieldType

Instances

• (FoldrValuesWithIndex tailRowList row fieldType, Homogeneous tailRow fieldType, HomogeneousRowList tailRowList fieldType, HomogeneousRowList trash fieldType, IsSymbol name, RowToList row trash, Cons name fieldType tailRow row) => FoldrValuesWithIndex1 (Cons name fieldType tailRowList) row fieldType

foldrValuesWithIndex1 :: forall row fieldType rowList. RowToList row rowList => FoldrValuesWithIndex1 rowList row fieldType => (String -> fieldType -> fieldType -> fieldType) -> Record row -> fieldType

foldrValuesWithIndex :: forall accum row fieldType rowList. RowToList row rowList => FoldrValuesWithIndex rowList row fieldType => (String -> fieldType -> accum -> accum) -> accum -> Record row -> accum

foldMapValuesWithIndexR1 :: forall fieldType row rowList row' rowList' m. RowToList row rowList => RowToList row' rowList' => FoldrValuesWithIndex1 rowList' row' m => MapValuesWithIndex rowList row fieldType m () row' => Monoid m => (String -> fieldType -> m) -> Record row -> m

foldMapValuesWithIndexR :: forall accum row fieldType rowList. RowToList row rowList => FoldrValuesWithIndex rowList row fieldType => Monoid accum => (String -> fieldType -> accum) -> Record row -> accum

class RLToAK :: RowList Type -> Constraintclass RLToAK (rowList :: RowList Type)  where

Members

• rlToAK :: Array String

Instances

• RLToAK Nil
• (IsSymbol name, RLToAK tail) => RLToAK (Cons name ty tail)

class RLToANEK :: RowList Type -> Constraintclass RLToANEK (rowList :: RowList Type)  where

Members

• rlToANEK :: Array NonEmptyString

Instances

• RLToANEK Nil
• (IsSymbol name, MakeNonEmpty name, RLToANEK tail) => RLToANEK (Cons name ty tail)

class RecordToAK :: forall k. k -> Constraintclass RecordToAK a  where

Members

• recordToAK :: Array String

Instances

• (RowToList row rowList, RLToAK rowList) => RecordToAK (Record row)

class RecordToANEK :: forall k. k -> Constraintclass RecordToANEK a  where

Members

• recordToANEK :: Array NonEmptyString

Instances

• (RowToList row rowList, RLToANEK rowList) => RecordToANEK (Record row)

rowToANEK :: forall @row rowList. RowToList row rowList => RLToANEK rowList => Array NonEmptyString

rowToAK :: forall @row rowList. RowToList row rowList => RLToAK rowList => Array String

class RLToLK :: RowList Type -> Constraintclass RLToLK (rowList :: RowList Type)  where

Members

• rlToLK :: List String

Instances

• RLToLK Nil
• (IsSymbol name, RLToLK tail) => RLToLK (Cons name ty tail)

class RLToLNEK :: RowList Type -> Constraintclass RLToLNEK (rowList :: RowList Type)  where

Members

• rlToLNEK :: List NonEmptyString

Instances

• RLToLNEK Nil
• (IsSymbol name, MakeNonEmpty name, RLToLNEK tail) => RLToLNEK (Cons name ty tail)

class RecordToLK :: forall k. k -> Constraintclass RecordToLK a  where

Members

• recordToLK :: List String

Instances

• (RowToList row rowList, RLToLK rowList) => RecordToLK (Record row)

class RecordToLNEK :: forall k. k -> Constraintclass RecordToLNEK a  where

Members

• recordToLNEK :: List NonEmptyString

Instances

• (RowToList row rowList, RLToLNEK rowList) => RecordToLNEK (Record row)

rowToLNEK :: forall @row rowList. RowToList row rowList => RLToLNEK rowList => List NonEmptyString

rowToLK :: forall @row rowList. RowToList row rowList => RLToLK rowList => List String

class RLToNEAK :: RowList Type -> Constraintclass RLToNEAK (rowList :: RowList Type)  where

Members

• rlToNEAK :: NonEmptyArray String

Instances

• (IsSymbol name, RLToAK tail) => RLToNEAK (Cons name ty tail)

class RLToNEANEK :: RowList Type -> Constraintclass RLToNEANEK (rowList :: RowList Type)  where

Members

• rlToNEANEK :: NonEmptyArray NonEmptyString

Instances

• (IsSymbol name, MakeNonEmpty name, RLToANEK tail) => RLToNEANEK (Cons name ty tail)

class RecordToNEAK :: forall k. k -> Constraintclass RecordToNEAK a  where

Members

• recordToNEAK :: NonEmptyArray String

Instances

• (RowToList row rowList, RLToNEAK rowList) => RecordToNEAK (Record row)

class RecordToNEANEK :: forall k. k -> Constraintclass RecordToNEANEK a  where

Members

• recordToNEANEK :: NonEmptyArray NonEmptyString

Instances

• (RowToList row rowList, RLToNEANEK rowList) => RecordToNEANEK (Record row)

rowToNEANEK :: forall @row rowList. RowToList row rowList => RLToNEANEK rowList => NonEmptyArray NonEmptyString

rowToNEAK :: forall @row rowList. RowToList row rowList => RLToNEAK rowList => NonEmptyArray String

class RLToNELK :: RowList Type -> Constraintclass RLToNELK (rowList :: RowList Type)  where

Members

• rlToNELK :: NonEmpty List String

Instances

• (IsSymbol name, RLToLK tail) => RLToNELK (Cons name ty tail)

class RLToNELNEK :: RowList Type -> Constraintclass RLToNELNEK (rowList :: RowList Type)  where

Members

• rlToNELNEK :: NonEmpty List NonEmptyString

Instances

• (IsSymbol name, MakeNonEmpty name, RLToLNEK tail) => RLToNELNEK (Cons name ty tail)

class RecordToNELK :: forall k. k -> Constraintclass RecordToNELK a  where

Members

• recordToNELK :: NonEmpty List String

Instances

• (RowToList row rowList, RLToNELK rowList) => RecordToNELK (Record row)

class RecordToNELNEK :: forall k. k -> Constraintclass RecordToNELNEK a  where

Members

• recordToNELNEK :: NonEmpty List NonEmptyString

Instances

• (RowToList row rowList, RLToNELNEK rowList) => RecordToNELNEK (Record row)

rowToNELNEK :: forall @row rowList. RowToList row rowList => RLToNELNEK rowList => NonEmpty List NonEmptyString

rowToNELK :: forall @row rowList. RowToList row rowList => RLToNELK rowList => NonEmpty List String

pickFn :: forall r1 r2. Fn2 (Array String) (Record r1) (Record r2)

pick :: forall rowA r @rowB rowListB. Union rowB r rowA => RowToList rowB rowListB => RLToAK rowListB => Record rowA -> Record rowB

class MapIndex :: forall k. RowList Type -> Row Type -> k -> Type -> Row Type -> Row Type -> Constraintclass MapIndex (rowList :: RowList Type) (row :: Row Type) a b (from :: Row Type) (to :: Row Type) | rowList -> row a b from to where

Members

• mapIndexBuilder :: (String -> b) -> Builder (Record from) (Record to)

Instances

• (IsSymbol name, Cons name a trash row, MapIndex tail row a b from from', Lacks name from', Cons name b from' to) => MapIndex (Cons name a tail) row a b from to
• MapIndex Nil row a b () ()

mapIndex :: forall row rowList a b row'. RowToList row rowList => MapIndex rowList row a b () row' => (String -> b) -> Proxy row -> Record row'

class MapRecord :: RowList Type -> Row Type -> Type -> Type -> Row Type -> Row Type -> Constraintclass MapRecord (rowList :: RowList Type) (row :: Row Type) a b (from :: Row Type) (to :: Row Type) | rowList -> row a b from to where

Members

• mapRecordBuilder :: (a -> b) -> Record row -> Builder (Record from) (Record to)

Instances

• (IsSymbol name, Cons name a trash row, MapRecord tail row a b from from', Lacks name from', Cons name b from' to) => MapRecord (Cons name a tail) row a b from to
• MapRecord Nil row a b () ()

mapRecord :: forall row rowList a b row'. RowToList row rowList => MapRecord rowList row a b () row' => (a -> b) -> Record row -> Record row'

class MapValuesWithIndex :: RowList Type -> Row Type -> Type -> Type -> Row Type -> Row Type -> Constraintclass MapValuesWithIndex (rowList :: RowList Type) (row :: Row Type) a b (from :: Row Type) (to :: Row Type) | rowList -> row a b from to where

Type class for transforming record values based on field names and values.

Members

• mapValuesWithIndexBuilder :: (String -> a -> b) -> Record row -> Builder (Record from) (Record to)

  The implementation for mapping over the record's values with the field name.

Instances

• (IsSymbol fieldName, Cons fieldName a restRow row, MapValuesWithIndex tail row a b from from', Lacks fieldName from', Cons fieldName b from' to) => MapValuesWithIndex (Cons fieldName a tail) row a b from to

  Instance for transforming a record with a non-empty field (i.e., head of the row list).

• MapValuesWithIndex Nil row a b () ()

  Base case: Empty record (i.e., no fields to transform).

mapValuesWithIndex :: forall row rowList a b row'. RowToList row rowList => MapValuesWithIndex rowList row a b () row' => (String -> a -> b) -> Record row -> Record row'

Like mapRecord from https://github.com/justinwoo/purescript-record-extra but mapRecordWithIndex The 'mapValuesWithIndex' function allows you to transform the values of a record, with access to the index (as the field name) and the value.

Example usage:

let record = { name: "Alice", age: 25 }
let result = mapValuesWithIndex (\name value -> name ++ ": " ++ show value) record
-- result will be: { name: "name: Alice", age: "age: 25" }

class ParSequenceRecord :: forall k. k -> Row Type -> Row Type -> Row Type -> (Type -> Type) -> (Type -> Type) -> Constraintclass (Parallel parM m) <= ParSequenceRecord rowList inputRow accRow resultRow parM m | rowList -> inputRow accRow resultRow parM m where

Class for sequencing a record of monadic values in parallel

Members

• parSequenceRecordImpl :: Record inputRow -> parM (Builder (Record accRow) (Record resultRow))

Instances

• (IsSymbol fieldName, Cons fieldName (m fieldType) remainingFields inputRow, Parallel parM m, Lacks fieldName (), Cons fieldName fieldType () resultRow) => ParSequenceRecord (Cons fieldName (m fieldType) Nil) inputRow () resultRow parM m

  Base case: When there's only one field left in the record

• (IsSymbol fieldName, Cons fieldName (m fieldType) remainingFields inputRow, ParSequenceRecord tailList inputRow accRow intermediateRow parM m, Lacks fieldName intermediateRow, Cons fieldName fieldType intermediateRow resultRow) => ParSequenceRecord (Cons fieldName (m fieldType) tailList) inputRow accRow resultRow parM m
• (Parallel parM m, Applicative parM) => ParSequenceRecord Nil inputRow () () parM m

  Base case: Empty record

parSequenceRecord :: forall inputRow outputRow rowList parM m. RowToList inputRow rowList => ParSequenceRecord rowList inputRow () outputRow parM m => Record inputRow -> m (Record outputRow)

Sequences a record of monadic values in parallel, returning a monadic record of values. For example, turns { a: Aff Int, b: Aff String } into Aff { a: Int, b: String } by running all the monadic values in parallel.

class SListToANES :: SList -> Constraintclass SListToANES (slist :: SList)  where

Members

• slistToANES :: Array NonEmptyString

Instances

• SListToANES SNil
• (IsSymbol name, MakeNonEmpty name, SListToANES tail) => SListToANES (SCons name tail)

class SListToAS :: SList -> Constraintclass SListToAS (slist :: SList)  where

Members

• slistToAS :: Array String

Instances

• SListToAS SNil
• (IsSymbol name, SListToAS tail) => SListToAS (SCons name tail)

class SListToNEANES :: SList -> Constraintclass SListToNEANES (slist :: SList)  where

Members

• slistToNEANES :: NonEmptyArray NonEmptyString

Instances

• (IsSymbol name, MakeNonEmpty name, SListToANES tail) => SListToNEANES (SCons name tail)

class SListToNEAS :: SList -> Constraintclass SListToNEAS (slist :: SList)  where

Members

• slistToNEAS :: NonEmptyArray String

Instances

• (IsSymbol name, SListToAS tail) => SListToNEAS (SCons name tail)

class SListToLNES :: SList -> Constraintclass SListToLNES (slist :: SList)  where

Members

• slistToLNES :: List NonEmptyString

Instances

• SListToLNES SNil
• (IsSymbol name, MakeNonEmpty name, SListToLNES tail) => SListToLNES (SCons name tail)

class SListToLS :: SList -> Constraintclass SListToLS (slist :: SList)  where

Members

• slistToLS :: List String

Instances

• SListToLS SNil
• (IsSymbol name, SListToLS tail) => SListToLS (SCons name tail)

class SListToNELNES :: SList -> Constraintclass SListToNELNES (slist :: SList)  where

Members

• slistToNELNES :: NonEmpty List NonEmptyString

Instances

• (IsSymbol name, MakeNonEmpty name, SListToLNES tail) => SListToNELNES (SCons name tail)

class SListToNELS :: SList -> Constraintclass SListToNELS (slist :: SList)  where

Members

• slistToNELS :: NonEmpty List String

Instances

• (IsSymbol name, SListToLS tail) => SListToNELS (SCons name tail)

data SNil :: SListdata SNil

Instances

• SListToRowList SNil Nil

data SList

A phantom type-level linked list of field names (symbols), used to express a deterministic ordering.

data SCons :: Symbol -> SList -> SListdata SCons t0 t1

Instances

• (SListToRowList sTail tail) => SListToRowList (SCons name sTail) (Cons name trash tail)

class SListToRowList :: SList -> RowList Type -> Constraintclass SListToRowList (xs :: SList) (rl :: RowList Type) | xs -> rl, rl -> xs

Convert a type-level symbol list (SList) to a RowList (RL.RowList). Example use foo :: forall @slist rowList . SListToRowList slist rowList => ...do something with rowList

Instances

• SListToRowList SNil Nil
• (SListToRowList sTail tail) => SListToRowList (SCons name sTail) (Cons name trash tail)

Operator alias for Record.ExtraSrghma.SList.Types.SCons (right-associative / precedence 6)

class SequenceRecord :: forall k. k -> Row Type -> Row Type -> Row Type -> (Type -> Type) -> Constraintclass (Functor m) <= SequenceRecord rowList row from to m | rowList -> row from to m where

Members

• sequenceRecordImpl :: Record row -> m (Builder (Record from) (Record to))

Instances

• (IsSymbol name, Cons name (m ty) trash row, Functor m, Lacks name (), Cons name ty () to) => SequenceRecord (Cons name (m ty) Nil) row () to m
• (IsSymbol name, Cons name (m ty) trash row, Apply m, SequenceRecord tail row from from' m, Lacks name from', Cons name ty from' to) => SequenceRecord (Cons name (m ty) tail) row from to m
• (Applicative m) => SequenceRecord Nil row () () m

sequenceRecord :: forall row row' rowList m. RowToList row rowList => SequenceRecord rowList row () row' m => Record row -> m (Record row')

class TraverseRecord :: forall k. k -> Row Type -> Row Type -> Row Type -> Row Type -> (Type -> Type) -> Constraintclass (Functor m) <= TraverseRecord rowList rowF rowA from to m | rowList -> rowF rowA from to m where

Members

• traverseRecordImpl :: Record rowF -> Record rowA -> m (Builder (Record from) (Record to))

Instances

• (Applicative m) => TraverseRecord Nil rowF rowA () () m
• (IsSymbol name, Cons name (a -> m b) trashF rowF, Cons name a trashA rowA, Apply m, TraverseRecord tail rowF rowA from from' m, Lacks name from', Cons name b from' to) => TraverseRecord (Cons name (a -> m b) tail) rowF rowA from to m

traverseRecord :: forall rowF rowA rowOut rowList m. RowToList rowF rowList => TraverseRecord rowList rowF rowA () rowOut m => Record rowF -> Record rowA -> m (Record rowOut)

newtype LazyTupleList a

A lazy unfoldable wrapper for converting record values into a sequential structure.

Constructors

• LazyTupleList (Unit -> Maybe (Tuple a (LazyTupleList a)))

Instances

• Lazy (LazyTupleList a)

valuesToUnfoldableLazy :: forall row rowList container value. RowToList row rowList => FoldrValuesLazy rowList row value => Unfoldable container => Record row -> container value

Converts a record of values into any Unfoldable container, lazily.

class ZipRecord :: RowList Type -> RowList Type -> Row Type -> Row Type -> Row Type -> Row Type -> Constraintclass ZipRecord (rowListL :: RowList Type) (rowListR :: RowList Type) (rowL :: Row Type) (rowR :: Row Type) (resultRowAcc :: Row Type) (resultRow :: Row Type) | rowListL -> rowL resultRowAcc resultRow, rowListR -> rowR resultRowAcc resultRow where

Zips two records (with matching keys) into a single record of Tuple values.

Members

• zipRecordImpl :: Record rowL -> Record rowR -> Builder (Record resultRowAcc) (Record resultRow)

Instances

• ZipRecord Nil Nil rowL rowR () ()
• (IsSymbol key, Cons key a restRowL rowL, Cons key b restRowR rowR, Cons key (Tuple a b) resultTail resultRow, Lacks key resultTail, ZipRecord tailL tailR rowL rowR resultRowAcc resultTail) => ZipRecord (Cons key a tailL) (Cons key b tailR) rowL rowR resultRowAcc resultRow

zipRecord :: forall rowListL rowL rowListR rowR zippedRow. RowToList rowL rowListL => RowToList rowR rowListR => ZipRecord rowListL rowListR rowL rowR () zippedRow => Record rowL -> Record rowR -> Record zippedRow