02 0부터 시작

대화형 환경에서의 간단한 테스트
명령줄 프롬프트 설정: set prompt "ghci>"사칙 연산

ghci> 2 + 15
17

ghci> 49 * 100
4900

ghci> 1892 - 1472
420

ghci> 5 / 2
2.5

ghci>

괄호 우선 순위 변경

ghci> (50 * 100) - 4999
1  

ghci> 50 * 100 - 4999
1  

ghci> 50 * (100 - 4999)
-244950

볼 연산

ghci> True && False
False

ghci> True && True
True

ghci> False || True
True

ghci> not False
True

ghci> not (True && True)
False

상등성 판단

ghci> 5 == 5
True

ghci> 1 == 0
False

ghci> 5 /= 5
False

ghci> 5 /= 4
True

ghci> "hello" == "hello"
True

유형 오류
함수에 전달되는 매개 변수의 유형은 반드시 요구에 부합해야 한다. 그렇지 않으면 오류가 발생할 수 있다

ghci> 5+"llama"

No instance for (Num [Char])
arising from a use of `+' at :1:0-9
Possible fix: add an instance declaration for (Num [Char])
In the expression: 5 + "llama"
In the definition of `it': it = 5 + "llama"

호출 함수
함수 호출은 괄호가 필요 없고, 매개 변수 사이는 빈칸으로 구분됩니다

ghci> succ 8
9

ghci> min 9 10
9

ghci> min 3.4 3.2
3.2

ghci> max 100 101
101

함수의 높은 우선 순위
함수는 오른쪽으로 결합한 것이다

ghci> succ 9 + max 5 4 + 1
16

ghci> (succ 9) + (max 5 4) + 1
16

사용자 정의 함수
Haskell의 사용자 정의 함수와 수학의 함수는 매우 유사하다. 예를 들어f(x) = x + x아래에 정의된 함수는 하나의 수를 곱하기 2

doubleMe x = x + x

저장 및 로드baby.hs 파일로 저장하고 :l 명령으로 불러오기

ghci> :l baby  
[1 of 1] Compiling Main             ( baby.hs, interpreted )
Ok, modules loaded: Main.

ghci> doubleMe 9
18

ghci> doubleMe 8.3
16.6

분기 표현식if ... then ... else ...**Haskell **에서

if문장은 표현식이기 때문에 되돌아오는 값이 있다

필수 eles 문장

두 지점이 되돌아오는 데이터 형식은 같아야 하며 그렇지 않으면 오류가 발생해야 한다

doubleSmallNumber x = if x > 100
                      then x
                      else  x*2

if문장은 표현식이기 때문에 최종적으로 하나의 값으로 간소화할 수 있기 때문에 어디에나 사용할 수 있다

doubleSmallNumber' x = (if x > 100 then x else x*2) + 1

함수의 명명 규범

함수 이름에 작은따옴표 사용 가능

함수 이름의 자모는 반드시 소문자로 써야 한다

매개 변수(변수)가 없는 함수는 상수를 정의한 것과 같고 그의 값은 수정할 수 없다

List 시작
List는 본질적으로 하나의 서열로 다른 동적 언어와 달리 서열의 항목은 같은 유형이다
참고: 상호작용 환경에서는 let로 변수를 정의해야 합니다.

ghci> let lostNumbers = [4,8,15,16,23,48]  
ghci> lostNumbers  
[4,8,15,16,23,48]

++ 합병 연산

[1,2,3,4] ++ [9,10,11,12]  ==  [1,2,3,4,9,10,11,12]

: 목록 헤더에 원소를 추가하면 속도가 매우 빠르다

'A' : " SMALL CAT"  ==  "A SMALL CAT" 
5:[1,2,3,4,5]  ==  [5,1,2,3,4,5]

[] 빈 목록
빈 리스트 는 리스트 의 가장 안쪽 원소 이고, 리스트 는 사실상 일련 의 열 연결 연산 의 문법 설탕 이다

[1,2,3] ==  1:2:3:[]

!! 색인 목록의 요소, 경계를 넘지 않도록 주의하십시오

"Steve Buscemi" !! 6  ==  'B' 
[9.4,33.2,96.2,11.2,23.25]!! 1  ==  33.2

목록의 목록
목록에 목록을 끼워 넣을 수 있지만, 하위 목록의 유형은 같아야 합니다

ghci> let b = [[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
ghci> b
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]

ghci> b ++ [[1,1,1,1]]
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3],[1,1,1,1]]

