Haskell 学習記

curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh

$ curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh

Welcome to Haskell!

This script can download and install the following binaries:
  * ghcup - The Haskell toolchain installer
  * ghc   - The Glasgow Haskell Compiler
  * cabal - The Cabal build tool for managing Haskell software
  * stack - A cross-platform program for developing Haskell projects (similar to cabal)
  * hls   - (optional) A language server for developers to integrate with their editor/IDE

ghcup installs only into the following directory,
which can be removed anytime:
  /Users/paalon/.ghcup

Press ENTER to proceed or ctrl-c to abort.
Note that this script can be re-run at any given time.

-------------------------------------------------------------------------------

Detected fish shell on your system...
Do you want ghcup to automatically add the required PATH variable to "/Users/paalon/.config/fish/config.fish"?

[P] Yes, prepend  [A] Yes, append  [N] No  [?] Help (default is "P").

A
-------------------------------------------------------------------------------
Do you want to install haskell-language-server (HLS)?
HLS is a language-server that provides IDE-like functionality
and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ...
Also see https://haskell-language-server.readthedocs.io/en/stable/

[Y] Yes  [N] No  [?] Help (default is "N").

Y
-------------------------------------------------------------------------------
Do you want to enable better integration of stack with GHCup?
This means that stack won't install its own GHC versions, but uses GHCup's.
For more information see:
  https://docs.haskellstack.org/en/stable/yaml_configuration/#ghc-installation-customisation-experimental
If you want to keep stacks vanilla behavior, answer 'No'.

[Y] Yes  [N] No  [?] Help (default is "Y").

Y
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 27.6M  100 27.6M    0     0  8575k      0  0:00:03  0:00:03 --:--:-- 8575k
[ Info  ] downloading: https://raw.githubusercontent.com/haskell/ghcup-metadata/master/ghcup-0.0.8.yaml as file /Users/paalon/.ghcup/cache/ghcup-0.0.8.yaml
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  424k  100  424k    0     0  3670k      0 --:--:-- --:--:-- --:--:-- 3659k
[ Info  ] Upgrading GHCup...
[ Warn  ] No GHCup update available

System requirements
  Note: On OS X, in the course of running ghcup you will be given a dialog box to install the command line tools. Accept and the requirements will be installed for you. You will then need to run the command again.
On Darwin M1 you might also need a working llvm installed (e.g. via brew) and have the toolchain exposed in PATH.
Press ENTER to proceed or ctrl-c to abort.
Installation may take a while.


