- Beginners - Haskell.org

ANNOUNCE: Haskell Communities and Activities Report (31st ed., November 2016)
by Mihai Maruseac 25 Dec '16

25 Dec '16

On behalf of all the contributors, we are pleased to announce that the Haskell Communities and Activities Report (31st edition, November 2016) is now available, in PDF and HTML formats: http://haskell.org/communities/11-2016/report.pdf http://haskell.org/communities/11-2016/html/report.html All previous editions of HCAR can be accessed on the wiki at https://wiki.haskell.org/Haskell_Communities_and_Activities_Report Many thanks go to all the people that contributed to this report, both directly, by sending in descriptions, and indirectly, by doing all the interesting things that are reported. We hope you will find it as interesting a read as we did. If you have not encountered the Haskell Communities and Activities Reports before, you may like to know that the first of these reports was published in November 2001. Their goal is to improve the communication between the increasingly diverse groups, projects, and individuals working on, with, or inspired by Haskell. The idea behind these reports is simple: Every six months, a call goes out to all of you enjoying Haskell to contribute brief summaries of your own area of work. Many of you respond (eagerly, unprompted, and sometimes in time for the actual deadline) to the call. The editors collect all the contributions into a single report and feed that back to the community. When we try for the next update, six months from now, you might want to report on your own work, project, research area or group as well. So, please put the following into your diaries now: ======================================== End of February 2016: target deadline for contributions to the May 2017 edition of the HCAR Report ======================================== Unfortunately, many Haskellers working on interesting projects are so busy with their work that they seem to have lost the time to follow the Haskell related mailing lists and newsgroups, and have trouble even finding time to report on their work. If you are a member, user or friend of a project so burdened, please find someone willing to make time to report and ask them to "register" with the editors for a simple e-mail reminder in November (you could point us to them as well, and we can then politely ask if they want to contribute, but it might work better if you do the initial asking). Of course, they will still have to find the ten to fifteen minutes to draw up their report, but maybe we can increase our coverage of all that is going on in the community. Feel free to circulate this announcement further in order to reach people who might otherwise not see it. Enjoy! -- Mihai Maruseac (MM) "If you can't solve a problem, then there's an easier problem you can solve: find it." -- George Polya

1 0

applicative default structure
by Ovidiu Deac 23 Dec '16

23 Dec '16

This code is using Applicative Maybe. The structure is provided by Maybe and the value 1 is wrapped in this structure. No surprises here. Prelude> pure 1 :: Maybe Int Just 1 Prelude> :t (pure 1 :: Maybe Int) (pure 1 :: Maybe Int) :: Maybe Int ...but can somebody explain the type of x below? Prelude> x = pure 1 Prelude> x 1 Prelude> :t x x :: (Applicative f, Num a) => f a What is f here? Thanks!

3 7

Noobie attempt to process log output into dependency graph
by John Lusk 17 Dec '16

17 Dec '16

