Send Beginners mailing list submissions to
beginners@haskell.org
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
[EMAIL PROTECTED]
You can reach the person managing the list at
[EMAIL PROTECTED]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. help ([EMAIL PROTECTED])
2. Re: Type polymorphism with size (Brent Yorgey)
3. Re: Type polymorphism with size (David Frey)
----------------------------------------------------------------------
Message: 1
Date: Tue, 18 Nov 2008 16:20:47 -0600
From: [EMAIL PROTECTED]
Subject: [Haskell-beginners] help
To: beginners@haskell.org
Message-ID: <[EMAIL PROTECTED]>
Content-Type: text/plain; charset="ISO-8859-1"
On Tue, 18 Nov 2008 17:12:57 -0500 (EST), [EMAIL PROTECTED]
said:
> Send Beginners mailing list submissions to
> beginners@haskell.org
>
> To subscribe or unsubscribe via the World Wide Web, visit
> http://www.haskell.org/mailman/listinfo/beginners
> or, via email, send a message with subject or body 'help' to
> [EMAIL PROTECTED]
>
> You can reach the person managing the list at
> [EMAIL PROTECTED]
>
> When replying, please edit your Subject line so it is more specific
> than "Re: Contents of Beginners digest..."
>
>
> Today's Topics:
>
> 1. Re: Profiling haskell code (Brent Yorgey)
> 2. Parsing arithmentic expressions (Glurk)
> 3. Re: Parsing arithmentic expressions (Bernie Pope)
> 4. RE: Profiling haskell code (Sayali Kulkarni)
> 5. Re: Profiling haskell code (Brent Yorgey)
> 6. Type polymorphism with size (Michael Snoyman)
> 7. Re: Type polymorphism with size (Brent Yorgey)
> 8. Re: Type polymorphism with size (Michael Snoyman)
>
>
> ----------------------------------------------------------------------
>
> Message: 1
> Date: Fri, 14 Nov 2008 15:53:34 -0500
> From: Brent Yorgey <[EMAIL PROTECTED]>
> Subject: Re: [Haskell-beginners] Profiling haskell code
> To: beginners@haskell.org
> Message-ID: <[EMAIL PROTECTED]>
> Content-Type: text/plain; charset=us-ascii
>
> >
> > quicksort [ ] = [ ]
> >
> > quicksort (x : xs) = quicksort larger ++ [x ] ++ quicksort smaller
> >
> >
> > where
> >
> >
> > smaller = [a | a <- xs, a <= x ]
> >
> >
> > larger = [b | b <- xs, b > x ]
> >
> >
> >
> >
> >
> > When I compile the code with the following command :
> >
> >
> >
> > $ ghc --make Project.hs -prof -auto-all
> >
> > Then I tested it with the following command :
> >
> > $ Project +RTS -p
> >
> > It generates the .hi and the .o file but I cannot get the .prof file.
> >
> > Please let me know if any of the steps is missing or where could I check
> > my profiling info.
> >
>
> Hi Sayali,
>
> Is the code shown above *everything* in your Project.hs file? You
> will also need a main function for it to actually do anything. If
> there is more to your Project.hs file that you have not shown, could
> you send the complete version?
>
> Do you get any errors? Does Project produce the output that you expect?
>
> -Brent
>
>
> ------------------------------
>
> Message: 2
> Date: Sun, 16 Nov 2008 00:15:29 +0000 (UTC)
> From: Glurk <[EMAIL PROTECTED]>
> Subject: [Haskell-beginners] Parsing arithmentic expressions
> To: beginners@haskell.org
> Message-ID: <[EMAIL PROTECTED]>
> Content-Type: text/plain; charset=us-ascii
>
> Hi,
>
> I'm just trying to learn how to use Parsec and am experimenting with
> parsing
> arithmetic expressions.
>
> This article gives a good example ->
> http://www.haskell.org/haskellwiki/Parsing_expressions_and_statements
>
> However, like most other examples I could find, the grammar for the
> expression
> doesn't take operator precedence into account, and allows for expressions
> of
> any size by defining expr recursively, eg :-
>
> expr ::= var | const | ( expr ) | unop expr | expr duop expr
>
> So, you can keep extending the expression by adding another operator and
> expression.
>
> The data to hold the expression is then very easily derived :-
>
> data Expr = Var String | Con Bool | Uno Unop Expr | Duo Duop Expr Expr
>
> The grammar I want to parse is slightly different in that it allows for
> operator precendence. Part of the grammar is something like :-
>
> expression = SimpleExpression {relation SimpleExpression}.
> SimpleExpression = ["+"|"-"] term {AddOperator term}.
>
> So, instead of recursively defining expression, it is made up of
> multiples
> occurrences of SimpleExpression joined together with Relation operators.
>
> Where I am confused is how I should best represent this stucture in my
> data.
> Should I have something like :-
>
> data Expr = Expr SimpleExpr [(RelOp, SimpleExpression)]
>
> ie, an initial SimpleExpr, followed by a list of operator and
> SimpleExpression
> pairs.
>
> I haven't seen any example similar to this, so I was wondering if I'm
> going
> down the wrong track ?
>
> Perhaps another alternative is to modify the grammar somehow ?
>
> I guess, the question is, in general how do you handle such repeated
> elements
> as definied in an EBNF grammar, in structuring your data ?
>
> Any advice appreciated !
>
> Thanks :)
>
>
>
> ------------------------------
>
> Message: 3
> Date: Mon, 17 Nov 2008 16:35:02 +1100
> From: Bernie Pope <[EMAIL PROTECTED]>
> Subject: Re: [Haskell-beginners] Parsing arithmentic expressions
> To: Glurk <[EMAIL PROTECTED]>
> Cc: beginners@haskell.org
> Message-ID: <[EMAIL PROTECTED]>
> Content-Type: text/plain; charset=US-ASCII; format=flowed; delsp=yes
>
> Hi,
>
> Have you seen the buildExpressionParser combinator in Parsec?
>
>
> http://legacy.cs.uu.nl/daan/download/parsec/parsec.html#buildExpressionParser
>
> It allows you to specify precedence and associativity for operator
> parsers declaratively, and it generally saves you from lots of
> refactoring in the grammar.
>
> You could probably stick with the straightforward data representation
> of expressions.
>
> Cheers,
> Bernie.
>
> On 16/11/2008, at 11:15 AM, Glurk wrote:
>
> > Hi,
> >
> > I'm just trying to learn how to use Parsec and am experimenting with
> > parsing
> > arithmetic expressions.
> >
> > This article gives a good example ->
> > http://www.haskell.org/haskellwiki/Parsing_expressions_and_statements
> >
> > However, like most other examples I could find, the grammar for the
> > expression
> > doesn't take operator precedence into account, and allows for
> > expressions of
> > any size by defining expr recursively, eg :-
> >
> > expr ::= var | const | ( expr ) | unop expr | expr duop expr
> >
> > So, you can keep extending the expression by adding another operator
> > and
> > expression.
> >
> > The data to hold the expression is then very easily derived :-
> >
> > data Expr = Var String | Con Bool | Uno Unop Expr | Duo Duop Expr Expr
> >
> > The grammar I want to parse is slightly different in that it allows
> > for
> > operator precendence. Part of the grammar is something like :-
> >
> > expression = SimpleExpression {relation SimpleExpression}.
> > SimpleExpression = ["+"|"-"] term {AddOperator term}.
> >
> > So, instead of recursively defining expression, it is made up of
> > multiples
> > occurrences of SimpleExpression joined together with Relation
> > operators.
> >
> > Where I am confused is how I should best represent this stucture in
> > my data.
> > Should I have something like :-
> >
> > data Expr = Expr SimpleExpr [(RelOp, SimpleExpression)]
> >
> > ie, an initial SimpleExpr, followed by a list of operator and
> > SimpleExpression
> > pairs.
> >
> > I haven't seen any example similar to this, so I was wondering if
> > I'm going
> > down the wrong track ?
> >
> > Perhaps another alternative is to modify the grammar somehow ?
> >
> > I guess, the question is, in general how do you handle such repeated
> > elements
> > as definied in an EBNF grammar, in structuring your data ?
> >
> > Any advice appreciated !
> >
> > Thanks :)
> >
> > _______________________________________________
> > Beginners mailing list
> > Beginners@haskell.org
> > http://www.haskell.org/mailman/listinfo/beginners
>
>
>
> ------------------------------
>
> Message: 4
> Date: Mon, 17 Nov 2008 09:35:26 +0530
> From: "Sayali Kulkarni" <[EMAIL PROTECTED]>
> Subject: RE: [Haskell-beginners] Profiling haskell code
> To: "Brent Yorgey" <[EMAIL PROTECTED]>, <beginners@haskell.org>
> Message-ID: <[EMAIL PROTECTED]>
> Content-Type: text/plain; charset="us-ascii"
>
> Hello Brent,
>
> I just have written a quick sort program.
> There is nothing more in the code than that I have shown.
>
> What is it about the main function?
> What do I need to do in the main function?
>
> I do not get any errors.
> And I get the expected output. The only thing that I am stuck at is that
> I do not get the ".prof" file which will give me the profile details of
> the code.
>
> Also it would be great if you could through a light on whether there is
> any other method to profile a code in Haskell?
>
> Regards,
> Sayali.
>
> -----Original Message-----
> From: [EMAIL PROTECTED]
> [mailto:[EMAIL PROTECTED] On Behalf Of Brent Yorgey
> Sent: Saturday, November 15, 2008 2:24 AM
> To: beginners@haskell.org
> Subject: Re: [Haskell-beginners] Profiling haskell code
>
> >
> > quicksort [ ] = [ ]
> >
> > quicksort (x : xs) = quicksort larger ++ [x ] ++ quicksort smaller
> >
> >
> > where
> >
> >
> > smaller = [a | a <- xs, a <= x ]
> >
> >
> > larger = [b | b <- xs, b > x ]
> >
> >
> >
> >
> >
> > When I compile the code with the following command :
> >
> >
> >
> > $ ghc --make Project.hs -prof -auto-all
> >
> > Then I tested it with the following command :
> >
> > $ Project +RTS -p
> >
> > It generates the .hi and the .o file but I cannot get the .prof file.
> >
> > Please let me know if any of the steps is missing or where could I
> check
> > my profiling info.
> >
>
> Hi Sayali,
>
> Is the code shown above *everything* in your Project.hs file? You
> will also need a main function for it to actually do anything. If
> there is more to your Project.hs file that you have not shown, could
> you send the complete version?
>
> Do you get any errors? Does Project produce the output that you expect?
>
> -Brent
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
>
> ------------------------------
>
> Message: 5
> Date: Mon, 17 Nov 2008 09:07:57 -0500
> From: Brent Yorgey <[EMAIL PROTECTED]>
> Subject: Re: [Haskell-beginners] Profiling haskell code
> To: beginners@haskell.org
> Message-ID: <[EMAIL PROTECTED]>
> Content-Type: text/plain; charset=us-ascii
>
> On Mon, Nov 17, 2008 at 09:35:26AM +0530, Sayali Kulkarni wrote:
> > Hello Brent,
> >
> > I just have written a quick sort program.
> > There is nothing more in the code than that I have shown.
> >
> > What is it about the main function?
> > What do I need to do in the main function?
> >
> > I do not get any errors.
> > And I get the expected output. The only thing that I am stuck at is that
> > I do not get the ".prof" file which will give me the profile details of
> > the code.
> >
> > Also it would be great if you could through a light on whether there is
> > any other method to profile a code in Haskell?
> >
> > Regards,
> > Sayali.
>
> Hi Sayali,
>
> Just writing a quicksort function by itself is fine if you want to
> test it interactively in ghci. But if you want to profile it you will
> have to make an executable, which means you will need a 'main'
> function which says what to do when the program is run. Your main
> function might look something like this:
>
> main = do print "Sorting..."
> print (length (quicksort (reverse [1..1000000])))
> print "Done!"
>
> Of course, sorting a list in reverse order might not be a very
> representative task; you might also want to look into the
> System.Random module to generate a list of a million random elements
> and sort that.
>
> -Brent
>
> >
> > -----Original Message-----
> > From: [EMAIL PROTECTED]
> > [mailto:[EMAIL PROTECTED] On Behalf Of Brent Yorgey
> > Sent: Saturday, November 15, 2008 2:24 AM
> > To: beginners@haskell.org
> > Subject: Re: [Haskell-beginners] Profiling haskell code
> >
> > >
> > > quicksort [ ] = [ ]
> > >
> > > quicksort (x : xs) = quicksort larger ++ [x ] ++ quicksort smaller
> > >
> > >
> > > where
> > >
> > >
> > > smaller = [a | a <- xs, a <= x ]
> > >
> > >
> > > larger = [b | b <- xs, b > x ]
> > >
> > >
> > >
> > >
> > >
> > > When I compile the code with the following command :
> > >
> > >
> > >
> > > $ ghc --make Project.hs -prof -auto-all
> > >
> > > Then I tested it with the following command :
> > >
> > > $ Project +RTS -p
> > >
> > > It generates the .hi and the .o file but I cannot get the .prof file.
> > >
> > > Please let me know if any of the steps is missing or where could I
> > check
> > > my profiling info.
> > >
> >
> > Hi Sayali,
> >
> > Is the code shown above *everything* in your Project.hs file? You
> > will also need a main function for it to actually do anything. If
> > there is more to your Project.hs file that you have not shown, could
> > you send the complete version?
> >
> > Do you get any errors? Does Project produce the output that you expect?
> >
> > -Brent
> > _______________________________________________
> > Beginners mailing list
> > Beginners@haskell.org
> > http://www.haskell.org/mailman/listinfo/beginners
> >
>
>
> ------------------------------
>
> Message: 6
> Date: Tue, 18 Nov 2008 10:02:20 -0800
> From: "Michael Snoyman" <[EMAIL PROTECTED]>
> Subject: [Haskell-beginners] Type polymorphism with size
> To: beginners@haskell.org
> Message-ID:
> <[EMAIL PROTECTED]>
> Content-Type: text/plain; charset="utf-8"
>
> I am trying to write some code to read flat files from a mainframe
> system.
> This includes some character fields. This is a fixed width file, so each
> field will have a consistent length between records, but there are fields
> of
> different length within a record. For example, I might have a "name"
> field
> length 20 and an eye color field length 5.
>
> I am trying to use the binary library to read in this file. I've written
> a
> binary type, MFChar2, for reading in a 2-length character field. It is
> defined as such (you can safely ignore the ebcdicToAscii piece, it is
> just
> doing character conversion):
>
> data MFChar2 = MFChar2 [Word8]
> instance Binary MFChar2 where
> put = undefined
> get = do ebcdic <- replicateM 2 getWord8
> return $ MFChar2 $ map ebcdicToAscii ebcdic
>
> What I would like to do is have some kind of generic "MFChar" data type
> which could take any character length, but I can't figure out how to do
> it.
> Any help would be appreciated.
>
> Thanks,
> Michael
> -------------- next part --------------
> An HTML attachment was scrubbed...
> URL:
> http://www.haskell.org/pipermail/beginners/attachments/20081118/3349841f/attachment-0001.htm
>
> ------------------------------
>
> Message: 7
> Date: Tue, 18 Nov 2008 14:18:22 -0500
> From: Brent Yorgey <[EMAIL PROTECTED]>
> Subject: Re: [Haskell-beginners] Type polymorphism with size
> To: beginners@haskell.org
> Message-ID: <[EMAIL PROTECTED]>
> Content-Type: text/plain; charset=us-ascii
>
> On Tue, Nov 18, 2008 at 10:02:20AM -0800, Michael Snoyman wrote:
> > I am trying to write some code to read flat files from a mainframe system.
> > This includes some character fields. This is a fixed width file, so each
> > field will have a consistent length between records, but there are fields of
> > different length within a record. For example, I might have a "name" field
> > length 20 and an eye color field length 5.
> >
> > I am trying to use the binary library to read in this file. I've written a
> > binary type, MFChar2, for reading in a 2-length character field. It is
> > defined as such (you can safely ignore the ebcdicToAscii piece, it is just
> > doing character conversion):
> >
> > data MFChar2 = MFChar2 [Word8]
> > instance Binary MFChar2 where
> > put = undefined
> > get = do ebcdic <- replicateM 2 getWord8
> > return $ MFChar2 $ map ebcdicToAscii ebcdic
> >
> > What I would like to do is have some kind of generic "MFChar" data type
> > which could take any character length, but I can't figure out how to do it.
> > Any help would be appreciated.
>
> Hm, interesting! The problem is that 'get' does not take any
> arguments, so must determine what to do from the type at which it is
> called. So the number of words to be read needs to be in the type.
> We can't put actual Int values in a type -- but there is actually a
> way to do what you want, by encoding natural numbers at the type
> level! I don't know whether this really belongs on a 'beginners' list
> but I couldn't resist. =)
>
>
> data Z -- the type representing zero
> data S n -- the type representing the successor of another natural
>
> -- for example, Z, S Z, and S (S Z) are types representing
> -- zero, one, and two.
>
> -- the n is for a type-level natural representing the length of the list.
> data MFChar n = MFChar [Word8]
>
> -- add a Word8 to the beginning of an MFChar, resulting in an MFChar
> -- one word longer
> mfCons :: Word8 -> MFChar n -> MFChar (S n)
> mfCons w (MFChar ws) = MFChar (w:ws)
>
> instance Binary (MFChar Z) where
> get = return $ MFChar []
>
> instance (Binary (MFChar n)) => Binary (MFChar (S n)) where
> get = do ebcdic <- getWord8
> rest <- get -- the correct type of get is
> -- inferred due to the use of mfCons below
> return $ mfCons (ebcdicToAscii ebcdic) rest
>
>
> Now if you wanted to read a field with 20 chars, you can use
>
> get :: Get (MFChar (S (S (S ... 20 S's ... Z))))
>
> Ugly, I know. You could make it slightly more bearable by defining
> some type synonyms at the top of your program like
>
> type Five = S (S (S (S (S Z))))
> type Ten = S (S (S (S (S Five))))
>
> and so on. Then you can just say get :: Get (MFChar Ten) or whatever.
>
> This is untested but it (or something close to it) ought to work. Of
> course, you may well ask yourself whether this contortion is really
> worth it. Maybe it is, maybe it isn't, but I can't think of a better
> way to do it in Haskell. In a dependently typed language such as
> Agda, we could just put regular old natural numbers in the types,
> instead of going through contortions to encode natural numbers as
> types as we have to do here. So I guess the real answer to your
> question is "use a dependently typed language". =)
>
> If you have problems getting this to work or more questions, feel free
> to ask!
>
> -Brent
>
>
> ------------------------------
>
> Message: 8
> Date: Tue, 18 Nov 2008 14:18:46 -0800
> From: "Michael Snoyman" <[EMAIL PROTECTED]>
> Subject: Re: [Haskell-beginners] Type polymorphism with size
> To: "Brent Yorgey" <[EMAIL PROTECTED]>
> Cc: beginners@haskell.org
> Message-ID:
> <[EMAIL PROTECTED]>
> Content-Type: text/plain; charset="utf-8"
>
> On Tue, Nov 18, 2008 at 11:18 AM, Brent Yorgey
> <[EMAIL PROTECTED]>wrote:
>
> > Hm, interesting! The problem is that 'get' does not take any
> > arguments, so must determine what to do from the type at which it is
> > called. So the number of words to be read needs to be in the type.
> > We can't put actual Int values in a type -- but there is actually a
> > way to do what you want, by encoding natural numbers at the type
> > level! I don't know whether this really belongs on a 'beginners' list
> > but I couldn't resist. =)
> >
> >
> > data Z -- the type representing zero
> > data S n -- the type representing the successor of another natural
> >
> > -- for example, Z, S Z, and S (S Z) are types representing
> > -- zero, one, and two.
> >
> > -- the n is for a type-level natural representing the length of the list.
> > data MFChar n = MFChar [Word8]
> >
> > -- add a Word8 to the beginning of an MFChar, resulting in an MFChar
> > -- one word longer
> > mfCons :: Word8 -> MFChar n -> MFChar (S n)
> > mfCons w (MFChar ws) = MFChar (w:ws)
> >
> > instance Binary (MFChar Z) where
> > get = return $ MFChar []
> >
> > instance (Binary (MFChar n)) => Binary (MFChar (S n)) where
> > get = do ebcdic <- getWord8
> > rest <- get -- the correct type of get is
> > -- inferred due to the use of mfCons below
> > return $ mfCons (ebcdicToAscii ebcdic) rest
> >
> >
> > Now if you wanted to read a field with 20 chars, you can use
> >
> > get :: Get (MFChar (S (S (S ... 20 S's ... Z))))
> >
> > Ugly, I know. You could make it slightly more bearable by defining
> > some type synonyms at the top of your program like
> >
> > type Five = S (S (S (S (S Z))))
> > type Ten = S (S (S (S (S Five))))
> >
> > and so on. Then you can just say get :: Get (MFChar Ten) or whatever.
> >
> > This is untested but it (or something close to it) ought to work. Of
> > course, you may well ask yourself whether this contortion is really
> > worth it. Maybe it is, maybe it isn't, but I can't think of a better
> > way to do it in Haskell. In a dependently typed language such as
> > Agda, we could just put regular old natural numbers in the types,
> > instead of going through contortions to encode natural numbers as
> > types as we have to do here. So I guess the real answer to your
> > question is "use a dependently typed language". =)
> >
> > If you have problems getting this to work or more questions, feel free
> > to ask!
> >
>
> Very interesting solution to the problem. I tried it out and it works
> perfectly... but it's just too much of a hack for my tastes (no offense;
> I
> think it was very cool). I thought about it a bit and realized what I
> really
> want is a way to deal with tuples of the same type, which led to this
> kind
> of implementation.
>
> class RepTuple a b | a -> b where
> toList :: a -> [b]
> tMap :: (b -> b) -> a -> a
>
> instance RepTuple (a, a) a where
> toList (a, b) = [a, b]
> tMap f (a, b) = (f a, f b)
>
> And so on and so forth for every kind of tuple. Of course, this runs into
> the issue of the single case, for which I used the OneTuple library
> (actually, I wrote my own right now, but I intend to just use the
> OneTuple
> library).
>
> I can then do something like this (which I have tested and works):
>
> data MFChar w = MFChar w
> deriving Eq
> instance (RepTuple w a, Integral a) => Show (MFChar w) where
> show (MFChar ws) = map (chr . fromIntegral) $ toList ws
> instance (Integral a, Binary w, RepTuple w a) => Binary (MFChar w) where
> put = undefined
> get = do ebcdic <- get
> let ascii = tMap ebcdicToAscii ebcdic
> return $ MFChar ascii
>
> type MFChar1 = MFChar (OneTuple Word8)
> type MFChar2 = MFChar (Word8, Word8)
> type MFChar4 = MFChar (Word8, Word8, Word8, Word8)
> type MFChar5 = MFChar (Word8, Word8, Word8, Word8, Word8)
> type MFChar10 = MFChar (Word8, Word8, Word8, Word8, Word8,
> Word8, Word8, Word8, Word8, Word8)
>
> If I wanted, I could do away with the tMap function and just include the
> ebcdicToAscii step in the show instance.
>
> Michael
> -------------- next part --------------
> An HTML attachment was scrubbed...
> URL:
> http://www.haskell.org/pipermail/beginners/attachments/20081118/8a75bca1/attachment.htm
>
> ------------------------------
>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
>
> End of Beginners Digest, Vol 5, Issue 10
> ****************************************
--
israel orange
[EMAIL PROTECTED]
------------------------------
Message: 2
Date: Tue, 18 Nov 2008 20:16:37 -0500
From: Brent Yorgey <[EMAIL PROTECTED]>
Subject: Re: [Haskell-beginners] Type polymorphism with size
To: beginners@haskell.org
Message-ID: <[EMAIL PROTECTED]>
Content-Type: text/plain; charset=us-ascii
On Tue, Nov 18, 2008 at 02:18:46PM -0800, Michael Snoyman wrote:
>
> Very interesting solution to the problem. I tried it out and it works
> perfectly... but it's just too much of a hack for my tastes (no offense; I
None taken. =)
>
> class RepTuple a b | a -> b where
> toList :: a -> [b]
> tMap :: (b -> b) -> a -> a
>
> instance RepTuple (a, a) a where
> toList (a, b) = [a, b]
> tMap f (a, b) = (f a, f b)
>
> And so on and so forth for every kind of tuple. Of course, this runs into
> the issue of the single case, for which I used the OneTuple library
> (actually, I wrote my own right now, but I intend to just use the OneTuple
> library).
>
This is reasonable too. It's just a tradeoff of hackishness vs. code
length/tediousness. I.e. in the solution with type-level naturals, you
don't need a separate instance like this for every number you're going
to use. And no one really likes writing things like
tMap f (a,b,c,d,e,g,h,i,j) = ... =)
-Brent
------------------------------
Message: 3
Date: Tue, 18 Nov 2008 19:58:24 -0800
From: "David Frey" <[EMAIL PROTECTED]>
Subject: Re: [Haskell-beginners] Type polymorphism with size
To: "beginners@haskell.org" <beginners@haskell.org>
Message-ID: <[EMAIL PROTECTED]>
Content-Type: text/plain; charset=ISO-8859-1
On 11/18/2008, "Michael Snoyman" <[EMAIL PROTECTED]> wrote:
>I am trying to write some code to read flat files from a mainframe system.
>This includes some character fields. This is a fixed width file, so each
>field will have a consistent length between records, but there are fields of
>different length within a record. For example, I might have a "name" field
>length 20 and an eye color field length 5.
>
>I am trying to use the binary library to read in this file. I've written a
>binary type, MFChar2, for reading in a 2-length character field. It is
>defined as such (you can safely ignore the ebcdicToAscii piece, it is just
>doing character conversion):
>
>data MFChar2 = MFChar2 [Word8]
>instance Binary MFChar2 where
> put = undefined
> get = do ebcdic <- replicateM 2 getWord8
> return $ MFChar2 $ map ebcdicToAscii ebcdic
>
>What I would like to do is have some kind of generic "MFChar" data type
>which could take any character length, but I can't figure out how to do it.
>Any help would be appreciated.
>
>Thanks,
>Michael
Is this something that could be accomplished using template Haskell? I
don't know anything about template Haskell, but maybe someone else on
the list can comment on this suggestion.
------------------------------
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 5, Issue 11
****************************************
