courses

https://www.seas.upenn.edu/~cis194/fall16/

Exercies 1

import CodeWorld
import Data.Fixed
trafficController :: Double -> Picture
trafficController t
    | s < 3 = trafficLight Green
    | s < 4 = trafficLight Amber
    | s < 6 = trafficLight Red
    | s < 7 = trafficLight RedAmber
    where s = mod' t 7

botCircle c = colored c (translated 0 (-2.5) (solidCircle 1))
midCircle c = colored c (translated 0 0 (solidCircle 1))
topCircle c = colored c (translated 0 2.5  (solidCircle 1))

data TrafficState = Green | Amber | Red | RedAmber
trafficLight :: TrafficState -> Picture
trafficLight Green = botCircle green & midCircle black & topCircle black & frame
trafficLight Amber = botCircle black & midCircle yellow & topCircle black & frame
trafficLight Red = botCircle black & midCircle black & topCircle red & frame
trafficLight RedAmber = botCircle black & midCircle yellow & topCircle red & frame

frame = rectangle 2.5 7.5
main :: IO ()
main = animationOf trafficController

Exercise 2

import CodeWorld
import Data.Fixed
tree :: Integer -> Picture -> Picture
tree 0 b = b
tree n b = path [(0,0),(0,1)] & translated 0 1 (
  rotated (pi/10) (tree (n-1) b) & rotated (- pi/10) (tree (n-1) b))

blossom :: Double -> Picture
blossom t = colored yellow (solidCircle ( min s (t / 10.0 * s)))
  where s = 0.2

tree_blossom :: Double -> Picture
tree_blossom t = tree 8 (blossom t)
main = animationOf (tree_blossom)

Which applicaton is applicable of using Haskell?

Haskell is for sure not suitable for embedded application, but where it is most suitable?

Following paper may give some idea:

www.starling-software.com/misc/icfp-2009-cjs.pdf

In short, in finnacial applications, where

• algorithm is complex and the language should be more expressive
• better perfomrance than Java
• strong type system and pure functional language makes the software less bug
• much less test code. (In C, usually test code is, sometimes much, more than the production code).

And also this Paper:

https://pdfs.semanticscholar.org/a722/b1ca878a662f132e7fd7a5b6b29298378dd5.pdf

Exciting Features in Haskell

Pattern Match

This makes it more expressive:

https://www.haskell.org/tutorial/patterns.html

List and Tuple are different with ones in Python

In Python,

• List is mutable sequence of elements, each element could have different type.
• Tuple is immutable sequences of elements, each element could have different type

In Haskell, since all data are immutable:

• List is sequence of elements with all same type with infinite length.
• Tuple is seuqnce of elements with possiblely differnet types with limitted length.

Recursion

Excellent examples about Recursion and Pattern Matching:

http://learnyouahaskell.com/recursion

The combination of Pattern Matching and Recursion may explain why Haskell needs less test code as the implementation is more or less how the test code is written (consider the edge conditions first).

Functors, Applicatives, Monads

Every one should read this paper for Monads:

http://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/baastad.pdf

To put it simple, Monads are design pattern in FP to decouple the states that was coupled with main logic usually.

Very easy-to-understand article about Functor, Applicative and Monad http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html#functors

Type Constructor

For functions, (->) is a type constructor; the types f -> g and (->) f g are the same. Similarly, the types [a] and [] a are the same

Haskell Type Class

Haskell classes are roughly similar to a Java interface. Like an interface declaration, a Haskell class declaration defines a protocol for using an object rather than defining an object itself.

It is more like the interface in Golang, where the interface is defined in the place where it is used. As long as the object passed in has conformed interfaces it works fine.

Real World Project

https://github.com/erkmos/haskell-companies

Adjoint Uplink

This project is written in Haskell, it is a blockchain project. https://github.com/adjoint-io/uplink