[ Info  ] downloading: https://downloads.haskell.org/~ghc/9.4.8/ghc-9.4.8-x86_64-apple-darwin.tar.xz as file /Users/paalon/.ghcup/cache/ghc-9.4.8-x86_64-apple-darwin.tar.xz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  179M  100  179M    0     0  9643k      0  0:00:19  0:00:19 --:--:-- 9901k
[ Info  ] verifying digest of: ghc-9.4.8-x86_64-apple-darwin.tar.xz
[ Info  ] Unpacking: ghc-9.4.8-x86_64-apple-darwin.tar.xz to /Users/paalon/.ghcup/tmp/ghcup-d53f019aa9d89ede
[ Info  ] Installing GHC (this may take a while)
[ Info  ] Merging file tree from "/Users/paalon/.ghcup/tmp/ghcup-42328ccebcd7f0a2/Users/paalon/.ghcup/ghc/9.4.8" to "/Users/paalon/.ghcup/ghc/9.4.8"
[ Info  ] GHC installation successful
[ Info  ] downloading: https://raw.githubusercontent.com/haskell/ghcup-metadata/master/ghcup-0.0.8.yaml as file /Users/paalon/.ghcup/cache/ghcup-0.0.8.yaml
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
[ Info  ] GHC 9.4.8 successfully set as default version
[ Info  ] downloading: https://downloads.haskell.org/ghcup/unofficial-bindists/cabal/3.10.3.0/cabal-install-3.10.3.0-x86_64-apple-darwin.tar.xz as file /Users/paalon/.ghcup/cache/cabal-install-3.10.3.0-x86_64-apple-darwin.tar.xz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 5581k  100 5581k    0     0  8980k      0 --:--:-- --:--:-- --:--:-- 8973k
[ Info  ] verifying digest of: cabal-install-3.10.3.0-x86_64-apple-darwin.tar.xz
[ Info  ] Unpacking: cabal-install-3.10.3.0-x86_64-apple-darwin.tar.xz to /Users/paalon/.ghcup/tmp/ghcup-293c36cdcb00d017
[ Info  ] Installing cabal
[ Info  ] Cabal installation successful
Config file path source is default config file.
Config file not found: /Users/paalon/.cabal/config
Writing default configuration to /Users/paalon/.cabal/config
Downloading the latest package list from hackage.haskell.org
Package list of hackage.haskell.org has been updated.
The index-state is set to 2024-06-23T04:37:08Z.
[ Info  ] downloading: https://downloads.haskell.org/~ghcup/unofficial-bindists/haskell-language-server/2.7.0.0/haskell-language-server-2.7.0.0-x86_64-apple-darwin.tar.xz as file /Users/paalon/.ghcup/cache/haskell-language-server-2.7.0.0-x86_64-apple-darwin.tar.xz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  169M  100  169M    0     0  8498k      0  0:00:20  0:00:20 --:--:-- 8254k
[ Info  ] verifying digest of: haskell-language-server-2.7.0.0-x86_64-apple-darwin.tar.xz
[ Info  ] Unpacking: haskell-language-server-2.7.0.0-x86_64-apple-darwin.tar.xz to /Users/paalon/.ghcup/tmp/ghcup-0908d99d67f9a8aa
[ Info  ] Installing HLS
[ Info  ] Merging file tree from "/Users/paalon/.ghcup/tmp/ghcup-bab2e2f7367fcc33/Users/paalon/.ghcup/hls/2.7.0.0" to "/Users/paalon/.ghcup/hls/2.7.0.0"
[ Info  ] HLS installation successful
[ Info  ] This is just the server part of your LSP configuration. Consult the README on how to
[ ...   ] configure HLS, your project and your LSP client in your editor:
[ ...   ]   https://haskell-language-server.readthedocs.io/en/stable/
[ Info  ] downloading: https://downloads.haskell.org/~ghcup/unofficial-bindists/stack/2.15.5/stack-2.15.5-osx-x86_64.tar.gz as file /Users/paalon/.ghcup/cache/stack-2.15.5-osx-x86_64.tar.gz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 8493k  100 8493k    0     0  9494k      0 --:--:-- --:--:-- --:--:-- 9490k
[ Info  ] verifying digest of: stack-2.15.5-osx-x86_64.tar.gz
[ Info  ] Unpacking: stack-2.15.5-osx-x86_64.tar.gz to /Users/paalon/.ghcup/tmp/ghcup-1415566a5b57c92f
[ Info  ] Installing stack
[ Info  ] Stack installation successful
[ Info  ] Stack manages GHC versions internally by default. To improve integration, please visit:
[ ...   ]   https://www.haskell.org/ghcup/guide/#stack-integration
[ ...   ]
[ ...   ] Also check out:
[ ...   ]   https://docs.haskellstack.org/en/stable/yaml_configuration
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   764  100   764    0     0   1134      0 --:--:-- --:--:-- --:--:--  1135

===============================================================================

OK! /Users/paalon/.config/fish/config.fish has been modified. Restart your terminal for the changes to take effect,
or type ". /Users/paalon/.ghcup/env" to apply them in your current terminal session.

===============================================================================

All done!

To start a simple repl, run:
  ghci

To start a new haskell project in the current directory, run:
  cabal init --interactive

To install other GHC versions and tools, run:
  ghcup tui

If you are new to Haskell, check out https://www.haskell.org/ghcup/steps/

-- Hello.hs
module Main where

main :: IO ()
main = putStrLn "Hello!"

$ ghc Hello.hs
[1 of 2] Compiling Main             ( Hello.hs, Hello.o )
[2 of 2] Linking Hello
ld: warning: ignoring duplicate libraries: '-lm'
$ ./Hello
Hello!

module Main where

main :: IO ()
main = do
  putStrLn "Hello! What is your name?"
  name <- getLine
  let out = "Nice to meet you, " ++ name ++ "!"
  putStrLn out

$ ghc Hello.hs
[1 of 2] Compiling Main             ( Hello.hs, Hello.o ) [Source file changed]
[2 of 2] Linking Hello [Objects changed]
ld: warning: ignoring duplicate libraries: '-lm'
$ ./Hello
Hello! What is your name?
Paalon
Nice to meet you, Paalon!

module Main where

main :: IO ()
main = do
  putStrLn "Hello! What is your name?"
  let out = "Nice to meet you, " ++ getLine ++ "!"
  putStrLn out

$ ghc Hello.hs
[1 of 2] Compiling Main             ( Hello.hs, Hello.o ) [Source file changed]

