常連

こんばんは、何度か入門しようとして挫折している初心者です。

以前入門しようとした際は Stack 一択な感じだったと思います。
現在は ghcup+Cabal v2 という選択肢があると聞き調べてはいるのですが、結局どちらを使用したほうがいいのか分かりませんでした。
Cabal がパワーアップして Stack はもういらないのかなと思ってはいるのですが自信はありません。

これから入門する初心者はどちらを使用したほうがよいでしょうか？
よろしくお願いします。

Haskell の環境構築には Stack と ghcup+Cabal v2 のどちらを使用すべきでしょうか？

### 前提・実現したいこと

Stackのghcでhsファイルのみでのコンパイルをする際にモジュールをインポートしたい。

### 発生している問題・エラーメッセージ

```
stack ghc echo.hs
[1 of 1] Compiling Echo             ( echo.hs, echo.o )

echo.hs:5:1: error:
    Could not find module ‘System’
    Use -v to see a list of the files searched for.
  |
5 | import System
  | ^^^^^^^^^^^^^
```

### 該当のソースコード
『ふつうのHaskellプログラミング』内のサンプルコードを写したものです。

```Haskell
import System

main = do args <- getArgs
            putStrLn $ unwords args

```

### 試したこと

```Haskell
import Prelude
```
を最上部に追加してみたのですがエラーメッセージに変化は見られませんでした。

Stackでのモジュールインポート

![イメージ説明](ba05dcc719e5ac0d6f61e33774ba411e.png)

OS:macOS Mojave 10.14.5

Brew doctorでWarning: Some installed formulae are not readable:   ghc@8.0: unknown version :lionが出ます。

![イメージ説明](bb2324777caee34bcb94a170cceb4961.jpeg)
ファイルの保存というところがまずわかりせん
適当に打ち込んで見ましたが全くわかりません、すいません。

線引いたところがわかりません

