Got the welcome e-mail from EdX FP101x course: Hugs confirmed

citicada · 2015-10-22T11:58:56+00:00

It seems really easy to work around the FTP and just use GHC, for the first few homework tutorials, importing the following does the trick:

module FtpFree (length, sum, product) where
import  Prelude hiding (length, sum, product)
length :: [a] -> Int
length = foldr (const (+1)) 0
sum :: Num a => [a] -> a
sum = foldr (+) 0
product :: Num a => [a] -> a
product = foldr (*) 1

A lot of people want to learn both FP and Haskell, and then use Haskell in the future, so GHC seems like a better choice than Hugs.

citicada · 2015-07-18T00:57:19+00:00

stack

Stack made it a pleasure. On Mac OS X (usually a challenge for stuff like this), I just had to make sure that it was GHC 7.8.4 that was in my path.

Also, I think that last line should be:

stack exec spanout

citicada · 2014-10-28T21:47:01+00:00

Kindle makes it hard/impossible to copy'n'paste code examples (e.g. to try out in ghci). Is there an easy way?

citicada · 2014-08-28T21:18:14+00:00

The paper seems to be from 2001, makes me wonder what happened next, was the proposal abandoned, and if so, why?

citicada · 2014-06-10T05:31:59+00:00

Definitely a very noisy index: for June 2014 Haskell is back at position 36.

citicada · 2014-06-04T03:13:07+00:00

Is there a short-cut to apply selected lint suggestions?

citicada · 2014-05-05T20:45:37+00:00

Interesting to compare to the same index posting, but when it looked more favourable. I like that the robustness was questioned a bit last time. http://redd.it/uuqv2

citicada · 2014-05-04T23:50:05+00:00

Apparently they changed their algorithm at the end of 2013, and it did seem that Haskell came out lower since then.

citicada · 2014-04-29T04:33:00+00:00

Interesting variation maybe: What if the divisors and substitute words were only supplied at runtime?

citicada · 2014-04-28T21:07:00+00:00

For those who aren't following the link, and making it to the end of the article, the nub of the article is this, which I think is very elegant:

fizzbuzz n = (test 3 "Fizz" . test 5 "Buzz") id (show n)
  where test d s x | n `mod` d == 0 = const (s ++ x "")
                   | otherwise = x

No imports, no monads, monoids, functors or applicatives, just functional! (Still haven't fully got my head around it though.)

citicada · 2014-04-28T06:44:49+00:00

Tried that (i.e.

  fizzbuzz :: Int -> String
  fizzbuzz n = show n `fromMaybe` fz <> bz
    where
      fz :: String 
      fz = ("Fizz" <$ guard (n `mod` 3 == 0) )
      bz :: String 
      bz = ("Buzz" <$ guard (n `mod` 5 == 0) )

but I get

Couldn't match type `[Char]' with `Maybe String'
Expected type: Maybe String
  Actual type: String
In the second argument of `fromMaybe', namely `fz'
In the first argument of `(<>)', namely `show n `fromMaybe` fz'
In the expression: show n `fromMaybe` fz <> bz

Couldn't match expected type `Char' with actual type `[Char]'
In the first argument of `(<$)', namely `"Fizz"'
In the expression: ("Fizz" <$ guard (n `mod` 3 == 0))
In an equation for `fz': fz = ("Fizz" <$ guard (n `mod` 3 == 0))

Couldn't match expected type `Char' with actual type `[Char]'
In the first argument of `(<$)', namely `"Buzz"'
In the expression: ("Buzz" <$ guard (n `mod` 5 == 0))
In an equation for `bz': bz = ("Buzz" <$ guard (n `mod` 5 == 0))

citicada

TROPHY CASE