Hello.hs:6:37: error:
    • Couldn't match expected type: [Char]
                  with actual type: IO String
    • In the first argument of ‘(++)’, namely ‘getLine’
      In the second argument of ‘(++)’, namely ‘getLine ++ "!"’
      In the expression: "Nice to meet you, " ++ getLine ++ "!"
  |
6 |   let out = "Nice to meet you, " ++ getLine ++ "!"
  |                                     ^^^^^^^

module Main where

main :: IO ()
main = do
  putStrLn "Hello! What is your name?"
  name <- getLine
  putStrLn "Nice to meet you, " ++ name ++ "!"

$ ghc Hello.hs
[1 of 2] Compiling Main             ( Hello.hs, Hello.o ) [Source file changed]

Hello.hs:7:3: error:
    • Couldn't match type ‘[]’ with ‘IO’
      Expected: IO ()
        Actual: [()]
    • In a stmt of a 'do' block:
        putStrLn "Nice to meet you, " ++ name ++ "!"
      In the expression:
        do putStrLn "Hello! What is your name?"
           name <- getLine
           putStrLn "Nice to meet you, " ++ name ++ "!"
      In an equation for ‘main’:
          main
            = do putStrLn "Hello! What is your name?"
                 name <- getLine
                 putStrLn "Nice to meet you, " ++ name ++ "!"
  |
7 |   putStrLn "Nice to meet you, " ++ name ++ "!"
  |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Hello.hs:7:36: error:
    • Couldn't match type ‘Char’ with ‘()’
      Expected: [()]
        Actual: String
    • In the first argument of ‘(++)’, namely ‘name’
      In the second argument of ‘(++)’, namely ‘name ++ "!"’
      In a stmt of a 'do' block:
        putStrLn "Nice to meet you, " ++ name ++ "!"
  |
7 |   putStrLn "Nice to meet you, " ++ name ++ "!"
  |                                    ^^^^

Hello.hs:7:44: error:
    • Couldn't match type ‘Char’ with ‘()’
      Expected: [()]
        Actual: String
    • In the second argument of ‘(++)’, namely ‘"!"’
      In the second argument of ‘(++)’, namely ‘name ++ "!"’
      In a stmt of a 'do' block:
        putStrLn "Nice to meet you, " ++ name ++ "!"
  |
7 |   putStrLn "Nice to meet you, " ++ name ++ "!"
  |

putStrLn ("Nice to meet you, " ++ name ++ "!")

type Item = String
type Items = [Item]

-- Returns a new list of Items with the new item in it
addItem :: Item -> Items -> Items

-- Returns a string representation of the items
displayItems :: Items -> String

-- Returns a new list of items or an error message if the index is out of bounds
removeItem :: Int -> Items -> Either String Items

-- Returns a new list of Items with the new item in it
addItem :: Item -> Items -> Items
addItem item items = item : items

-- Returns a string representation of the items
displayItems :: Items -> String
displayItems items =
  let
    displayItem index item = show index ++ " - " ++ item
    reversedList = reverse items
    displayedItemsList = zipWith displayItem [1..] reversedList
  in
    unlines displayedItemsList

zipwith(f, xs, ys) = [f(x, y) for (x, y) in zip(xs, ys)]

unlines(x::Vector{String}) = join(x .* '\n')

-- Takes a list of items
-- Interact with the user
-- Return an updated list of items
interactWithUser :: Items -> IO Items

interactWithUser :: Items -> IO Items
interactWithUser items = do
  putStrLn "Enter an item to add to your todo list:"
  item <- getLine
  let newItems = addItem item items
  putStrLn "Item added.\n"
  putStrLn "The List of items is:"
  putStrLn (displayItems newItems)
  pure newItems

module Main where

type Item = String
type Items = [Item]

-- Returns a new list of Items with the new item in it
addItem :: Item -> Items -> Items
addItem item items = item : items

-- Returns a string representation of the items
displayItems :: Items -> String
displayItems items =
  let
    displayItem index item = show index ++ " - " ++ item
    reversedList = reverse items
    displayedItemsList = zipWith displayItem [1..] reversedList
  in
    unlines displayedItemsList

-- Takes a list of items
-- Interact with the user
-- Return an updated list of items
interactWithUser :: Items -> IO Items
interactWithUser items = do
  putStrLn "Enter an item to add to your todo list:"
  item <- getLine
  let newItems = addItem item items
  putStrLn "Item added.\n"
  putStrLn "The List of items is:"
  putStrLn (displayItems newItems)
  pure newItems