Hi, all, Here's my question: I thought, for grins, I'd try to turn some log output into a dependency graph (using GraphViz's dot(1)). I'm having difficulty forcing my stateful paradigm into a functional one, so I need some help. If I was to do this with an imperative (stateful) language, I'd build a set of edges (or a map to a frequency count, really, since I'll use freq > 1 to add some output text noting the repeated occurrences), and then dump out the set elements to a text file that would look something like this fragment: a -> q q -> d d -> e [color=red] d -> f [color=red My big problem now is that if I process a subtree that looks like: a b c d b d e my current plan is to proces the first b-c-d subtree and then process the b-d-e subtree, *BUT* I need to pass the updated edge set to the second processing call, which is pretty stateful. Do I need to just bite the bullet and find some succinct way to do that, or is my entire approach just wrong, stuck in my stateful mindset? My (awful) code looks like this: -- Emit to stdout a series of dot(1) edges specifying dependencies.-- "A -> B" means "A depends on B".---- Build with 'ghc dependency-graph.hs'-- -- Input is a text file containing lines as follows:-- (some indentation) (some extraneous text) (file-A) in (some directory)-- (some extra indentation) (some extraneous text) (file-B) in (some directory)-- (some indentation matching the first line above) (some extraneous text) (file-C) in (some directory)---- This means that file-A depends on file-B, but neither file-A nor file-B depend on file-C.---- Sample:-- Helios.MigrationTool.Common.AssemblyUtils.GetAssemblyList() Information: 0 : Processing SXA.Compass.Config.ViewModel.dll in C:\Program Files (x86)\Allscripts Sunrise\Clinical Manager Client\7.2.5575.0\-- Helios.MigrationTool.Common.AssemblyUtils.GetAssemblyList() Information: 0 : Adding C:\Program Files (x86)\Allscripts Sunrise\Clinical Manager Client\7.2.5575.0\SXA.Compass.Config.ViewModel.dll (IsPresent=true) to assemblyList at beginning of GetAssemblyListEx()-- Helios.MigrationTool.Common.AssemblyUtils.GetAssemblyList() Information: 0 : Processing SXA.Compass.Config.Utils.dll in C:\Program Files (x86)\Allscripts Sunrise\Clinical Manager Client\7.2.5575.0\---- (Need to skip the line containing "Adding", and only process the ones containing "Processing".)-- -- Algorithm:-- Read first line, parse, remember indentation-- Repeat for other lines, but if indentation increases, store pair A -> B in hashset.-- At end, dump out hashset. -- import Debug.Trace-- import System.Environment-- import System.Console.GetOpt-- import Data.Maybe (fromMaybe)-- import Data.List.Splitimport Prelude -- hiding (readFile) -- Because we want the System.IO.Strict version-- import System.IO (hPutStr, hPutStrLn, stderr)-- import System.IO.Strict-- import Control.Monad-- import System.Directory-- import System.FilePathimport Text.Regex.TDFA-- import Text.Regex.TDFA.String-- import Text.Printf -- import qualified Data.Map.Lazy as Mapimport qualified Data.Map.Strict as Map ---------------------------------------------------------------- Test Datal1 = " Helios.MigrationTool.Common.AssemblyUtils.GetAssemblyList() Information: 0 : Processing SXA.Compass.Config.ViewModel.dll\tin C:\\Program Files (x86)\\Allscripts Sunrise\\Clinical Manager Client\\7.2.5575.0\\"l2 = " Helios.MigrationTool.Common.AssemblyUtils.GetAssemblyList() Information: 0 : Adding C:\\Program Files (x86)\\Allscripts Sunrise\\Clinical Manager Client\\7.2.5575.0\\SXA.Compass.Config.ViewModel.dll\t(IsPresent=true)\tto assemblyList at beginning of GetAssemblyListEx()"l3 = " Helios.MigrationTool.Common.AssemblyUtils.GetAssemblyList() Information: 0 : Processing SXA.Compass.Config.Utils.dll\tin C:\\Program Files (x86)\\Allscripts Sunrise\\Clinical Manager Client\\7.2.5575.0\\"---------------------------------------------------------------- Test Data Ends-- See http://stackoverflow.com/q/32149354/370611-- toRegex = makeRegexOpts defaultCompOpt{multiline=False} defaultExecOpt -- Escape parens?-- initialFillerRegex :: String-- initialFillerRegex = "Helios.MigrationTool.Common.AssemblyUtils.GetAssemblyList\$\$ Information: 0 : Processing" -- Regex matching (marking) a line to be processed-- valuableLineRegex :: String-- valuableLineRegex = "\\bProcessing\\b" -- |Regex matching line to be parsedparseLineRegex :: StringparseLineRegex = "^(.* Information: 0 : Processing )([^ ]*)[ \t]+in (.*)" -- 3subexpressions main :: IO()main = do logContents <- getContents putStrLn $ unlines $ fst $ edges (parseIndent $ lines logContents) Map.empty ------------------------------------------------------------------ |Parses out the leading indentation of the given String into a string of spaces and the rest of the lineparseIndent :: String -> (String,String)parseIndent s = ((fourth $ (s =~ "^( *)(.*)" :: (String,String,String,[String]))) !! 0, (fourth $ (s =~ "^( *)(.*)" :: (String,String,String,[String]))) !! 1) ------------------------------------------------------------------ |Returns a list of strings describing edges in the form "a -> b /* comment */"edges :: [(String,String)] -- ^ Input tuples: (indent, restOfString) -> Map.Map String Int -- ^ Map of edges in form "a -> b" with a count of the number of times that edge occurs -> [String] -- ^ Output list of edge descriptions in form "a -> b optionalExtraText" edges [] edgeSet = (edgeDump $ Map.assocs edgeSet, 0) edges (lastLine:[]) edgeSet = (edgeDump $ Map.assocs edgeSet, 1) edges (fstLogLine:sndLogLine:[]) edgeSet = let fstFields = (snd fstLogLine) =~ parseLineRegex :: (String,String,String,[String]) sndFields = (snd sndLogLine) =~ parseLineRegex :: (String,String,String,[String]) in if length (fourth fstFields) == 0 then error ("Unmatched: " ++ (first fstFields)) -- First line must always match else if length (fourth sndFields) == 0 -- "Adding", not "Processing" then edges (fstLogLine:[]) edgeSet -- Skip useless line else if indentLength fstLogLine >= indentLength sndLogLine then edges (sndLogLine:[]) edgeSet -- Can't be an edge from first to second line; drop first line and keep going. else edges (sndLogLine:[]) (Map.insertWith (+) ((fullName fstFields) ++ (fullName sndFields)) 1) edges (fstLogLine:sndLogLine:thdLogLine:logLines) edgeSet = let fstFields = (snd fstLogLine) =~ parseLineRegex :: (String,String,String,[String]) sndFields = (snd sndLogLine) =~ parseLineRegex :: (String,String,String,[String]) thdFields = (snd thdLogLine) =~ parseLineRegex :: (String,String,String,[String]) in if length (fourth fstFields) == 0 then error ("Unmatched: " ++ (first fstFields)) -- First line must always match else if length (fourth sndFields) == 0 -- "Adding", not "Processing" then edges (fstLogLine:thdLogLine:logLines) edgeSet -- Skip useless line else if indentLength fstLogLine >= indentLength sndLogLine then [] -- Stop processing at outdent else -- Looking one of: -- 1 -- 2 -- process 1 -> 2, then process 2.. as subtree -- 3 -- Need to process as subtree rooted at 2, then drop subtree (zero or more lines at same level as 3) -- or -- 1 -- 2 -- processs, then drop this line (process 2.. as empty subtree?) -- 3 -- or -- 1 -- 2 -- process, then drop this line (drop entire subtree rooted at 1) (same as above, drop empty subtree? (2)) -- 3 -- or -- 1 -- 2 -- same as above? Drop empty subtree rooted at 2 -- 3 edges (sndLogLine:thdLogLine:logLines) (Map.insertWith (+) ((fullName fstFields) ++ (fullName sndFields)) 1) -- now what? I need to pass the UPDATED edgeSet on to the next call, after the subtree rooted at 2 is dropped. then edges (sndLogLine:logLines) edgeSet -- Can't be an edge from first to second line; drop first line and keep going. else edges (sndLogLine:(takeWhile (increasingIndent $ length $ fst fstLogLine) logLines)) (Map.insertWith (+) ((fullName fstFields) ++ (fullName sndFields)) 1) else ((fst $ edges (sndLogLine:logLines) edgeSet) ++ (fst $ edges (fstLogLine:(drop (snd $ edges (sndLogLine:logLines) edgeSet) -- # of lines processed logLines)) edgeSet), (snd $ edges (sndLogLine:logLines) edgeSet) + (snd $ edges (fstLogLine:(drop (snd $ edges (sndLogLine:logLines) edgeSet) -- # of lines processed logLines)) edgeSet) ) ----------------------------------------------------------------fullname :: (String,String,String,[String]) -> Stringfullname (_,_,_,[_,fileName,directoryName]) = directoryName ++ fileName ------------------------------------------------------------------ |Edges from the first line to all following linesedgesFrom :: String -- ^ First line -> [String] -- ^ Following lines -> Map.Map String Int -- ^ Set of edges built so far -> [String]edgesFrom a b c = [] ------------------------------------------------------------------ |Return length of indent or errorindentLength :: (String,String,String,[String]) -- ^ Regex match context -> Int -- ^ Length of indentindentLength (prefix,_,_,[]) = error $ "Not matched: " ++ prefixindentLength (_,_,_,subexprs) = length $ subexprs !! 0 ------------------------------------------------------------------ |Returns a list of edges, possibly with comments indicating occurrence counts > 1edgeDump :: [(String,Int)] -- ^ List of (edge,count) tuples -> [String] -- ^ List of edges, possibly w/commentsedgeDump [] = []edgeDump ((edge,count):rest) | count <= 1 = edge:(edgeDump rest) | otherwise = (edge ++ " /* " ++ (show count) ++ " occurrences */"):(edgeDump rest) ----------------------------------------------------------------first :: (a,b,c,d) -> afirst (x,_,_,_) = x fourth :: (a,b,c,d) -> dfourth (_,_,_,x) = x

4 12

Sorting
by mike h 14 Dec '16

14 Dec '16

Hi, I’m trying to sort a list of tuples. A char and a count of that char (Char , Int) e.g. [ ('r',2), ('c',2),('a', 2), ('b',3), ('f',2)] e.g. ‘r’ occurs twice etc. The order should be based on the count first and then ties broken by the natural ordering of char. So [ ('r',2), ('c',2),('a', 2), ('b',3), ('f',2)] will sort as [('b',3),('a', 2), ('c',2),('f',2), ('r',2)] I initially tried variants on sortBy (compare `on` snd) and then made a type Tup = T (Char, Int) and defined Eq and then got to the point where I felt that this had become too difficult for a simple problem and concluded that I’m missing a point somewhere and need a bit of help! Many thanks M

3 3

Problem install Gtk
by Arnim Fiebig 14 Dec '16

14 Dec '16

The same happen on Win8.1 and another Pc with win7 1. install 'HaskellPlatform-8.0.1-full-x86_64-setup-a' ok 2. copy 'gtk+-bundle_3.6.4-20130513_win64' to C:\Gtk\ ok 3. 'cabal install gtk' failed Thanks for help Guenter

3 2

crypto random UUID generation
by Ovidiu Deac 13 Dec '16

13 Dec '16

I have to produce a crypto random UUID. I haven't found simple examples. and I used the one from hre (see type CRand) http://hackage.haskell.org/package/monadcryptorandom-0.7.0/docs/Control-Mon… My attempt is the following: cryptoRandomUUID :: IO UUID.UUID cryptoRandomUUID = do g <- newGenIO:: IO SystemRandom case runCRand impl g of Left err -> throwIO err Right (v, g') -> return v where impl = do w1 <- getCRandom w2 <- getCRandom w3 <- getCRandom w4 <- getCRandom return $ UUID.fromWords w1 w2 w3 w4 ...but the compilation fails miserably with: • Ambiguous type variable ‘e0’ arising from a use of ‘runCRand’ prevents the constraint ‘(ContainsGenError e0)’ from being solved. Relevant bindings include impl :: CRandT SystemRandom e0 Data.Functor.Identity.Identity UUID.UUID (bound at src/Party.hs:75:9) Probable fix: use a type annotation to specify what ‘e0’ should be. These potential instance exist: instance ContainsGenError GenError -- Defined in ‘Control.Monad.CryptoRandom’ • In the expression: runCRand impl g In a stmt of a 'do' block: case runCRand impl g of { Left err -> throwIO err Right (v, g') -> return v } In the expression: do { g <- newGenIO :: IO SystemRandom; case runCRand impl g of { Left err -> throwIO err Right (v, g') -> return v } } ... What's the problem here? Are there some good examples for generating crypto-randoms? Thanks!