前置き
---
このコードをコンパイルすると、次のようなエラーを吐きます。[Wandbox](https://wandbox.org/permlink/6X4i0rCrXfGCwQVR)

```Haskell
-- Ex1.hs
main :: IO()
main = do
    let
        a = 1 :: Int
        b = 2 :: Int
        
    print $ (a / b :: Double)
```

```plain
prog.hs:8:14: error:
    • Couldn't match expected type ‘Double’ with actual type ‘Int’
    • In the second argument of ‘($)’, namely ‘(a / b :: Double)’
      In a stmt of a 'do' block: print $ (a / b :: Double)
      In the expression:
        do let a = ...
               b = ...
           print $ (a / b :: Double)
  |
8 |     print $ (a / b :: Double)
  |              ^^^^^
```

actual type 'Int' との文言は、 (/) :: Int -> Int -> Int の存在を示唆しているように思えます。
しかし、以下のコードもやはりエラーを吐きます。[Wandbox](https://wandbox.org/permlink/l8iJHxWTcONAhMo0)

```Haskell
-- Ex2.hs
main :: IO()
main = do
    let
        a = 1 :: Int
        b = 2 :: Int
        
    print $ (a / b :: Int)    -- 単に print $ a / b でも同様のエラーを吐く
```

```plain
prog.hs:8:14: error:
    • No instance for (Fractional Int) arising from a use of ‘/’
    • In the second argument of ‘($)’, namely ‘(a / b :: Int)’
      In a stmt of a 'do' block: print $ (a / b :: Int)
      In the expression:
        do let a = ...
               b = ...
           print $ (a / b :: Int)
  |
8 |     print $ (a / b :: Int)    -- 単に print $ a / b でも同様のエラーを吐く
  |              ^^^^^
```

エラーの原因が関数の存否に遡り、タイムトラベルを目撃したような気分です。

本題
---
最大の疑問は、次の二つです。

- **型の一致する関数が無いのであれば、なぜその時点でエラーが出ないのか？**
- **定義されていない筈の演算に、なぜ actual type が存在するのか？**

また、併せて次の点も気になります。

- **世のHaskellerは 整数÷整数=浮動小数 の計算をどのようにスマートに解決しているのか？**
暗黙の型変換が無い以上 fromIntegral に頼るしか無いのでしょうか。

- **整数÷整数=浮動小数 の計算を担う中置関数を自前で用意する場合、慣習的に用いられる命名はあるのか？**
とりあえず (*/) :: (Integral a, Integral b) => a -> b -> Double を定義してみましたが、高頻度で用意されそうな関数である以上、慣習的な命名があるのではと考えます。

答えやすい質問だけお答え頂いても結構です。

---
何か質問に不足がありましたら、どうぞ遠慮無くご指摘下さい。

未定義の関数のactual typeをどうして推測できるのか

Haskell 学習中に理解できない Warning に突き当たったので、どなたかご教授いただければと思います。
最小構成とWarning の内容を以下に記載します。

```lang-haskell
{-# OPTIONS -Wall -Werror #-}

square' :: Double -> Double
square' x = x ^ 2
```

```lang-sh
test.hs:5:15: Warning:
    Defaulting the following constraint(s) to type `Integer'
      (Integral b0) arising from a use of `^' at test.hs:5:15
      (Num b0) arising from the literal `2' at test.hs:5:17
    In the expression: x ^ 2
    In an equation for square': square' x = x ^ 2
```

環境は以下の通りです。

```lang-shell
$ ghc --version
The Glorious Glasgow Haskell Compilation System, version 7.6.3
```
よろしくお願いします。

`^' の Warning

HaskellでChurch numeralを実装しようと、
以下のような関数を定義しました。
```lang-Haskell
true x y = x
false x y = y
_if b x y = b x y
zero f x = x
one f x = f x
s n f x = f (n f x)
isZero n = n (\x->false) true
add m n f x = m f (n f x)
mult m n f = m (n f)
toInt n = n (+1) 0
toChurch 0 = zero
toChurch n = s (toChurch (n-1))
pre n f x = (n (\g h->h(g f)) (\u->x)) (\u->u)
```
toInt(add (toChurch 3) (toChurch 8))などは、きちんと11になります。preの定義はWikipediaから引っ張ってきました。

ところが、上の関数をSample.hsに書いて、ghciで読み込んだ後、次の単純な関数を定義しようとすると、エラーになります。直感的には、nが0なら1を、0以外ならそのまま返すだけの単純な関数なのですが…。
```lang-Haskell
let hoge n = _if (isZero n) one n
```
下記のエラーが出るのですが、型がうまく取れていなさそうだということしかわかりません。どうすればよいのでしょうか。
それとも、Haskellでは型の制限でChurch numeralを実装するのは不可能でしょうか。
---
Occurs check: cannot construct the infinite type:
  t2
  ~
  (t1 -> t3 -> t4 -> t4)
  -> (t6 -> t5 -> t6) -> ((t8 -> t7) -> t8 -> t7) -> t2 -> t
Relevant bindings include
  n :: (t1 -> t3 -> t4 -> t4)
       -> (t6 -> t5 -> t6) -> ((t8 -> t7) -> t8 -> t7) -> t2 -> t
    (bound at <interactive>:2:10)
  hoge :: ((t1 -> t3 -> t4 -> t4)
           -> (t6 -> t5 -> t6) -> ((t8 -> t7) -> t8 -> t7) -> t2 -> t)
          -> t
    (bound at <interactive>:2:5)
In the third argument of ‘_if’, namely ‘n’
In the expression: _if (isZero n) one n

HaskellでChurch numeralの実装

今更ですが、Haskellを始め、未知の世界の楽しさにハマっています。

そんなところ、関数モナドが今ひとつ飲み込めず、もやもやしています。

関数モナド（Readerモナドとも呼ぶようですね）のバインドの定義と実装は、

```Haskell
  (>>=) :: m a -> (a -> m b) -> m b

  h >>= f = \w -> f (h w) w
```
となっています。

ざっくりとした解釈では、`h`に`m a` に当たる、関数ファンクターの値（単引数の関数、例えば`(+3)`など）がセットされると思うのですが、この場合、`m`には`((->) r)`が対応することになります。ここでの`a`の実体はなんなのでしょうか？

Maybeファンクターなどは、`Just 3`のように、`a`に当たるものが明確なのでわかりやすいのですが、単引数の関数から、何を読み取れば`a`になるのかわからないのが、もやもやの原因です。

以上、ご回答いただければ、ありがたいです。

GHC