main :: IO ()
main = do
  putStrLn "TODO app"
  let initialList = []
  interactWithUser initialList
  putStrLn "Thanks for using this app."

interactWithUser :: Items -> IO ()
interactWithUser items = do
  putStrLn "Enter an item to add to your todo list:"
  item <- getLine
  let newItems = addItem item items
  putStrLn "Item added.\n"
  putStrLn "The List of items is:"
  putStrLn (displayItems newItems)
  interactWithUser newItems

data Command
  = Quit
  | DisplayItems
  | AddItem String

parseCommand :: String -> Either String Command
parseCommand line = case words line of
  ["quit"] -> Right Quit
  ["items"] -> Right DisplayItems
  "add" : "-" : item -> Right (AddItem (unwords item))
  _ -> Left "Unknown command."

interactWithUser :: Items -> IO ()
interactWithUser items = do
  putStrLn "Commands: quit, items, add - <item to add>"
  line <- getLine
  case parseCommand line of
    Right DisplayItems -> do
      putStrLn "The List of items is:"
      putStrLn (displayItems items)
      interactWithUser items

    Right (AddItem item) -> do
      let newItems = addItem item items
      putStrLn "Item added."
      interactWithUser newItems

    Right Quit -> do
      putStrLn "Bye!"
      pure ()

    Left errMsg -> do
      putStrLn ("Error: " ++ errMsg)
      interactWithUser items

data Command
  ...
  | Help

parseCommand :: String -> Either String Command
parseCommand line = case words line of
  ...
  ["help"] -> Right Help
  _ -> Left "Unknown command."

interactWithUser :: Items -> IO ()
interactWithUser items = do
  line <- getLine
  case parseCommand line of
    Right Help -> do
      putStrLn "Commands: help, quit, items, add - <item to add>"
      interactWithUser items
    ...

-- Returns a new list of items or an error message if the index is out of bounds
removeItem :: Int -> Items -> Either String Items
removeItem reverseIndex allItems =
    impl (length allItems - reverseIndex) allItems
  where
    impl index items =
      case (index, items) of
        (0, item : rest) ->
          Right rest
        (n, []) ->
          Left "Index out of bounds."
        (n, item : rest) ->
          case impl (n - 1) rest of
            Right newItems ->
              Right (item : newItems)
            Left errMsg ->
              Left errMsg

data Command
  ...
  | Done Int

parseCommand :: String -> Either String Command
parseCommand line = case words line of
  ...
  ["done", idxStr] ->
    if all (\c -> elem c "0123456789") idxStr
      then Right (Done (read idxStr))
      else Left "Invalid index."
  _ -> Left "Unknown command."

interactWithUser :: Items -> IO ()
interactWithUser items = do
  line <- getLine
  case parseCommand line of
    Right Help -> do
      putStrLn "Commands: help, quit, items, add - <item to add>, done <item index>"
      interactWithUser items
    Right (Done index) -> do
      let result = removeItem index items
      case result of
        Left errMsg -> do
          putStrLn ("Error: " ++ errMsg)
          interactWithUser items
        Right newItems -> do
          putStrLn "Item done."
          interactWithUser newItems

    ...

case		class		data		default		deriving
do		else		foreign		if		import
in		infix		infixl		infixr		instance
let		module		newtype		of		then
type		where		_

s = [x * x | x <- [1..5]] -- [1, 4, 9, 16, 25]

s = [x * x for x = 1:5]

s = [x * x | x <- [1..5], x /= 3]

s = [x * x for x = filter(x -> x ≠ 3, 1:5)]

fst (1, 'a', "ABC") -- 1
snd (1, 'a', "ABC") -- 'a'
(_, _, x) = (1, 'a', "ABC") -- binds x to "ABC"

stmt1 >> stmt2 >> stmt3 >> stmt4

add x y = x + y

main = print (add 3 5)

main = print $ add 3 5

# $ % & * + . / < = > ? @ \ ^ | - ~

\arg -> expr
\(arg1, arg2) -> expr

func 1 = "One"
func 2 = "Two"
func 3 = "Three"
main = print $ func 1

foo x
  | x == 1 = "One"
  | x == 2 = "Two"
  | x == 3 = "Three"
  | otherwise = "More..."

main = putStrLn $ foo 2

f n = n * 2
g n = n * 3
h n = n * 4
-- fn n = f(g(h(n)))
-- fn n = (f . g . h) n
fn = (f . g . h)
main = print $ fn 5

f(n) = 2n
g(n) = 3n
h(n) = 4n
fn = f ∘ g ∘ h
println(fn(5))