ghci> [6,6,6]:b
[[6,6,6],[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]

ghci> b !! 2
[1,2,2,3,4]

목록 크기 비교
목록은 크기를 비교할 수 있으며, 비교할 때 그 중의 원소를 순서대로 비교한다

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

ghci> [3,2,1] > [2,10,100]  
True  

ghci> [3,4,2] > [3,4]  
True  

ghci> [3,4,2] > [2,4]  
True  

ghci> [3,4,2] == [3,4,2]  
True

head 목록의 헤더 꺼내기

head [5,4,3,2,1]  ==  5 

tail 머리 이외의 부분 꺼내기

tail [5,4,3,2,1]   ==  [4,3,2,1] 

last 목록의 끝 제거

last [5,4,3,2,1]   ==  1 

init 꼬리 빼기

init [5,4,3,2,1]  ==  [5,4,3,2]

주의: 위의 네 함수에서 빈 목록을 처리하면 오류가 발생합니다

ghci> head []  
*** Exception: Prelude.head: empty list

length 리스트 길이를 반환합니다.

ghci> length [5,4,3,2,1]  
5

null List가 비어 있는지 확인

ghci> null [1,2,3]  
False  

ghci> null []  
True

reverse List 반전

ghci> reverse [5,4,3,2,1]  
[1,2,3,4,5]

take 목록의 처음 몇 개의 요소를 되돌려줍니다

List 길이를 초과한 원소 개수를 얻으면 원 List

만 얻을 수 있다

만약 take 0 원소가 있다면 빈 Lis를 얻을 수 있습니다!

ghci> take 3 [5,4,3,2,1]  
[5,4,3]  

ghci> take 1 [3,9,3]  
[3]  

ghci> take 5 [1,2]  
[1,2]  

ghci> take 0 [6,6,6] 
[]

drop 목록의 처음 요소 삭제

ghci> drop 3 [8,4,2,1,5,6]  
[1,5,6]  

ghci> drop 0 [1,2,3,4]  
[1,2,3,4]  

ghci> drop 100 [1,2,3,4]  
[]

maximum 목록에서 가장 큰 요소를 되돌려줍니다minimun 목록에서 가장 작은 요소를 되돌려줍니다

ghci> minimum [8,4,2,1,5,6]  
1  
ghci> maximum [1,9,2,3,4]  
9

sum 목록에 있는 모든 요소의 및product 목록의 모든 요소의 적을 되돌려줍니다

ghci> sum [5,2,1,6,3,2,5,7]  
31  

ghci> product [6,2,1,2]  
24  

ghci> product [1,2,5,6,7,9,2,0]  
0

elem 원소가 목록에 있는지 판단

ghci> 4 `elem` [3,4,5,6]  
True  
ghci> 10 `elem` [3,4,5,6]  
False

Range 사용Range 질서정연한 서열을 정의할 수 있습니다
이른바 서열은 수학상의 수열과 유사하여 점차 증가하거나 감소할 수 있다

[1..20]  ==  [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] 
['a'..'z']  ==  "abcdefghijklmnopqrstuvwxyz" 
['K'..'Z']  ==  "KLMNOPQRSTUVWXYZ" 

시퀀스 간격을 지정할 수 있습니다.

[2,4..20]  ==  [2,4,6,8,10,12,14,16,18,20] 
[3,6..20]  ==  [3,6,9,12,15,18] 

부동 소수점 수를 사용하여 시퀀스를 만들지 마십시오. 정확하지 않습니다.

[0.1, 0.3 .. 1]   ==  [0.1,0.3,0.5,0.7,0.8999999999999999,1.0999999999999999] 

불활성cycle 무한 순환 시퀀스 만들기

take 10 (cycle [1,2,3])  ==  [1,2,3,1,2,3,1,2,3,1] 
take 12 (cycle"LOL ")  ==  "LOL LOL LOL " 

repeat 무한 길이의 시퀀스 만들기

take 10 (repeat 5)  ==  [5,5,5,5,5,5,5,5,5,5]

목록 확인
목록 해석은 본질적으로 대수상의 집합 변환이다.다음은 서열의 원소를 배로 늘립니다

[x*2 | x 

조건 필터
집합에 필터 조건을 설정해야 조건에 맞는 항목이 새 목록에 들어갈 수 있습니다
다음 조건은 서열에서 배가된 원소12보다 큰 원소만 배가된 후 새로운 서열에 들어갑니다

[x*2 | x = 12]  == [12,14,16,18,20]

취50에서 100 사이의 모든 제7여3의 원소

[ x | x 

참고: 조건은 쉼표로 구분됩니다.
다중 조건 필터
여러 필터 기준 설정 가능

[ x | x 

다중 목록 확인
여러 시퀀스를 한 시퀀스로 각각

주의: 필터 조건은 여러 해석 변수를 사용하여 연산할 수 있음

두 변수의 연산 결과를 새 서열에 넣기

[ x*y | x  50]  == [55,80,100,110]

전체 정렬
여러 개의 서열을 해석할 때는 일종의 전체 배열 조합이다

ghci> let nouns = ["hobo","frog","pope"]
ghci> let adjectives = ["lazy","grouchy","scheming"]

ghci> [adjective ++ " " ++ noun | adjective 

목록 해석으로 length 함수 구현
목록의 요소가 무엇인지에 관심이 없으면 밑줄로 대체할 수 있습니다

length' xs = sum [1 | _ 

대문자 필터링
조건 필터로 대문자를 필터하는 거예요.
주의: 여기 \elem` 함수를 사용했습니다

removeNonUppercase st = [ c | c  removeNonUppercase "Hahaha! Ahahaha!"
"HA"

ghci> removeNonUppercase "IdontLIKEFROGS"
"ILIKEFROGS"

네스트된 목록 확인
해석된 항목이 목록이라면 다시 해석할 수 있습니다

ghci> let xxs = [[1,3,5,2,3,1,2,4,5],[1,2,3,4,5,6,7,8,9],[1,2,4,2,1,6,3,1,3,2,3,6]]

ghci> [ [ x | x 

원조
목록은 하나의 수조와 같고, 원조는 벡터와 같으며, 그 중 모든 요소는 하나의 분량이다
원조는 자신의 데이터 형식이 있고 분량의 수량과 유형이 원조의 유형을 결정한다.아래의 이 목록은 잘못된 것입니다. 왜냐하면 그 중의 원조 유형이 다르기 때문입니다

[(1,2),(8,11,5),(4,5)]

Couldn't match expected type `(t, t1)'
against inferred type `(t2, t3, t4)'
In the expression: (8, 11, 5)
In the expression: [(1, 2), (8, 11, 5), (4, 5)]
In the definition of `it': it = [(1, 2), (8, 11, 5), (4, 5)]

모듈 비교 크기

Prelude> (1,2,3)>(2,3,4)
False

일원조가 없다
가장 짧은 원조도 두 개의 분량이 있어야 하는데, 이를 이원조 또는 서대라고 한다.
일원조는 의미가 없고 데이터 자체이다

Prelude> (2)
2

Prelude> (1,2)
(1,2)

이원조의 분량을 취하다

fst 추출 순서 쌍의 첫 번째 분량

snd 추출 순서 쌍의 두 번째 분량

주의: fstsnd 이 두 함수는 이원조만 처리할 수 있고 다원조는 처리할 수 없습니다.

ghci> fst (8,11)
8

ghci> fst ("Wow", False)
"Wow"

ghci> snd (8,11)
11

ghci> snd ("Wow", False)
False

zip 함수zip 함수는 두 목록의 요소를 조합하여 하나의 이원조 목록으로 만들 수 있다
주의: 목록 해석 처리를 하면 전체 배열이 됩니다. map 을 사용할 수 있습니까?

ghci> zip [1,2,3,4,5] [5,5,5,5,5]
[(1,5),(2,5),(3,5),(4,5),(5,5)]

ghci> zip [1 .. 5] ["one", "two", "three", "four", "five"]
[(1,"one"),(2,"two"),(3,"three"),(4,"four"),(5,"five")]

서로 다른 길이의 목록도 조합할 수 있으며, 비교적 짧은 것을 기준으로 한다

ghci> zip [1..] ["apple", "orange", "cherry", "mango"]
[(1,"apple"),(2,"orange"),(3,"cherry"),(4,"mango")]

목록을 통해 구성 모듈의 목록을 분석합니다
문제: 모든 변의 길이가 10보다 작고 둘레가 24와 같은 직각 삼각형을 찾아라
주의: 이곳의 해석 조건은 세 개의 해석 변수를 사용하여 연산합니다

ghci> let rightTriangles' = 
        [(a,b,c) |  c  rightTriangles'
[(6,8,10)]