Greetings All, While I admire Haskell enormously, as a an intermediate beginner I find it difficult to know what is normal Haskell style for real world programming. On the subject of monad transformers, the paper by Martin Grabümller titled 'Monad Transformers Step by Step' gives an example of an evaluator using monad transformers with the following type: type Eval6 α = ReaderT Env (ErrorT String (WriterT [String] (StateT Integer IO))) α Is this how normal Haskell is developed and written in practice? I find the type and the function impenetrably dense and difficult to understand. Should I be aspiring to have my functions look and work like this? Of course it depends on what you want to do, but the essence of the question is, does Haskell ultimately end up looking like this for any real programming, beyond textbook list manipulation functions? Andrew
On Fri, Sep 18, 2015 at 9:00 PM, Andrew Bernard
Is this how normal Haskell is developed and written in practice? I find the type and the function impenetrably dense and difficult to understand. Should I be aspiring to have my functions look and work like this? Of course it depends on what you want to do, but the essence of the question is, does Haskell ultimately end up looking like this for any real programming, beyond textbook list manipulation functions?
If you need that, then yes. If not, then no. Usually that kind of thing is packaged up in higher level libraries; the type Eval6 would be exposed, the underlying stuff is used internally and you would not normally need to know or care about it unless you were specifically working on the internals of that library. Most applications you would write, you only care about Eval6 and any functions exported along with it. That said, I think in most cases you would use a newtype and derive through MonadReader, MonadError, MonadState, and MonadIO so you can ignore precisely how the type was built and just use it. -- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
Hi, I am also something of a beginner in Haskell and have to say I am slowly getting to see that many things that once looked impenetrable are starting to clear up for me. I am basically developing the intuitions that work in the Haskell world - different intuitions from those I acquired when I worked using imperative languages. So possibly even advanced Haskell code is not impenetrable by nature - it's just different - and once you get over the initial difficulty it'll then look clear and not that dense at all? Martin Andrew Bernard:
Greetings All,
While I admire Haskell enormously, as a an intermediate beginner I find it difficult to know what is normal Haskell style for real world programming. On the subject of monad transformers, the paper by Martin Grabümller titled 'Monad Transformers Step by Step' gives an example of an evaluator using monad transformers with the following type:
type Eval6 α = ReaderT Env (ErrorT String (WriterT [String] (StateT Integer IO))) α
Is this how normal Haskell is developed and written in practice? I find the type and the function impenetrably dense and difficult to understand. Should I be aspiring to have my functions look and work like this? Of course it depends on what you want to do, but the essence of the question is, does Haskell ultimately end up looking like this for any real programming, beyond textbook list manipulation functions?
Andrew
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
Hi. I am a beginner too.
For the most part I agree with you, except that Haskell is, in my opinion, a dense language per se.
Haskell is more poetry than prose; you do not read/write a poem like a novel.
Whether you are new to this language or master it, it is dense.
Guillaume
Hi, I am also something of a beginner in Haskell and have to say I am slowly getting to see that many things that once looked impenetrable are starting to clear up for me.
I am basically developing the intuitions that work in the Haskell world - different intuitions from those I acquired when I worked using imperative languages.
So possibly even advanced Haskell code is not impenetrable by nature - it's just different - and once you get over the initial difficulty it'll then look clear and not that dense at all?
Martin
Andrew Bernard:
Greetings All,
While I admire Haskell enormously, as a an intermediate beginner I find it difficult to know what is normal Haskell style for real world programming. On the subject of monad transformers, the paper by Martin Grabümller titled 'Monad Transformers Step by Step' gives an example of an evaluator using monad transformers with the following type:
type Eval6 α = ReaderT Env (ErrorT String (WriterT [String] (StateT Integer IO))) α
Is this how normal Haskell is developed and written in practice? I find the type and the function impenetrably dense and difficult to understand. Should I be aspiring to have my functions look and work like this? Of course it depends on what you want to do, but the essence of the question is, does Haskell ultimately end up looking like this for any real programming, beyond textbook list manipulation functions?
Andrew
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Sent from Whiteout Mail - https://whiteout.io My PGP key: https://keys.whiteout.io/lethuillier@wmail.io
Also, looking at this topic in more detail - we could speak of different kinds of denseness. One is inherent because there is so much encoded in the types and abstractions used. However this is the kind of denseness that IMO fades away as you get the right intuitions. Then it's true that there is lots of space in Haskell for writing dense code - this is the "poetry" bit. But I can also write code that is more spacious, I write out more things explicitly, variables with longer names, etc. It'll be less of a poetry maybe, but easier to read. There can be different kinds of poetry... :-) M. lethuillier@wmail.io:
Hi. I am a beginner too.
For the most part I agree with you, except that Haskell is, in my opinion, a dense language per se.
Haskell is more poetry than prose; you do not read/write a poem like a novel.
Whether you are new to this language or master it, it is dense.
Guillaume
Saturday, Sep 19, 2015 8:30 AM Martin Vlk wrote:
Hi, I am also something of a beginner in Haskell and have to say I am slowly getting to see that many things that once looked impenetrable are starting to clear up for me.
I am basically developing the intuitions that work in the Haskell world - different intuitions from those I acquired when I worked using imperative languages.
So possibly even advanced Haskell code is not impenetrable by nature - it's just different - and once you get over the initial difficulty it'll then look clear and not that dense at all?
Martin
Andrew Bernard:
Greetings All,
While I admire Haskell enormously, as a an intermediate beginner I find it difficult to know what is normal Haskell style for real world programming. On the subject of monad transformers, the paper by Martin Grabümller titled 'Monad Transformers Step by Step' gives an example of an evaluator using monad transformers with the following type:
type Eval6 α = ReaderT Env (ErrorT String (WriterT [String] (StateT Integer IO))) α
Is this how normal Haskell is developed and written in practice? I find the type and the function impenetrably dense and difficult to understand. Should I be aspiring to have my functions look and work like this? Of course it depends on what you want to do, but the essence of the question is, does Haskell ultimately end up looking like this for any real programming, beyond textbook list manipulation functions?
Andrew
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Sent from Whiteout Mail - https://whiteout.io
My PGP key: https://keys.whiteout.io/lethuillier@wmail.io
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
On Sat, Sep 19, 2015, at 06:30 AM, Andrew Bernard wrote:
Greetings All,
While I admire Haskell enormously, as a an intermediate beginner I find it difficult to know what is normal Haskell style for real world programming. On the subject of monad transformers, the paper by Martin Grabümller titled 'Monad Transformers Step by Step' gives an example of an evaluator using monad transformers with the following type:
type Eval6 α = ReaderT Env (ErrorT String (WriterT [String] (StateT Integer IO))) α
I felt the same too when I looked at that paper and read some other Haskell code. But in my own little practice, I haven't written such type signatures. One of the talks that can help you get rid of the fear is this one by Brian Hurt. It certainly helped me and I used a few Monad Transformers after that talk to make my code cleaner. Encourage you to have a look. https://www.youtube.com/watch?v=8t8fjkISjus Cheers and happy hacking! -- Ramakrishnan
participants (6)
-
Andrew Bernard -
Brandon Allbery -
Francesco Ariis -
lethuillier＠wmail.io -
Martin Vlk -
Ramakrishnan Muthukrishnan