Haskell notes (part 01)

import Data.Binary.Put (putShortByteString)
import Data.Text.Encoding.Error (ignore)
main = do
  putStrLn "Hello! World!"

-- Just ignore this part, if you do not use Emacs and eev

-- (buffer-file-name)

{-
 (eepitch-ghci)
 (eepitch-kill)
 (eepitch-ghci)
:load hello.hs
-}

- :set prompt "hsk > "

- putStrLn "Hello Haskell!"

- This is just an example:

- module $Test where

- main :: IO() -- it is the monad IO () - the Input/Output monad
- main = putStrLn "Hello Haskell!"

- If you have multiple lines after "main =", you've to write:

- main = do

- and open a new line (2 spaces of left-indentation)
- for writing your code...

module Main where

main :: IO ()
main = do
  print (5 + 5)
  print (5 * 7)
  print (8 - 3)
  print (5 / 2)
  print (3 * 6.0)
  print (4 ** 3)
  print (sqrt 36.0)
  print (round 4.4)
  print (round 4.6)
  print (floor 4.6)
  print (ceiling 4.6)
  return ()

-- Just ignore this part, if you do not use Emacs and eev

-- or type "C-c C-l". So that, the function is automagically loaded into haskell REPL
-- M-x haskell-doc-mode

-- (buffer-file-name)

{-
 (eepitch-ghci)
 (eepitch-kill)
 (eepitch-ghci)
:load maths.hs
:main
-}

- :t show 3 -> show 3 :: String

- :t read "3" -> read "3" :: Read a => a

- read "3" + 5
- read "True" && True

- read "4" -- error, since it needs a type annotation, because it
- does not know if you want a Float or Int

- read "4" :: Int
- read "4" :: Double
- read "5" :: Float
- (read "4" :: Float) * 3
- read "[1,2,2]" :: [Float]
- read "('a', 3.4)" :: (Char, Float)

-- load the function in the repl with:
-- :l hello
-- after saving it, you do not need to load again, but:
-- :reload
-- and call it with:
-- :main

-- Script from the book:
-- Learn You a Great Haskell

-- double an only given number
doubleMe x = x + x

-- double two given numbers
-- and sum them
doubleUsSumUs x y = (x * 2) + (y * 2)

-- Just ignore this part, if you do not use Emacs and eev

-- or type "C-c C-l". So that, the function is automagically loaded into haskell REPL
-- M-x haskell-doc-mode

-- (buffer-file-name)

{-
 (eepitch-ghci)
 (eepitch-kill)
 (eepitch-ghci)
:load baby.hs
-}

- the compiler can infer what we want,
- by looking to the rest of the
- list elements
- [read "True", False, True, False]

- minBound :: Int
- maxBound :: Int
- maxBound :: (Bool, Int, Char)

  module Dup where

-- You can write functions with same names (with two (or more)
-- versions (you can use prime(s) "'" for that), and different types

-- load and call the functions on GHCI

-- dupFoo 3
-- dupFoo' 3

-- function declaration
dupFoo :: Int -> Int

-- build the function
dupFoo n = n + n

-- function declaration
dupFoo' :: Float -> Float

-- build the function
dupFoo' n = 2 * n


{-
 (eepitch-ghci)
 (eepitch-kill)
 (eepitch-ghci)
:load dup.hs

-}

- div :: Integral a => a -> a -> a
- div :: Int -> Int -> Int

- :t 20

- 20 :: Int
- 20 :: Float
- 20 :: Double

- e.g.:

- lists:
- [1,2,3] <> [4,5,6]

- lists of lists
- [[1,2,3],[4,5,6]] <> [[7,8,9]]

- strings (chars, for real):
- ['h', 'e'] <> "llo"

- words = ["foo", "bar", "barz", "foo1", "bar2", "barz1", "barz2"]

- words !! 0
- words !! 5
- words !! 10

main :: IO ()

-- Lists start at 0 index

scores :: [Int]
scores = [5, 7, 9, 10]

-- the bang operator access list indexes

main = do
  print [scores !! 0]
  print [scores !! 2]

  print (head scores)
  print (last scores)
  print (init scores)
  print (tail scores)

-- Just ignore this part, if you do not use Emacs and eev

-- or type "C-c C-l". So that, the function is automagically loaded into haskell REPL
-- M-x haskell-doc-mode

-- (buffer-file-name)

{-
 (eepitch-ghci)
 (eepitch-kill)
 (eepitch-ghci)
:load lists.hs
:main
-}

- 1 : [2,3] -- prepends 1 to the list, using cons ":"

- 'h' : ['e', 'l', 'l', 'o']

- 'f' : 'o' : ['o']

- [1,2,3] : []

- [1] : [2] : [3] : [[10,11,12]]

- l = [1] : [2] : [3] : [[10,11,12]]

- l = [1] : [2] : [3] : [[10,11,12]]

- head l
- init l
- tail l

module PatMatch where

-- partern matching

sorte :: Int -> String
sorte 7 = "Acertou! Parabéns"

-- load this function and
-- call this it like so:
-- sorte # -- where "#" is a number

-- we should always add a catchall at the end of our patern matching function

sorte x = "Que pena... Errou"

-- ignore this part if you do not have "eev" in Emacs

{-
 (eepitch-ghci)
 (eepitch-kill)
 (eepitch-ghci)
:load partern_match.hs
-}

- Type "C-c C-l" when editing a haskell script. So that, the function is automagically loaded into haskell REPL

- (buffer-file-name)
- eval this inside your local buffer or file

- You can use eeit
- and just add ":main" to its block
- or you can call ghci with "C-c C-l" as well

- use 2 spaces indentation
- M-x haskell-doc-mode

module Main where

-- call the down function

main = printSmallNumber 11

-- function name = body

printSmallNumber num =
 if num < 10
 then print num
 else print "The number is too big"

- Books
- Effective_Haskell
- Learn_You_a_Great_Haskell
- Haskell_98_Tutorial
- Haskell_TCofP
- Haskell_PaTyp

- Introduction au langage Haskell
- by nokomprendo

- gitlab
- http://tny.im/CxTon

- Articles
- http://tny.im/qZbsp

- Videos
- http://tny.im/lFIfd