BoomBoom

newtype BoomBoom tok a

Our core type - nearly an iso: { ser: a → tok, prs: tok → Maybe a }

Constructors

• BoomBoom (BoomBoomD tok a a)

Instances

• Newtype (BoomBoom tok a) _
• Invariant (BoomBoom tok)
• (Semigroup tok, TypeEquals a Unit) => Semigroup (BoomBoom tok a)
• (Monoid tok, TypeEquals a Unit) => Monoid (BoomBoom tok a)

newtype BoomBoomD tok a' a

D from diverging as a' can diverge from a. It is enough to express Applicative for parsing and two Semigroupoids in both directions (ser and prs).

Constructors

• BoomBoomD { prs :: tok -> Maybe { a :: a, tok :: tok }, ser :: a' -> tok }

Instances

• Newtype (BoomBoomD tok a' a) _
• Functor (BoomBoomD tok a')
• Profunctor (BoomBoomD tok)
• (Semigroup tok) => Apply (BoomBoomD tok a')
• (Monoid tok) => Applicative (BoomBoomD tok a')
• (Monoid tok) => Alt (BoomBoomD tok a')

  This Alt instance is somewhat dangerous - it allows you to define inconsistent BoomBoom. For example in case of coproduct type you can get tok's mempty value as a result of serialization which is not parsable by the same BoomBoom.

divergeA :: forall tok a' a. (a' -> a) -> BoomBoom tok a -> BoomBoomD tok a' a

divergeA together with BoomBoomD Applicative instance form quite nice API to create by hand BoomBooms for records (or other product types):

recordB ∷ BoomBoom String {x :: Int, y :: Int}
recordB = BoomBoom $
  {x: _, y: _}
  <$> _.x >- int
  <* lit "/"
  <*> _.y >- int

This can be tedious and leaves responsibility on the user to accordingly pick and create elements of a product. For example I could easily replace _.x with _.y (and get two _.y) by mistake and it won't be detected by compiler.

Operator alias for BoomBoom.divergeA (left-associative / precedence 5)

newtype ProductBuilder tok a r r'

These two semigroupoids keep track of BoomBoom divergence and allow us to define nice combinators for variant and record build up.

You should not really worry about these two types because they are underlying machinery for higher level combinators addChoice/buildVariant and addField/buildRecord.

Constructors

• ProductBuilder (BoomBoomD tok a (r -> r'))

Instances

• (Semigroup tok) => Semigroupoid (ProductBuilder tok a)
• (Monoid tok) => Category (ProductBuilder tok a)

newtype CoproductBuilder tok a v v'

For sure serializer could be expressed much easier (like: a → (b → t) → t) but we want to use BooBoomD for this and we've got ser: a'-> tok with moving a' part to our disposition.

Constructors

• CoproductBuilder (BoomBoomD tok ((v -> v') -> tok) a)

Instances

• (Semigroup tok) => Semigroupoid (CoproductBuilder tok a)

addChoice :: forall tok n s' s r' r a. RowCons n a r' r => RowCons n a s s' => IsSymbol n => Semigroup tok => Eq tok => SProxy n -> BoomBoom tok Unit -> BoomBoom tok a -> CoproductBuilder tok (Variant s') (Either (Variant r) tok) (Either (Variant r') tok)

Our category allows us to step by step contract our variant:

    (((Either a tok → Either b tok) → tok) → tok)
>>> (((Either b tok → Either c tok) → tok) → tok)
=   (((Either a tok → Either c tok) → tok) → tok)

Where a, b, c is our contracting variant series.

buildVariant :: forall r tok. CoproductBuilder tok (Variant r) (Either (Variant r) tok) (Either (Variant ()) tok) -> BoomBoom tok (Variant r)

We are getting our final serializer here - a function which returns

Either Void tok so we can just pick right thing from it:

ser ∷ (((Either (Variant r) tok → Either (Variant ()) tok) → tok) → tok)

addField :: forall tok s' s p' p n a. RowCons n a s s' => RowLacks n s => RowCons n a p p' => RowLacks n p => IsSymbol n => SProxy n -> BoomBoom tok a -> ProductBuilder tok (Record s') (Record p) (Record p')

buildRecord :: forall tok r. ProductBuilder tok r (Record ()) r -> BoomBoom tok r

serialize :: forall tok a. BoomBoom tok a -> (a -> tok)

parse :: forall tok a. BoomBoom tok a -> (tok -> Maybe a)

xrap :: forall tok n a. Newtype n a => BoomBoom tok a -> BoomBoom tok n

Newtype wrap/unwrap