Haskell: Where vs. Let

Jestem nowy w Haskell i jestem bardzo zdezorientowany gdzie vs. Let. Oba wydają się mieć podobny cel. Przeczytałem kilka porównań pomiędzy gdzie vs. Let ale mam problem z rozeznaniem, kiedy użyć każdego. Czy ktoś mógłby podać jakiś kontekst lub może kilka przykładów, które pokazują, kiedy używać jednego nad drugim?

Gdzie kontra Let

Klauzula where może być zdefiniowana tylko na poziomie definicja funkcji. Zazwyczaj jest to tożsame z zakresem definicji let. jedyną różnicą jest to, kiedy strażnicy są używane . Zakres klauzuli where rozciąga się na wszystkie straże. W przeciwieństwie do tego, Zakres wyrażenia let jest tylko bieżącą klauzulą funkcji i strażnikiem, jeśli istnieje.

Haskell Ściągawka

Haskell Wiki jest bardzo szczegółowa i zawiera różne przypadki, ale wykorzystuje hipotetyczne przykłady. Znajduję jego wyjaśnienia zbyt krótkie jak na początkującego.

Zalety Let :

f :: State s a
f = State $ \x -> y
   where y = ... x ...

Kontrola.Monad.Stan

Nie zadziała, bo gdzie odnosi się do wzór pasujący f =, gdzie nie ma x jest w zasięgu. Natomiast, jeśli zaczęło się od let, wtedy nie mieć kłopoty.

Haskell Wiki o zaletach Let

f :: State s a
f = State $ \x ->
   let y = ... x ...
   in  y

Zalety miejsca :

f x
  | cond1 x   = a
  | cond2 x   = g a
  | otherwise = f (h x a)
  where
    a = w x

f x
  = let a = w x
    in case () of
        _ | cond1 x   = a
          | cond2 x   = g a
          | otherwise = f (h x a)

Deklaracja vs. Wyrażenie

Haskell wiki wspomina, że gdzie klauzula jest deklaratywna, podczas gdy niech wyrażenie jest ekspresyjne. Pomijając styl, w jaki sposób działają inaczej?

Declaration style                     | Expression-style
--------------------------------------+---------------------------------------------
where clause                          | let expression
arguments LHS:     f x = x*x          | Lambda abstraction: f = \x -> x*x
Pattern matching:  f [] = 0           | case expression:    f xs = case xs of [] -> 0
Guards:            f [x] | x>0 = 'a'  | if expression:      f [x] = if x>0 then 'a' else ...

1. w pierwszym przykładzie dlaczego Let jest w zakresie, ale gdzie nie jest?
2. czy można zastosować gdzie do pierwszego przykładu?
3. czy niektórzy mogą zastosować to do rzeczywistych przykładów, w których zmienne reprezentują rzeczywiste wyrażenia?
4. czy istnieje ogólna zasada, której należy przestrzegać, kiedy używać każdego z nich?

Update

Dla tych, którzy przychodzą do tego wątku później znalazłem najlepsze wyjaśnienie, aby znaleźć tutaj: " łagodne wprowadzenie do Haskell {30]}".

Niech Wyrażenia.

Wyrażenia niech Haskella są użyteczne ilekroć zagnieżdżony zestaw wiązań jest wymagane. Jako prosty przykład, consider:

let y   = a*b
    f x = (x+y)/y
in f c + f d

Zestaw wiązań created by a let wyrażenie jest wzajemnie rekurencyjne, a wiązania wzorcowe traktowane są jako leniwe wzorce (tzn. niosą ze sobą implicit ~). Jedyny rodzaj deklaracji dozwolone są podpisy typów, wiązania funkcyjne i wzór wiązania.

Gdzie

Czasami jest to wygodne, aby zakres wiązania na kilku strzeżonych równań, co wymaga gdzie klauzula:

f x y  |  y>z           =  ...
       |  y==z          =  ...
       |  y<z           =  ...
     where z = x*x

Zauważ, że nie można tego zrobić za pomocą wyrażenia let, które tylko zakresy nad wyrażeniem, które zamyka. Klauzula where jest dozwolona tylko na najwyższym poziomie zbioru równań lub wyrażeń przypadków. Te same właściwości i ograniczenia dotyczące powiązań w wyrażeniach niech mają zastosowanie do tych w klauzulach where. Te dwie formy zagnieżdżonego zakresu wydają się bardzo podobne, ale pamiętaj, że wyrażenie let jest wyrażeniem, podczas gdy klauzula where nie jest -- jest częścią składni deklaracji funkcji i wyrażeń case.