Send Beginners mailing list submissions to
beginners@haskell.org
To subscribe or unsubscribe via the World Wide Web, visit
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
beginners-requ...@haskell.org
You can reach the person managing the list at
beginners-ow...@haskell.org
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. A seemingly simple use-case for Template Haskell (Mario Lang)
2. Re: A seemingly simple use-case for Template Haskell
(Ryan Trinkle)
3. Re: A seemingly simple use-case for Template Haskell
(Simon Peter Nicholls)
----------------------------------------------------------------------
Message: 1
Date: Wed, 28 Sep 2016 15:06:53 +0200
From: Mario Lang <ml...@delysid.org>
To: beginners@haskell.org
Subject: [Haskell-beginners] A seemingly simple use-case for Template
Haskell
Message-ID: <87shsk9nrm....@fx.delysid.org>
Content-Type: text/plain; charset=utf-8
Hi.
As a long-term Lisp fan, and someone who always admired compile-time
code-generation, I wanted to at least do something simple with Template
Haskell once.
In a small project of mine, I have this basically auto-generated data
type:
-- Braille music code only uses the old 6-dot system. We enumerate all
-- possible dot patterns to use the type system to avoid accidentally
-- specifying invalid dot patterns in the source code.
--
-- gen :: String
-- gen =
-- "data Braille = " ++ intercalate " | " ctors ++ " deriving (Enum, Eq)"
where
-- ctors = "NoDots" : map ctorName [1..63] where
-- ctorName :: Int -> String
-- ctorName = (++) "Dot" . concatMap (show . succ) . flip filter [0..5] .
testBit
data SixDots = NoDots | Dot1 | Dot2 | Dot12 | Dot3 | Dot13 | Dot23 | Dot123
| Dot4 | Dot14 | Dot24 | Dot124 | Dot34 | Dot134 | Dot234
| Dot1234 | Dot5 | Dot15 | Dot25 | Dot125 | Dot35 | Dot135
| Dot235 | Dot1235 | Dot45 | Dot145 | Dot245 | Dot1245 | Dot345
| Dot1345 | Dot2345 | Dot12345 | Dot6 | Dot16 | Dot26 | Dot126
| Dot36 | Dot136 | Dot236 | Dot1236 | Dot46 | Dot146 | Dot246
| Dot1246 | Dot346 | Dot1346 | Dot2346 | Dot12346 | Dot56 | Dot156
| Dot256 | Dot1256 | Dot356 | Dot1356 | Dot2356 | Dot12356
| Dot456 | Dot1456 | Dot2456 | Dot12456 | Dot3456 | Dot13456
| Dot23456 | Dot123456
deriving (Bounded, Enum, Eq, Read, Show)
So, while actually quite simple, this looks like an opportunity to use
Template Haskell for me. In other words, I want to figure out what is
necessary to generate this data type with TH, instead of the gen
function that basically generates a piece of plain Haskell code.
I have been reading "A practical Template Haskell Tutorial"[1] but I find
it a little bit too terse to actually solve this very little riddle on
my own.
For one, I find it confusing that some TH functions return "Q Dec" while
others just return Dec. I am aware that this is some sort of Monad for
the TH system, but I have never seen it explained anywhere.
Also, all the examples I can find seem to be mostly focused in
generating Q Exp or similar, but I didn't really find an example
for Q Dec.
I realize this should be simple to figure out on my own, but it
apparently is not. I have tried to wrap my head around this on my own
at least three times now, but always stopped after an hour or two due to
frustration. Is there some comprehensive TH documentation I haven't
seen yet? Could you please give me enough of a head-start that I
actually manage to write something which can generate this simple data
type above?
[1] https://wiki.haskell.org/A_practical_Template_Haskell_Tutorial
--
CYa,
⡍⠁⠗⠊⠕
------------------------------
Message: 2
Date: Wed, 28 Sep 2016 10:10:38 -0400
From: Ryan Trinkle <ryan.trin...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] A seemingly simple use-case for
Template Haskell
Message-ID:
<cahnepix7m9s-5zdan6dzjkwmeaa_3q27mspugr6qe+kngsj...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Why not just use a datastructure with 6 Bools? E.g.:
data SixDots = SixDots
{ dot1 :: Bool
, dot2 :: Bool
, dot3 :: Bool
, dot4 :: Bool
, dot5 :: Bool
, dot6 :: Bool
}
There may be even better ways to do this, but I would consider something
like this if I were working on this problem.
Although I do end up using TH sometimes, I usually find that it is better
to use non-meta-level solutions when practical.
Best,
Ryan
On Wed, Sep 28, 2016 at 9:06 AM, Mario Lang <ml...@delysid.org> wrote:
> Hi.
>
> As a long-term Lisp fan, and someone who always admired compile-time
> code-generation, I wanted to at least do something simple with Template
> Haskell once.
>
> In a small project of mine, I have this basically auto-generated data
> type:
>
> -- Braille music code only uses the old 6-dot system. We enumerate all
> -- possible dot patterns to use the type system to avoid accidentally
> -- specifying invalid dot patterns in the source code.
> --
> -- gen :: String
> -- gen =
> -- "data Braille = " ++ intercalate " | " ctors ++ " deriving (Enum,
> Eq)" where
> -- ctors = "NoDots" : map ctorName [1..63] where
> -- ctorName :: Int -> String
> -- ctorName = (++) "Dot" . concatMap (show . succ) . flip filter
> [0..5] . testBit
>
> data SixDots = NoDots | Dot1 | Dot2 | Dot12 | Dot3 | Dot13 | Dot23 | Dot123
> | Dot4 | Dot14 | Dot24 | Dot124 | Dot34 | Dot134 | Dot234
> | Dot1234 | Dot5 | Dot15 | Dot25 | Dot125 | Dot35 | Dot135
> | Dot235 | Dot1235 | Dot45 | Dot145 | Dot245 | Dot1245 |
> Dot345
> | Dot1345 | Dot2345 | Dot12345 | Dot6 | Dot16 | Dot26 | Dot126
> | Dot36 | Dot136 | Dot236 | Dot1236 | Dot46 | Dot146 | Dot246
> | Dot1246 | Dot346 | Dot1346 | Dot2346 | Dot12346 | Dot56 |
> Dot156
> | Dot256 | Dot1256 | Dot356 | Dot1356 | Dot2356 | Dot12356
> | Dot456 | Dot1456 | Dot2456 | Dot12456 | Dot3456 | Dot13456
> | Dot23456 | Dot123456
> deriving (Bounded, Enum, Eq, Read, Show)
>
> So, while actually quite simple, this looks like an opportunity to use
> Template Haskell for me. In other words, I want to figure out what is
> necessary to generate this data type with TH, instead of the gen
> function that basically generates a piece of plain Haskell code.
>
> I have been reading "A practical Template Haskell Tutorial"[1] but I find
> it a little bit too terse to actually solve this very little riddle on
> my own.
>
> For one, I find it confusing that some TH functions return "Q Dec" while
> others just return Dec. I am aware that this is some sort of Monad for
> the TH system, but I have never seen it explained anywhere.
>
> Also, all the examples I can find seem to be mostly focused in
> generating Q Exp or similar, but I didn't really find an example
> for Q Dec.
>
> I realize this should be simple to figure out on my own, but it
> apparently is not. I have tried to wrap my head around this on my own
> at least three times now, but always stopped after an hour or two due to
> frustration. Is there some comprehensive TH documentation I haven't
> seen yet? Could you please give me enough of a head-start that I
> actually manage to write something which can generate this simple data
> type above?
>
> [1] https://wiki.haskell.org/A_practical_Template_Haskell_Tutorial
> --
> CYa,
> ⡍⠁⠗⠊⠕
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20160928/a880b45d/attachment-0001.html>
------------------------------
Message: 3
Date: Wed, 28 Sep 2016 16:18:28 +0200
From: Simon Peter Nicholls <si...@mintsource.org>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] A seemingly simple use-case for
Template Haskell
Message-ID: <8298e68a-d98e-44df-89d7-50029d20d...@mintsource.org>
Content-Type: text/plain; charset="utf-8"
Hi Mario,
I had a similar itch to scratch when I first started noodling with Haskell,
coming from Lisp, and wrote the following for generating enums from a
convenient notation:
https://github.com/yesodweb/yesod/wiki/Create-String-Based-Enums-With-Template-Haskell
<https://github.com/yesodweb/yesod/wiki/Create-String-Based-Enums-With-Template-Haskell>
It’s approaching four years old, so likely no longer works as is, but I hope it
is helpful.
Even more than with Lisp macros, TH should be seen as a last resort. However,
sometimes you gotta scratch. I was frustrated at the time that I couldn’t find
any decent examples, and I specifically wanted to learn some TH - regardless of
whether there was a better way available.
In that wiki page you’ll find code for a custom quasi quoter, and code for
generating declarations. I mostly just relied on the template haskell docs:
https://hackage.haskell.org/package/template-haskell
<https://hackage.haskell.org/package/template-haskell>
which I found to have everything I needed, though of course there is a lot to
digest in there.
After gaining some familiarity, the types and functions for creating those
types feel a natural match to regular Haskell source, and Q is used because
otherwise your declarations would be just side effect free values, unable to
affect your program.
For your needs, find “data Dec” in the template haskell docs, and you’ll see
that `DataD` matches what you need at term level. Then take a look at `dataD`,
a function that will construct your declaration, using Q.
Cheers,
Si
> On 28 Sep 2016, at 15:06, Mario Lang <ml...@delysid.org> wrote:
>
> Hi.
>
> As a long-term Lisp fan, and someone who always admired compile-time
> code-generation, I wanted to at least do something simple with Template
> Haskell once.
>
> In a small project of mine, I have this basically auto-generated data
> type:
>
> -- Braille music code only uses the old 6-dot system. We enumerate all
> -- possible dot patterns to use the type system to avoid accidentally
> -- specifying invalid dot patterns in the source code.
> --
> -- gen :: String
> -- gen =
> -- "data Braille = " ++ intercalate " | " ctors ++ " deriving (Enum, Eq)"
> where
> -- ctors = "NoDots" : map ctorName [1..63] where
> -- ctorName :: Int -> String
> -- ctorName = (++) "Dot" . concatMap (show . succ) . flip filter [0..5] .
> testBit
>
> data SixDots = NoDots | Dot1 | Dot2 | Dot12 | Dot3 | Dot13 | Dot23 | Dot123
> | Dot4 | Dot14 | Dot24 | Dot124 | Dot34 | Dot134 | Dot234
> | Dot1234 | Dot5 | Dot15 | Dot25 | Dot125 | Dot35 | Dot135
> | Dot235 | Dot1235 | Dot45 | Dot145 | Dot245 | Dot1245 | Dot345
> | Dot1345 | Dot2345 | Dot12345 | Dot6 | Dot16 | Dot26 | Dot126
> | Dot36 | Dot136 | Dot236 | Dot1236 | Dot46 | Dot146 | Dot246
> | Dot1246 | Dot346 | Dot1346 | Dot2346 | Dot12346 | Dot56 | Dot156
> | Dot256 | Dot1256 | Dot356 | Dot1356 | Dot2356 | Dot12356
> | Dot456 | Dot1456 | Dot2456 | Dot12456 | Dot3456 | Dot13456
> | Dot23456 | Dot123456
> deriving (Bounded, Enum, Eq, Read, Show)
>
> So, while actually quite simple, this looks like an opportunity to use
> Template Haskell for me. In other words, I want to figure out what is
> necessary to generate this data type with TH, instead of the gen
> function that basically generates a piece of plain Haskell code.
>
> I have been reading "A practical Template Haskell Tutorial"[1] but I find
> it a little bit too terse to actually solve this very little riddle on
> my own.
>
> For one, I find it confusing that some TH functions return "Q Dec" while
> others just return Dec. I am aware that this is some sort of Monad for
> the TH system, but I have never seen it explained anywhere.
>
> Also, all the examples I can find seem to be mostly focused in
> generating Q Exp or similar, but I didn't really find an example
> for Q Dec.
>
> I realize this should be simple to figure out on my own, but it
> apparently is not. I have tried to wrap my head around this on my own
> at least three times now, but always stopped after an hour or two due to
> frustration. Is there some comprehensive TH documentation I haven't
> seen yet? Could you please give me enough of a head-start that I
> actually manage to write something which can generate this simple data
> type above?
>
> [1] https://wiki.haskell.org/A_practical_Template_Haskell_Tutorial
> --
> CYa,
> ⡍⠁⠗⠊⠕
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20160928/9746d3b4/attachment.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 99, Issue 21
*****************************************
