関数型プログラミング Ch3 Haskellを使ってみよう

❯ stack ghci
ghci>:q
Leaving GHCi.

ghci> -- コメント
ghci> {- コメント-}

ghci> fib 0 = 1                       -- ここでは fib 0 = 1
ghci> fib 1 = 1                       -- fib 0 = 1 の定義が上書きされる
ghci> fib n = fib (n-1) + fib (n-2)   -- fib 1 = 1 の定義も上書きされる
ghci> fib 12
*** Exception: stack overflow

ghci> :{
ghci| fib :: Int -> Int
ghci| fib 0 = 1
ghci| fib 1 = 1
ghci| fib n = fib (n-1) + fib (n-2)
ghci| :}
ghci> fib 12
233

ghci> x = 1
ghci> x + 2
3

ghci> (a, b) = (1, 2)
ghci> a
1
ghci> b
2

ghci> 1 :: Int
1
ghci> 1 :: Double
1.0

ghci> :t 'c'
'c' :: Char
ghci> :type (1 :: Int)
(1 :: Int) :: Int

ghci> 1 + 1
2
ghci> 2 - 1
1
ghci> 3 * 3
9
ghci> 9 / 3
3.0
ghci> 3 ^ 3
27
ghci> 3 ** 3
27.0
ghci> 3 ^ (1/2) -- エラー

<interactive>:7:3: error: [GHC-39999]

ghci> 3 ** (1/2)
1.7320508075688772
ghci> 2 * 3 + 1
7
ghci> 2 * (3 + 1)
8

ghci> (+) 3 4
7
ghci> (*) ((+) 3 4) 2
14
ghci> (*) 2 $ (+) 3 4
14

ghci> 5 /2
2.5
ghci> div 5 2
2
ghci> 5 `div` 2
2
ghci> 5 `mod` 2
1

ghci> fromIntegral (1 :: Int) :: Double
1.0
ghci> div 5 2
2
ghci> 2 ** (div 5 2)

<interactive>:6:1: error: [GHC-39999]
    • Ambiguous type variable ‘a0’ arising from a use of ‘print’
      prevents the constraint ‘(Show a0)’ from being solved.
      Probable fix: use a type annotation to specify what ‘a0’ should be.
      Potentially matching instances:
        instance [safe] Show Version -- Defined in ‘Data.Version’
        instance Show Exception.ArithException
          -- Defined in ‘GHC.Exception.Type’
        ...plus 39 others
        ...plus 20 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In a stmt of an interactive GHCi command: print it
ghci> 2 ** (fromIntegral (div 5 2))
4.0

ghci> 2 ^ (2 / 1)

<interactive>:8:3: error: [GHC-39999]
    • Could not deduce ‘Integral b0’ arising from a use of ‘^’
      --- 省略

ghci> 2 ^ (truncate (2 / 1))
4

ghci> [1,2,3]
[1,2,3]

ghci> []
[]

ghci> [1,2.0,3]
[1.0,2.0,3.0]
ghci> [1::Int,2::Double,3::Int]

<interactive>:22:9: error: [GHC-83865]
    • Couldn't match expected type ‘Int’ with actual type ‘Double’
    • In the expression: 2 :: Double
      In the expression: [1 :: Int, 2 :: Double, 3 :: Int]
      In an equation for ‘it’: it = [1 :: Int, 2 :: Double, 3 :: Int]

ghci> :type ([1::Int,2::Int])
([1::Int,2::Int]) :: [Int]
ghci> :type ['a','b','c']
['a','b','c'] :: [Char]

ghci> 1 : []
[1]
ghci> 1 : [2,3]
[1,2,3]
ghci> 1 : 2 : [3]
[1,2,3]

ghci> x:xs = [1,2,3]
ghci> x
1
ghci> xs
[2,3]

ghci> [1,2,3] !! 0
1
ghci> [1,2,3] !! 1
2
ghci> [1,2,3] !! 2
3
ghci> [1,2,3] !! 3
*** Exception: Prelude.!!: index too large
CallStack (from HasCallStack):
  error, called at libraries/base/GHC/List.hs:1366:14 in base:GHC.List
  tooLarge, called at libraries/base/GHC/List.hs:1376:50 in base:GHC.List
  !!, called at <interactive>:37:9 in interactive:Ghci15

ghci> [1 .. 10]
[1,2,3,4,5,6,7,8,9,10]

ghci> [1,3..10]
[1,3,5,7,9]

ghci> [1,3..] !! 10
21
ghci> [1,3..] !! 100
201

ghci> [1] ++ [2,3]
[1,2,3]

ghci> length []
0
ghci> length [1,2,3]
3

ghci> (1,2)
(1,2)
ghci> (1,2,3)
(1,2,3)

ghci> [(1,2),(1,2,3)]

<interactive>:60:8: error: [GHC-83865]
    • Couldn't match expected type: (a, b)
                  with actual type: (a0, b0, c0)
    • In the expression: (1, 2, 3)
      In the expression: [(1, 2), (1, 2, 3)]
      In an equation for ‘it’: it = [(1, 2), (1, 2, 3)]
    • Relevant bindings include
        it :: [(a, b)] (bound at <interactive>:60:1)

ghci> fst (1,2)
1
ghci> snd (1,2)
2
ghci> (x,y) = (1,2)
ghci> x
1
ghci> y
2

ghci> 'c'
'c'
ghci> :t 'c'
'c' :: Char
ghci> "String"
"String"
ghci> :t "String"
"String" :: String

type String = [Char]

ghci> "String" !! 1
't'
ghci> '!' : "String"
"!String"
ghci> "!!" ++  "String"
"!!String"
ghci> length "String"
6

ghci> 1 > 2
False
ghci> 1 < 1.5
True

ghci> 4 == 4
True
ghci> "cat" /= "cat"
False

ghci> 1 > 2
False
ghci> 2 > 0
True
ghci> 1 > 2 && 2 > 0
False
ghci> 1 > 2 || 2 > 0
True

ghci> 1 > 2
False
ghci> not (1 > 2)
True