case expr of
  pattern1 -> expr1
  pattern2 -> expr2
  _ -> expr3

import [qualified] ModuleName [as AliasName] [[hiding] (name, ...)]

loop 0 action = return ()
loop n action = do
  action
  loop (n - 1) action
main = loop 10 $ putStrLn "Hello"

import Control.Monad

main = do
  replicateM_ 3 $ putStrLn "Hello"

data TypeName =
      Constructor1 { fieldLabel1a :: Type1a, fieldLabel1b :: Type1b, ... }
  [ | Constructor2 { fieldLabel2a :: Type2a, fieldLabel2b :: Type2b, ... } ]...
  [deriving (TypeClass, ...)]

data Color = Red | Green | Blue deriving (Show, Eq)

main = do
  let x = Red
  let y = Green
  if x == y then print "Equal" else print "Not Equal"

data Point = Point Int Int deriving Show

addPoint (Point x1 y1) (Point x2 y2) = Point (x1 + x2) (y1 + y2)

main = do
  let a = Point 100 200
      b = Point 300 400
      c = addPoint a b
  print c				-- Point 400 600

data Figure = Rect { x1, y1, x2, y2 :: Int }
            | Circle { x, y, r :: Int }
            deriving Show
main = do
  let a = Rect { x1 = 100, y1 = 100, x2 = 200, y2 = 200 }
      b = Circle { x = 100, y = 100, r = 100 }
  print a	-- Rect {x1 = 100, y1 = 100, x2 = 200, y2 = 200}
  print b	-- Circle {x = 100, y = 100, r = 100}

const Figure = Union{Rect, Circle}

abstract type Show end
abstract type Figure <: Show end
struct Rect <: Figure end
struct Circle <: Figure end

newtype Pixel = Pixel Int deriving Show

main = do
  let a = Pixel 300
  print a

type Person = (Name, Address)
type Name = String
type Address = None | Addr String

class Foo a where
    foo :: a -> String
instance Foo Bool where
    foo True = "Bool: True"
    foo False = "Bool: False"
instance Foo Int where
    foo x = "Int: " ++ show x
instance Foo Char where
    foo x = "Char: " ++ [x]

main = do
    putStrLn $ foo True		-- Bool: True
    putStrLn $ foo (123::Int)	-- Int: 123
    putStrLn $ foo 'A'		-- Char: A

fn :: Int -> Maybe String
fn n
    | n == 1 = Just "One"
    | n == 2 = Just "Two"
    | otherwise = Nothing

main = do
    print $ fn 1	-- Just "One"
    print $ fn 2	-- Just "Two"
    print $ fn 3	-- Nothing

fn n = n * 2
main = do
    print $ fmap fn [1, 2, 3]	-- [2, 4, 6]
    print $ fmap fn Nothing	-- Nothing
    print $ fmap fn (Just 5)	-- Just 10
    print $ fmap fn (2, 3)	-- (4, 6)

fn n = n * 2
main = do
    print $ fn <$> [1, 2, 3]	-- [2, 4, 6]
    print $ fn <$> Nothing	-- Nothing
    print $ fn <$> (Just 5)	-- Just 10
    print $ fn <$> (2, 3)	-- (4, 6)

main = do
    print $ pure (*2) <*> Just 5	-- Just10
    print $ pure (*2) <*> [1, 2, 3]	-- [2, 4, 6]

main = do
    print $ [(*2), (*3)] <*> [1, 2, 3]	-- [2, 4, 6, 3, 6, 9]

fn x = return (2 * x)

main = do
    print $ [1, 2, 3] >>= fn	-- [2, 4, 6]
    print $ Just 5 >>= fn	-- Just 10
    print $ Nothing >>= fn	-- Nothing

-- MyModule.hs
module MyModule where

add x y = x + y

import MyModule

main = do
  print $ add 3 5

fn x = x * 2
ans = map fn [1, 2, 3]
main = print ans		-- [2, 4, 6]

-- 部分適用を使用しない例
tax :: Double -> Double -> Double
tax rate price = rate * price
main = do
  print $ tax 0.1 2500	-- 2500円の消費税(250円)を求める
  print $ tax 0.1 3500	-- 3500円の消費税(350円)を求める

-- 部分適用を使用した例
tax :: Double -> Double -> Double
tax rate price = rate * price
jptax = tax 0.1		-- 部分適用を利用した関数を定義する(第二引数が省略されている)
main = do
  print $ jptax 2500	-- 2500円の消費税(250円)を求める
  print $ jptax 3500	-- 3500円の消費税(350円)を求める

