Operators for choose/divide?

[mitchellwrosen]

Hi, I just stumbled upon this library and tried it out. First time using Decidable and Divisible and they seem rather elegant. However, I found the code rather hard to write without infix operators similar to <*> and <|>. Moreover, I had to manually turn my ADT into a "canonical" form, using Either and (,).

For example,

data Foo 
    = One Text 
    | Two Text Text 
    | Three Text Text Text

-- it would be nice to derive this with Generics and TH
gfoo :: Foo -> Either Text (Either (Text, Text) (Text, (Text, Text)))
gfoo = ...

fooValue :: Value Foo
fooValue = contramap gfoo $
    string
    <||> string <//> string
    <||> string <//> string <//> string

infixr 4 <||>
(<||>) = chosen

infixr 5 <//>
(<//>) = divided

Anyways, I guess my question is what is the recommended way of writing Values? It seems wrong to include operators here that aren't defined in contramap - and I assume they aren't defined in contramap for a good reason. But, I couldn't figure out a way to write readable code without them.

Thanks!
Mitchell

[nikita-volkov]

Wow! You're trying out a library with that quality of the documentation. You must be really desperate! :) That alone deserves respect, man!

Now, concerning the recommendations.

I never define custom operators, I find the existing ones of the category theory abstractions sufficient for any task. It's a personal opinion though, so I can't strongly recommend that.

I would advice against the gfoo thing in particular, and against looking for automagical Generics-based solutions in general though. One of the primary ideas behind this library was to move away from data-type-dictated encoder specifications. Instead it aims to let the encoder specifications be specified directly using the simplest building blocks, which are functions. That is instead of having them dispersed across datatypes, weird typeclass instances and functions, as the alternative APIs tend to impose.

Until I fix the documentation issue, I recommend you to check out the Encoders DSL of the Hasql library, since it shares the design with this library, but has a better documentation.

For using the product types in the contravariant context I've released a utility library. I think the library could be extended in a similar fashion to cover the sum types, which you have in your case. I'll think of something later. Suggestions are welcome.