Meta and unMeta #70

boisgera · 2024-09-03T10:41:13Z

boisgera
Sep 3, 2024
Maintainer

About the `Meta` type

🎯 Target: Python developers willing to understand the context in Haskell of the pandoc metadata type definition:

newtype Meta = Meta {unMeta :: Map Text MetaValue}

The Haskell pattern

It is described for example in Safe Zero-cost Coercions for Haskell under the name of "generative type abstraction". The gist: to represent HTML data for example, we may me tempted to define a type synonym

type HTML = String

that makes the HTML type undistinguishable from its internal representation. Or instead, in order to get more type safety, we can define a specific wrapper type on top of this representation with

newtype HTML = HTML String

Now, a function expecting an instance of HTML won't accept a raw instance of String anymore and some programming errors can be avoided. In order to work with ithe internal representation, we can define a function helper ("deconstructor" or "unwrapper") that would be:

unHTML :: HTML -> String
unHTML (HTML s) = s

In the Haskell interpreter, using HTML and unHTML would look like this:

> let string = "<body>Pandoc</body>"
> string
"<body>Pandoc</body>"
> let html = HTML string
> html
HTML "<body>Pandoc</body>"
> unHTML html
"<body>Pandoc</body>"

Now, the HTML type and its deconstructor unHTML can be achieved in one declaration instead of two, with the record syntax:

newtype HTML = HTML {unHTML :: String}

which is exactly the pattern that pandoc's Meta is using. Nothing new, just some syntaxic sugar.

At a first glance, we could be tempted to name the wrapped field string - after its type String - instead of unHTML. But you would end up with a deconstructor named with a very generic name string and you wouln't be able to repeat the trick. Say that you have

newtype HTML = HTML {string :: String}
newtype URL = URL {string :: String}

The, the second deconstructor would shadow the first:

> let html = HTML "<body>pandoc</body>"
> let url = URL "https://pandoc.org"
> let html_string = string html

<interactive>:11:26: error:
    • Couldn't match expected type ‘URL’ with actual type ‘HTML’
    • In the first argument of ‘string’, namely ‘html’
      In the expression: string html
      In an equation for ‘html_string’: html_string = string html

So instead doing

newtype HTML = HTML {unHTML :: String}
newtype URL = URL {unURL :: String}

provides systematic deconstructor names that are specific enough to avoid this issue.

How to translate this pattern in Python?

Not that in Python, since field are access with the dot syntax, the previous name collision issue would not exist. We could define

from dataclasses import dataclass
String = str 

@dataclass
class HTML:
    string: String

@dataclass
class URL:
    string: String

and happily use the field name string for both classes.

>>> html = HTML("<body>pandoc</body>")
>>> url = URL("https://pandoc.org")
>>> html.string
'<body>pandoc</body>'
>>> url.string
'https://pandoc.org'

In this context, it's arguably simpler than the "typed unwrapper" scheme.

So it would make sense to translate for example a Haskell typed definition

newtype Count = Count {unCount :: Int}

to

Count(int : Int = 0)

and

newtype HTML = HTML {unHTML :: String}

to

HTML(string: String = "")

As long as we have a canonical way to name a field of the wrapped type, we can use it as the named of the wrapper.

(Partial) Conclusion (🚧 wip)

How does this apply to Meta, the only use case for this pattern (today) in the pandoc types hierarchy?

Well, since Meta definition is

newtype Meta = Meta {unMeta :: Map Text MetaValue}

I think that the Pythonic & systematic thing to do would be to

select a scheme to name instances of Map KeyType ValueType,
specialize this scheme to get a name for Map Text MetaValue,
use this name for the unique Meta field.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Meta and unMeta #70

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 0 comments

Select a reply

Meta and unMeta #70

boisgera Sep 3, 2024 Maintainer

About the Meta type

The Haskell pattern

How to translate this pattern in Python?

(Partial) Conclusion (🚧 wip)

Replies: 0 comments

boisgera
Sep 3, 2024
Maintainer

About the `Meta` type