-- 正格評価の場合：main = fn 3 7 11 が実行される
-- 遅延評価の場合：main = do { print (1+2); print (3+4) } が実行される。(5+6)は評価されない
fn x y z = do { print x; print y }
main = fn (1+2) (3+4) (5+6)

Base.:∘(f::Function, fs::Tuple{Function, Function}) = x -> f(first(fs)(x), last(fs)(x))
∘(*, ((x -> x + 2) ∘ first, (y -> y + 3) ∘ last))

Base.:+(f::Function, g) = x -> f(x) + g
Base.:*(f::Function, g::Function) = x -> f(x) * g(x)
((identity + 2) ∘ first) * ((identity + 3) ∘ last)

Base.:+(f::Function, g) = x -> f(x) + g
Base.:+(f, g::Function) = x -> f + g(x)
Base.:+(f::Function, g::Function) = x -> f(x) + g(x)
Base.:*(f::Function, g) = x -> f(x) * g
Base.:*(f, g::Function) = x -> f * g(x)
Base.:*(f::Function, g::Function) = x -> f(x) * g(x)
Base.getindex(f::Function, i) = x -> f.(x)[i]
const id = identity
(id + 2)[1] * (id + 3)[2]

Base.:+(f::Function, g) = x -> f(x) + g
Base.:+(f, g::Function) = x -> x + g(x)
Base.:+(f::Function, g::Function) = x -> f(x) + g(x)
Base.:*(f::Function, g) = x -> f(x) * g
Base.:*(f, g::Function) = x -> f * g(x)
Base.:*(f::Function, g::Function) = x -> f(x) * g(x)
Base.getindex(f::Function, i) = x -> f.(x)[i]
const id = identity
(id[1] + 2) * (id[2] + 3)

Base.:+(f::Function, g) = (x...) -> f(x...) + g
Base.:+(f, g::Function) = (x...) -> f + g(x...)
Base.:+(f::Function, g::Function) = (x...) -> f(x...) + g(x...)
Base.:*(f::Function, g) = (x...) -> f(x...) * g
Base.:*(f, g::Function) = (x...) -> f * g(x...)
Base.:*(f::Function, g::Function) = (x...) -> f(x...) * g(x...)
Base.getindex(f::Function, i) = (x...) -> f.(x)[i]
const id = identity
((id[1] + 2) * (id[2] + 3))(1, 2) # 15

x = (1, "one")
case x of (x1, x2) -> print x2

-- 「パターン | Bool 型の式」で 条件分岐ができる
f x = case x of n | n `mod` 2 == 0 -> putStrLn "even"
                  | otherwise      -> putStrLn "odd"

-- １つのパターンに複数のガード節を付けられる
g x = case x of (x1, True) | x1 `mod` 2 == 0 -> x1 `div` 2
                (x1, _)    | x1 `mod` 2 == 0 -> x1
                           | otherwise       -> x1 - 1

-- <- でガード節にさらにパターンを書ける 
h x = case x of (x1, True) | (q, 0) <- x1 `divMod` 2 -> q
                (x_1, _)                             -> x1

f (x1, True) | (q, 0) <- x1 `divMod` 2 = q
f (x1, _)                              = x1

g n | n `mod` 2 == 0 = putStrLn "even"
    | otherwise      = putStrLn "odd"

(x, y) = 22 `divMod` 5

x:xs = [1,2,3]
x -- 1
xs -- [2,3]

map (2 *) [1..10] -- [2,4,6,8,10,12,14,16,18,20]

filter (\n -> n `mod` 3 == 0) [1..10] -- [3,6,9]

foldl (-) 0 [1..10] -- -55

foldr (-) 0 [1..10] -- -5

percentage k n | n == 0    = Nothing              :: Maybe Double
               | otherwise = Just (100.0 * k / n)

-- "40.0"
case percentage 20 50 of Nothing -> "UNKNOWN"
                         Just x  -> show x

import Data.Maybe
p = percentage 20 50
if isNothing p then "UNKNOWN" else show (fromJust p) -- "40.0"

import Data.Maybe
maybe "UNKNOWN" show (percentage 20 50)

module Main (main) where
import Control.Monad (forM_)

main :: IO ()
main = do
  forM_ [1..20] $ \i -> putStrLn (fizzbuzz i)
  where
    fizzbuzz n
      | n `mod` 15 == 0 = "fizz buzz"
      | n `mod` 3 == 0 = "fizz"
      | n `mod` 5 == 0 = "buzz"
      | otherwise = show n

