How can I turn a [TExp a] into a TExp [a], or otherwise apply refineTH to multiple values programatically?

Question

I've been using refined for refinement types in Haskell recently, and have encountered a major usability problem. I can't figure out how to refine an entire list of values at compile time.

For example I can write:

{-# LANGUAGE TemplateHaskell #-}

import Refined

oneToThree :: [Refined Positive Int]
oneToThree = [$$(refineTH 1), $$(refineTH 2), $$(refineTH 3)]

But I can't do this precludes the ability of using range syntax, because Refined doesn't (for good reason) have an instance for Enum.

I would like to be able to do something like

oneToThree :: [Refined Positive Int]
oneToThree = $$(traverse refineTH [1..3])

but I can't get this to compile because I can't lift [TExp (Refined Positive Int)] into TExp [Refined Positive Int].

Is there template haskell magic that I missing that will let me do this?

Would also be open to suggestions for better lightweight refinement type libraries if someone has a suggestion.

Carl · Accepted Answer · 2020-03-11T02:01:08.513

sequenceQTExpList :: [Q (TExp a)] -> Q (TExp [a])
sequenceQTExpList [] = [|| [] ||]
sequenceQTExpList (x:xs) = [|| $$(x) : $$(sequenceQTExpList xs) ||]

Then use it as

$$(sequenceQTExpList $ map refineTH [1..3])

You're right that it feels like a traverse. The type is a bit off, though, with the extra Qs floating around. I don't see anything offhand that lets you combine those layers usefully.

Unfortunately, a lot of the mechanism used there is TH syntax rather than functions. There just isn't an obvious way to do both the lifting and the splicing as functions, so you're stuck writing bespoke helpers for each container type instead of getting to use Traversable. It's an interesting problem. If there's a clean solution, it'd have a good chance of making it into a future version of template Haskell if it was brought up to the maintainers. But I just don't see it right now.

Clever! I think you can keep a bit more of the traverse-y feel with something like `traverseQTExpList f (x:xs) = [|| $$(f x) : $$(traverseQTExpList f xs) ||]` though. — Joseph Sible-Reinstate Monica, Mar 11 '20 at 02:39
Well, yes. I implementated `sequence` instead of `traverse`. It was slightly easier to test on a laptop with no internet and then manually copy to my phone. :) — Carl, Mar 11 '20 at 03:16

score 1 · Answer 2 · answered Mar 11 '20 at 01:37

This works (it needs to be in a different file than you use it in because of the stage restriction, though):

import Language.Haskell.TH.Syntax (Exp(ListE), TExp(TExp))

makeTypedTHList :: [TExp a] -> TExp [a]
makeTypedTHList xs = TExp $ ListE [x | TExp x <- xs]

You'd then use it like this:

{-# LANGUAGE TemplateHaskell #-}

import Refined
import AboveCodeInSeparateModuleBecauseOfStageRestriction (makeTypedTHList)

oneToThree :: [Refined Positive Int]
oneToThree = $$(makeTypedTHList <$> traverse refineTH [1..3])

However, calling the TExp constructor yourself subverts some of the safety of typed Template Haskell (although I think this particular case is safe). Ideally, I'd prefer an approach that didn't require doing that, but I can't think of one.

How can I turn a [TExp a] into a TExp [a], or otherwise apply refineTH to multiple values programatically?

2 Answers2