

CIS 194: Introduction to Haskell (Spring 2013) - hamidr
http://www.cis.upenn.edu/~cis194/

======
dschiptsov
I really like the amount of nonsense.)

It begins with _head is a mistake! It should not be in the Prelude. Other
partial Prelude functions you should almost never use include tail, init,
last, and (!!). From this point on, using one of these functions on a homework
assignment will lose style points!_

And here is a proposal:

    
    
      data NonEmptyList a = NEL a [a]
    
      nelToList :: NonEmptyList a -> [a]
      nelToList (NEL x xs) = x:xs
    
      listToNel :: [a] -> Maybe (NonEmptyList a)
      listToNel []     = Nothing
      listToNel (x:xs) = Just $ NEL x xs
    
      headNEL :: NonEmptyList a -> a
      headNEL (NEL a _) = a
    
      tailNEL :: NonEmptyList a -> [a]
      tailNEL (NEL _ as) = as
    

Dear sirs, a List is a recursive data structure _by definition_. Non-recursive
List is an unimaginable nonsense. What was made here with a name of safe(!)
NonEmptyList is some ugly Pair with lots of syntactic noise.

How could you get the last element from your NonEmptyList? How could you tell
how many elements in it?)

But, of course, never ever use these ugly unsafe lists - they might be empty!
Use safe NonEmptyList because in Haskell everything is safe. And never try to
think what the fuck you are reading.

~~~
Peaker
A better solution is length-encoded lists (often called Vectors):

    
    
      data Vector length a where
        Empty :: Vector 0 a
        Cons :: a -> Vector n a -> Vector (1 + n) a
    

But Haskell isn't very good at such encodings. Type-level computation is often
not worth it.

That said, even NonEmptyList is sometimes useful. For example, some Prelude
functions could use it:

    
    
      group :: [a] -> [NonEmptyList a]
    

Making common idioms like:

    
    
      map head . group ...
    

Safe again.

Not sure what you mean by:

> How could you get the last element from your NonEmptyList? How could you
> tell how many elements in it?) Exactly two.
    
    
      import Data.Monoid
      import Data.Maybe
    
      lastNel :: NonEmptyList a -> a
      lastNel (NEL x xs) = fromMaybe x . getLast $ mconcat $ map (Last . Just) xs
    
      lengthNel :: NonEmptyList a -> Int
      lengthNel (NEL x xs) = 1 + length xs

~~~
jdn
I'm not quite sure what you've done there. You seem to be confusing type
signatures with function definitions. You've also used GADT syntax, requiring
-XGADTs, which isn't needed for a simple vector type.

> Cons :: a -> Vector n a --> Vector (1 + n) a

This makes no sense, you can't specify constants in a type signature, and you
certainly can't add constants to a type variable in one.

I may be the one not in the know here, if so please show me this magic.

~~~
klibertp
Not in Haskell, but there are languages where it's possible. It's called
dependent typing and I don't really understand how it works, but I suppose gp
was referring to this.

~~~
jdn
Oh of course, and that also explains the use of GADTs since they are one route
to dependent types in Haskell. I'm not sure what he's done there is fully
legit, but maybe not as loony as at first thought.

~~~
tel
It plays fast and loose on notation, but is perfectly kosher in GHC (not
Haskell2010 or Haskell98).

------
MaxScheiber
The author and teacher of this course, Brent Yorgey, is one of those rare guys
who is both a fantastic lecturer and a fantastic researcher.

For Penn's fuller version of this course, check out CIS 552[1]. Dr. Stephanie
Weirich is also a fantastic lecturer, and a GHC contributor to boot (IIRC).

[1]
[http://www.seas.upenn.edu/~cis552/12fa/](http://www.seas.upenn.edu/~cis552/12fa/)

------
Watabou
Wow, thanks for this, it's exactly what I needed.

I started from LYAH and the only thing missing from it were some exercises so
I could retain the information that was presented in each chapter. Otherwise,
it's a fantastic book.

------
mcintyre1994
I really wanted to learn functional programming when my university offered it,
but unfortunately it's crunched in a horribly busy term and I'm not willing to
risk core modules for it if I end up struggling.

That said, I really do want to learn it and find MOOCs a really useful tool,
if anybody has any suggestions for any they've used (or the one linked, I'm
unclear if that's for students at that university only) that'd be awesome!

~~~
archarios
The Wash U Programming Languages course on Coursera was pretty functional-
programming oriented. I really enjoyed it and would recommend it to anyone.

~~~
mcintyre1994
Thanks, it's a shame the content is only available when it's running because
again the timing isn't great. I'll definitely check it out though.

------
ilolu
Are there any good set of videos to learn Haskell ? Or which book should I
start with. I don't have much experience in Functional Programming.

~~~
bestham
I find that this rather old video from OSCON 2007 by the incredible Simon
Peyton Jones (of F# and GHC) is the most inspiring Haskell video there is. It
uses the X window manager XMonad as the basis to explain many important
concepts of Haskell and testing (QuickCheck). It is self contained and no
previous knowledge of Haskell is needed:

[http://blip.tv/oreilly-open-source-
convention/oscon-2007-sim...](http://blip.tv/oreilly-open-source-
convention/oscon-2007-simon-peyton-jones-a-taste-of-haskell-part-i-329701)

~~~
bestham
The slides are here: [http://research.microsoft.com/en-
us/um/people/simonpj/papers...](http://research.microsoft.com/en-
us/um/people/simonpj/papers/haskell-tutorial/)

------
croyd
I'm currently trying to learn functional programming through Haskell. Glad to
have found another resource, plus this cheat sheet linked from the page looks
handy: [http://cheatsheet.codeslower.com/](http://cheatsheet.codeslower.com/)

------
JacobHenner
Interesting to see a Penn site here...

------
WasimBhai
Why should I learn Haskell? Will it help me professionally, or help me being a
better programmer?

~~~
shoki
> Why should I learn Haskell?

[http://stackoverflow.com/questions/1604790/what-is-
haskell-a...](http://stackoverflow.com/questions/1604790/what-is-haskell-
actually-useful-for)

For my own 2-cents, once I learned QuickCheck[1] and Parsec[2], I found myself
slowly rewriting them for every language I program in.

> Will it help me professionally?

Speaking as another professional, probably not.

I love Haskell, but my colleagues can't deal with it. They can't write it.
They don't know functional programming. And to be entirely honest, they will
never understand Monoids, Monads, or macro-hacking.

> ...Help me being a better programmer?

Maybe. If you like already like to think of software axiomatically, then yes,
it will make you will make you think of software more conceptually.

But honestly, getting javascript, ruby and go under your belt will also make
you think differently about software, and those are more practical languages.

[1]
[http://en.wikipedia.org/wiki/QuickCheck](http://en.wikipedia.org/wiki/QuickCheck)
[2]
[http://www.haskell.org/haskellwiki/Parsec](http://www.haskell.org/haskellwiki/Parsec)

------
xzel
I took this class last semester. Learned a lot. Brent was a great professor
and is a great guy.

------
Ashuu
Is it only for UPENN students?