show :: Show a => a -> String

data Employee = NewEmployee { employeeAge :: Integer, employeeIsManager :: Bool, employeeName :: String } deriving (Show)

employee :: Employee
employee = NewEmployee { employeeName = "Subhash Khot", employeeAge = 39, employeeIsManager = False }

main :: IO ()
main = do
  putStrLn $ show $ employeeAge employee
  putStrLn $ show $ employeeIsManager employee
  putStrLn $ show $ employeeName employee

data Dog = Dog deriving Show
data Cat = Cat deriving Show
data Human = Human String deriving Show

class Greeting a where
  name :: a -> String
  hello :: a -> String
  hello _ = "..."
  bye :: a -> String
  bye _ = "..."

instance Greeting Human where
  name (Human n) = n
  hello h = "Hi, I'm " ++ name h ++ "."
  bye _ = "See you."

instance Greeting Dog where
  name _ = "a dog"
  hello _ = "Bark!"

instance Greeting Cat where
  name _ = "a cat"
  bye _ = "Meow..."

main :: IO ()
main = do
  putStrLn $ hello $ Human "takeshi"
  putStrLn $ hello Dog
  putStrLn $ hello Cat

import Data.Monoid
main :: IO ()
main = do
  print $ [1,2,3] <> [4,5] -- [1,2,3,4,5]
  print $ "AB" <> "C" <> "DE" -- "ABCDE"
  print $ getSum $ 3 <> 2 -- 5
  print $ getProduct $ 3 <> 2 -- 6
  let maybes = [Nothing, Just 1, Just 100, Nothing]
  print $ getFirst $ mconcat $ map First maybes -- Just 1
  print $ getLast $ mconcat $ map Last maybes -- Just 100
  let f = appEndo $ Endo (subtract 1) <> Endo (^ 2)
  print $ f 3 -- 8

(型クラス1 型変数1, 型クラス2, 型変数2) => 型変数1 型変数2 ...

import Data.List (intercalate)

data Dog = Dog deriving Show
data Cat = Cat deriving Show
data Human = Human String deriving Show

class Greeting a where
  name :: a -> String
  hello :: a -> String
  hello _ = "..."
  bye :: a -> String
  bye _ = "..."

instance Greeting Human where
  name (Human n) = n
  hello h = "Hi, I'm " ++ name h ++ "."
  bye _ = "See you."

instance Greeting Dog where
  name _ = "a dog"
  hello _ = "Bark!"

instance Greeting Cat where
  name _ = "a cat"
  bye _ = "Meow..."

sayHello :: Greeting a => a -> IO ()
sayHello x = putStrLn $ hello x

class Greeting a => Laughing a where
  laugh :: a -> String

instance Laughing Human where
  laugh _ = "Zehahahah...!!"

leaveWithLaugh :: Laughing a => a -> IO ()
leaveWithLaugh x = do
  putStrLn $ bye x
  putStrLn $ laugh x

liftGreet :: (a -> String) -> ([a] -> String)
liftGreet f = intercalate "\n" . map f

instance Greeting a => Greeting [a] where
  name = liftGreet name
  hello = liftGreet hello
  bye = liftGreet bye

main :: IO ()
main = do
  sayHello $ Human "takashi"
  leaveWithLaugh $ Human "takashi"
  sayHello [Human "atsuhiko", Human "shingo"]

Hi, I'm takashi.
See you.
Zehahahah...!!
Hi, I'm atsuhiko.
Hi, I'm shingo.

data Human = Human String deriving Show

class Greeting a where
  name :: a -> String
  hello :: a -> String
  hello _ = "..."
  bye :: a -> String
  bye _ = "..."

instance Greeting Human where
  name (Human n) = n
  hello h = "Hi, I'm " ++ name h ++ "."
  bye _ = "See you."

class Breeding a where
  breed :: String -> a

instance Breeding Human where
  breed = Human -- この Human はコンストラクタ

main :: IO ()
main = do
  let baby = breed "takeshi"
  putStrLn $ hello baby

$ ghc constraint.hs
[1 of 2] Compiling Main             ( constraint.hs, constraint.o ) [Source file changed]

constraint.hs:23:14: error:
    • Ambiguous type variable ‘a0’ arising from a use of ‘breed’
      prevents the constraint ‘(Breeding a0)’ from being solved.
      Relevant bindings include baby :: a0 (bound at constraint.hs:23:7)
      Probable fix: use a type annotation to specify what ‘a0’ should be.
      Potentially matching instance:
        instance Breeding Human -- Defined at constraint.hs:18:10
    • In the expression: breed "takeshi"
      In an equation for ‘baby’: baby = breed "takeshi"
      In the expression:
        do let baby = breed "takeshi"
           putStrLn $ hello baby
   |
