[Haskell-cafe] printf using values more than once
olf at aatal-apotheke.de
Fri Jun 4 07:32:33 UTC 2021
On Thu, 3 Jun 2021, MigMit wrote:
> At this point I'm not sure how it is different from a simple function. The HoleyMonoid example
>> holey = now "x = " . later show . now ", y = " . later show
> when paired with 'argn'-style variables essentially becomes
>> holey arg1 arg2 = "y = " ++ show arg2 ++ "; x = " ++ show arg1
> So, what kind of syntax do you have in mind?
What I'm after is documentation of n-ary functions. Suppose
f :: a -> a -> Maybe a
f arg1 arg2 = if arg1 < arg2 then Nothing else Just arg2
The docstring of f should be a function that, given descriptions of the
arguments, generates a description of the result. E.g.
doc_f = "if " <> arg1 <> " is smaller than " <> arg2 <> " then Nothing
else Just " <> arg2
Say you have concrete arguments which are already tagged with a
x :: (String,a)
y :: (String,a)
One could then have an operator <%> that acts like function application
but at the same time takes care of documentation:
func desc_f f <%> x <%> y :: (String,c)
Here 'func' is an operator that translates the hypothetical docstring type
into a real function.
My provenience package currently burdens the user with constructing the
docstrings by manually inserting the appropriate descriptions from x and y
into doc_f. I'd like to automate that and make it more type-safe so that
mismatch between documentation and type of f is a compile-time error.
>> On 3 Jun 2021, at 22:21, Olaf Klinke <olf at aatal-apotheke.de> wrote:
>> Dear Café,
>> since the topic recently was rendering text, I'd like to ask a related design question. I want a version of printf that
>> - is more type-safe because unused or surplus arguments cause compile-time errors,
>> - the formatting instructions can use arguments out of order and more than once, - is polymorphic in the text type being built: Suppose I want to build a Pandoc Block but the holes are of type Inline. The format string must therefore be able to promote the Block type's constructors to constructors with holes.
>> The closest match I know of is HoleyMonoid  but it only provides printf-like holes, whereas I need named positional arguments like arg1, arg2 etc. that can be repeated. Document templating libraries provide these, but all templating libraries I looked at are type-unsafe.
>> In order to fulfill the second requirement, one could use the free monad over a Reader functor, e.g.
>> Free ((->) (forall a. Show a => a)) String
>> with some custom instances. Here one can use the nesting levels of the free monad to encode the argument position. But it is just as type-unsafe as printf. Funneling return type constructors through this works sort of, but it's awkward.
>> One can achieve type saftey with type classes like printf does:
>> class Eventually r a where
>> eventually :: r -> a
>> instance Eventually r r where
>> eventually = id
>> instance (Eventually r a) => Eventually r (b -> a) where
>> eventually r = const (eventually r)
>> This class can be used to inject constant Text into any nesting of
>> (Text -> ... -> Text -> Text)
>> and argument position is indeed function argument position. But using this system often leads to type ambiguity errors. Also, it is so type-safe that it is impossible to write a function taking a natural number and returning the hole of the corresponding position: Such a function would be dependently-typed.
>> My current best implementation uses a combination of Eventually and HoleyMonoid, but I'm not entirely satisfied.
>>  https://hackage.haskell.org/package/HoleyMonoid_______________________________________________
>> Haskell-Cafe mailing list
>> To (un)subscribe, modify options or view archives go to:
>> Only members subscribed via the mailman list are allowed to post.
More information about the Haskell-Cafe