[Haskell-cafe] printf using values more than once

[Olaf Klinke]

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 
description:
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.

Olaf

>
>> 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 [1] 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.
>>
>> Olaf
>>
>> [1] https://hackage.haskell.org/package/HoleyMonoid_______________________________________________
>> Haskell-Cafe mailing list
>> To (un)subscribe, modify options or view archives go to:
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
>> Only members subscribed via the mailman list are allowed to post.
>
>