23 |   let baby = breed "takeshi"
   |              ^^^^^

constraint.hs:24:14: error:
    • Ambiguous type variable ‘a0’ arising from a use of ‘hello’
      prevents the constraint ‘(Greeting a0)’ from being solved.
      Relevant bindings include baby :: a0 (bound at constraint.hs:23:7)
      Probable fix: use a type annotation to specify what ‘a0’ should be.
      Potentially matching instance:
        instance Greeting Human -- Defined at constraint.hs:10:10
    • In the second argument of ‘($)’, namely ‘hello baby’
      In a stmt of a 'do' block: putStrLn $ hello baby
      In the expression:
        do let baby = breed "takeshi"
           putStrLn $ hello baby
   |
24 |   putStrLn $ hello baby
   |

hello (baby :: Human)

data Human = Human String deriving Show

class Greeting a where
  name :: a -> String
  hello :: a -> String
  hello _ = "..."
  bye :: a -> String
  bye _ = "..."

instance Greeting Human where
  name (Human n) = n
  hello h = "Hi, I'm " ++ name h ++ "."
  bye _ = "See you."

class Breeding a where
  breed :: String -> a

instance Breeding Human where
  breed = Human -- この Human はコンストラクタ

clone = breed . name

main :: IO ()
main = do
  let baby = breed "takeshi"
  putStrLn $ hello (baby :: Human)
  putStrLn $ hello $ clone (Human "takeshi")

$ ghc constraint.hs
[1 of 2] Compiling Main             ( constraint.hs, constraint.o ) [Source file changed]

constraint.hs:21:9: error:
    • Ambiguous type variable ‘c0’ arising from a use of ‘breed’
      prevents the constraint ‘(Breeding c0)’ from being solved.
      Relevant bindings include
        clone :: Human -> c0 (bound at constraint.hs:21:1)
      Probable fix: use a type annotation to specify what ‘c0’ should be.
      Potentially matching instance:
        instance Breeding Human -- Defined at constraint.hs:18:10
    • In the first argument of ‘(.)’, namely ‘breed’
      In the expression: breed . name
      In an equation for ‘clone’: clone = breed . name
   |
21 | clone = breed . name
   |         ^^^^^

constraint.hs:27:14: error:
    • Ambiguous type variable ‘c0’ arising from a use of ‘hello’
      prevents the constraint ‘(Greeting c0)’ from being solved.
      Probable fix: use a type annotation to specify what ‘c0’ should be.
      Potentially matching instance:
        instance Greeting Human -- Defined at constraint.hs:10:10
    • In the first argument of ‘($)’, namely ‘hello’
      In the second argument of ‘($)’, namely
        ‘hello $ clone (Human "takeshi")’
      In a stmt of a 'do' block:
        putStrLn $ hello $ clone (Human "takeshi")
   |
27 |   putStrLn $ hello $ clone (Human "takeshi")
   |

clone x = breed (name x) `asTypeOf` x

ghci> :i Monad
type Monad :: (* -> *) -> Constraint
class Applicative m => Monad m where
  (>>=) :: m a -> (a -> m b) -> m b
  (>>) :: m a -> m b -> m b
  return :: a -> m a
  {-# MINIMAL (>>=) #-}
  	-- Defined in ‘GHC.Base’
instance Monoid a => Monad ((,) a) -- Defined in ‘GHC.Base’
instance (Monoid a, Monoid b) => Monad ((,,) a b)
  -- Defined in ‘GHC.Base’
instance (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c)
  -- Defined in ‘GHC.Base’
instance Monad ((->) r) -- Defined in ‘GHC.Base’
instance Monad IO -- Defined in ‘GHC.Base’
instance Monad Maybe -- Defined in ‘GHC.Base’
instance Monad Solo -- Defined in ‘GHC.Base’
instance Monad [] -- Defined in ‘GHC.Base’
instance Monad (Either e) -- Defined in ‘Data.Either’

main = return ()

main = getContents >>= putStr

echo "Hello!" | ./main

import System.Environment
main = do
  args <- getArgs
  print args

import Control.Exception

main =
  (readFile "dummyFileName" >>= putStrLn)
    `catch`
  (\(e :: SomeException) ->
    putStrLn $ "readFile failure!!! : " ++ displayException e)
    `finally`
  (putStrLn "finalization!!!")