2 3

Parse file with existentials
by Dmitriy Matrosov 13 Dec '16

13 Dec '16

> {-# LANGUAGE GADTs #-} > {-# LANGUAGE DataKinds #-} > {-# LANGUAGE RankNTypes #-} > {-# LANGUAGE KindSignatures #-} > {-# LANGUAGE StandaloneDeriving #-} > {-# LANGUAGE FlexibleInstances #-} > {-# LANGUAGE DeriveDataTypeable #-} > > import Prelude hiding (getLine) > import Data.Maybe > import Data.List > import Data.Typeable > import Control.Monad.Identity > import Control.Monad.Trans.Identity > import Control.Monad.Writer > import Control.Applicative > import System.FilePath Hi. I ask for an opinion about interface (implemented below) for parsing `rsync` filter files. The parser does not parse full syntax, i wrote it for determining rsync filter dependencies, when installing them using `shake`. So, i distinguish two kinds of lines: include of another filter file, which looks like . file and any other. I want to distinguish them at type level, so e.g. a record function for one constructor can't be applied to another, etc. I know, that i can prevent this at runtime by exporting only smart constructor, but i want a type check. > data RsyncFilterT = IncludeT | LineT > type IncludeT = 'IncludeT > type LineT = 'LineT > > -- Particular rsync filters distinguishable at type-level. > data RsyncFilter :: RsyncFilterT -> * where > Include :: {getInclude :: FilePath} -> RsyncFilter 'IncludeT > Line :: {getLine :: String} -> RsyncFilter 'LineT > deriving instance Show (RsyncFilter a) > deriving instance Typeable RsyncFilter For accessing records i use lenses redefined here. I redefine them with `Applicative` instead of `Functor` to make modify/set work even if value does not have a required record (by returning original (unmodified) value using `pure`). > type LensA a b = forall f. Applicative f => (b -> f b) -> a -> f a > > viewA :: LensA a b -> a -> b > viewA l = fromJust . getLast . getConst . l (Const . Last . Just) > viewAmaybe :: LensA a b -> a -> Maybe b > viewAmaybe l = getLast . getConst . l (Const . Last . Just) > > modifyA :: LensA a b -> (b -> b) -> a -> a > modifyA l f = runIdentity . l (Identity . f) > > modifyAA :: Applicative t => LensA a b -> (b -> t b) -> a -> t a > modifyAA l f = runIdentityT . l (IdentityT . f) > > setA :: LensA a b -> b -> a -> a > setA l s = modifyA l (const s) Here're lenses for `RsyncFilter` (its constructors are distinguishable at type-level, so i don't really need `Applicative` lenses here): > includeL :: LensA (RsyncFilter 'IncludeT) FilePath > includeL f z@Include {getInclude = x} = > fmap (\x' -> z{getInclude = x'}) (f x) > lineL :: LensA (RsyncFilter 'LineT) FilePath > lineL f z@Line {getLine = x} = > fmap (\x' -> z{getLine = x'}) (f x) The order of lines (may) matter, so i need to store all `RsyncFilter a` values in a list in original file order. But now the values are of different type. So.. i use existential container: > -- Generic container for any type of rsync filter. > data AnyFilter = forall (a :: RsyncFilterT). Typeable a => > AnyFilter (RsyncFilter a) > deriving instance Show AnyFilter > deriving instance Typeable AnyFilter And still i want to work on values of certain type to have some guarantees against misuse, so i need to cast `AnyFilter` back into `RsyncFilter` value: > -- Extract rsync filter from AnyFilter. > getFilter :: (forall (a :: RsyncFilterT). Typeable a => > RsyncFilter a -> b) -> AnyFilter -> b > getFilter f (AnyFilter x) = f x and here i also want to use lenses, but now the value may be of different type, that the lens expect, so i really need `Applicative` lenses here: > rsyncIncludeL' :: LensA AnyFilter (RsyncFilter 'IncludeT) > rsyncIncludeL' f z = maybe (pure z) (fmap AnyFilter . f) (getFilter cast z) > rsyncIncludeL :: LensA AnyFilter FilePath > rsyncIncludeL = rsyncIncludeL' . includeL > > rsyncLineL' :: LensA AnyFilter (RsyncFilter 'LineT) > rsyncLineL' f z = maybe (pure z) (fmap AnyFilter . f) > (getFilter cast z) > rsyncLineL :: LensA AnyFilter String > rsyncLineL = rsyncLineL' . lineL Then i define another Read/Show class just to be able to keep default Read/Show instances: > class Serialize a where > fromString :: String -> Maybe a > toString :: a -> String > > instance Serialize (RsyncFilter 'LineT) where > fromString = Just . Line > toString (Line xs) = xs > > -- RULE and PATTERN separator is space (`_` not supported). > -- Only short rule names without modifiers are supported. > instance Serialize (RsyncFilter 'IncludeT) where > fromString = go . break (== ' ') > where > go :: (String, String) -> Maybe (RsyncFilter 'IncludeT) > go (r, _ : x : xs) > | r == "." = Just (Include (x : xs)) > go _ = Nothing > toString (Include xs) = ". " ++ xs > > instance Serialize AnyFilter where > fromString x = > fmap AnyFilter (fromString x :: Maybe (RsyncFilter 'IncludeT)) > <|> fmap AnyFilter (fromString x :: Maybe (RsyncFilter 'LineT)) > toString x = fromMaybe "" $ > fmap toString (viewAmaybe rsyncIncludeL' x) > <|> fmap toString (viewAmaybe rsyncLineL' x) and a lens from String to AnyFilter, which effectively parses file and writes it back: > rsyncAnyL :: LensA String AnyFilter > rsyncAnyL f z = maybe (pure z) (fmap toString . f) (fromString z) And here is how i use this: > -- | Replace path prefix, if matched. > replacePrefix :: FilePath -> FilePath -> FilePath -> FilePath > replacePrefix old new x = maybe x (combine new . joinPath) $ > -- For ensuring that path prefix starts and ends at path > -- components (directories) boundaries, i first split them. > stripPrefix (splitDirectories old) (splitDirectories x) > > -- | Rewrite path in rsync inlcude line @line@ from source path > -- @srcdir@ to install path @prefix@ > -- > -- > usedIncludes srcdir prefix line > -- > -- and collect (rewritten) rsync include pathes in @Writer@ monad. > -- Other lines return as is. > usedIncludes :: FilePath -- ^ Source path. > -> FilePath -- ^ Install path. > -> String -- ^ Line from rsync filter file. > -> Writer [FilePath] String > usedIncludes srcdir prefix = > modifyAA (rsyncAnyL . rsyncIncludeL) $ \x -> do > let x' = replacePrefix srcdir prefix x > tell [x'] > return x' and then a shake rule: -- | Add file rule for instaling rsync filters with extension -- @ext@, rewriting source path @srcdir@ to install path @prefix@ -- in any rsync includes: -- -- > rsyncFilter ext srcdir prefix -- rsyncFilter :: String -- ^ Extension. -> FilePath -- ^ Install path. -> FilePath -- ^ Source path. -> Rules () rsyncFilter ext prefix srcdir = prefix ++ "//*" <.> ext %> \out -> do let src = replacePrefix prefix srcdir out ls <- readFileLines src let (rs, incs) = runWriter $ mapM (usedIncludes srcdir prefix) ls need incs putNormal $ "> Write " ++ out writeFileChanged out . unlines $ rs I probably won't think too much about this API, if i haven't read [Luke Palmer's post about existentials][1] . And now i doubt, did i fall into the same trap with existentials and does not see an obvious solution with functions? [1]: https://lukepalmer.wordpress.com/2010/01/24/haskell-antipattern-existential… -- Dmitriy Matrosov

1 0

Real World Haskell: Deprecated Libraries
by John Ky 28 Nov '16

28 Nov '16

Hello Haskellers, I have been working through the Real World Haskell chapter on Profiling and Optimisation <http://book.realworldhaskell.org/read/profiling-and-optimization.html>, and got to the section *Advanced techniques: fusion*, where I encountered some code using Data.Array.Vector from the deprecated library uvector. Does anyone know how to rewrite this to not use deprecated libraries? I have tried to use Data.Vector.Unboxed from vector, but my version consumes a lot of memory. The code I have is here: https://github.com/haskell-works/hw-tutorial-performance/blob/master/hw-tut… With that code, I get “1831 MB total memory in use”, which is terrible Build run steps I used were: stack build --executable-profiling --library-profiling --ghc-options="-fprof-auto -rtsopts -auto-all -caf-all -fforce-recomp" time /Users/jky/wrk/haskell-works/hw-tutorial-performance/.stack-work/install/x86_64-osx/lts-7.10/8.0.1/bin/hw-tutorial-performance-rwhe +RTS -sstderr -p -hy -RTS 1e7 I get very large numbers of allocations of Pair and Double. There is also a very large upfront allocation ARR_WORDS, which I feared would happen when using Data.Vector Any help appreciated. Cheers, -John

2 2

Setting up WXHaskell on the 8.0.1 platform?
by Cleverson Casarin Uliana 28 Nov '16

28 Nov '16

Hello all, I've sent this to the WXHaskell list, but no answers. Please what is the recommended way to set up WXWidgets and WXHaskell for the 8.0.1 Haskell Platform on Windows? I tried using the Achelanne installer, but it gives errors apparently related to packages versions incompatibilities. Thanks, Cleverson

2 1

pattern matching on a common element
by briand＠aracnet.com 26 Nov '16

26 Nov '16

Here's what I'm doing: data X = A1 String Double | A2 String Int | A3 String Double Int name c = case c of A1 name _ -> name A2 name _ -> name A3 name _ _ -> name I'm sure there's a better way...

5 10