๐ data
ํ์
Haskell
์์ ํ์
์ ์ ์ํ๋ ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ ์ค ํ๋๋ data
์
๋๋ค.
data <type-name> <type-args>
= <type-constructor> <type>
| <type-constructor> <type>
| <type-constructor> <type>
| ...
newtype
๊ณผ ๋ค๋ฅด๊ฒ ์ฌ๋ฌ ํ์
์ธ์๋ฅผ ๋ฐ์ ์ ์๊ณ ,
์ฌ๋ฌ constructor
๋ฅผ ํ๋์ ํ์
์ ๋งค์นญ์ํฌ ์ ์๋ค๋ ํน์ง์ ๊ฐ์ง๊ณ ์์ต๋๋ค.
constructor
๋ค์ ํ์
์ธ์๋ 0๊ฐ ์ด์์ ์ ์ํ๋ฉด ๋ฉ๋๋ค.
๋ค์์ data
์ ์์์
๋๋ค.
data Bool = True | False
์ด์งธ ํํ๊ฐ ์ฐ๋ฆฌ๊ฐ ํํ ์ฌ์ฉํ๋ enum
๊ณผ ๋ง์ด ๋ฎ์์์ง์๋์?
๋๋ค๋ฅธ ์์๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
data Person = Person String Int -- ์ด๋ฆ๊ณผ ๋์ด๋ฅผ ์ธ์๋ก ๋ฐ๋ Person ํ์
์๋ ์ด๋ฆ๊ณผ ๋์ด๋ฅผ ์ธ์๋ก ๋ฐ๋ Person
ํ์
์ ์ ์ํ ๊ฒ์
๋๋ค.
๊ทธ๋ฐ๋ฐ ์์ ๊ฐ์ด ํ์ ์ ์ ์ํ ๊ฒฝ์ฐ ๊ฐ๊ฐ์ ํ์ ์ด ์๋ฏธํ๋ ๋ฐ๊ฐ ๋ฌด์์ธ์ง ๋ช ํํ์ง ์๋ค๋ ๋ฌธ์ ๊ฐ ์์ต๋๋ค.
๋จ์ํ ํ์ ์ด๋ผ๋ฉด ๋ฌธ์ ๊ฐ ์๋๊ฒ ์ง๋ง, ๋ณต์กํด์ง์๋ก ํ์ ์ด ํ๋ค ๊ฒ์ ๋๋ค.
์ด๋ด๋ record syntax
๋ฅผ ์ฌ์ฉํ๋ฉด ๋ช
ํํ ํ์ดํ์ด ๊ฐ๋ฅํด์ง๋๋ค.
๐ก Record Syntax
record syntax
๋ constructor
๊ฐ๊ฐ์ ํ์
์ ํ๋๋ฅผ ๋ถ์ผ ์ ์๋ ๊ธฐ๋ฅ์
๋๋ค.
์ฃผ์ํ ์ ์ ํ๋์ด๋ฆ ์ถฉ๋์ด ๋ฐ์ํ ์ ์๋ค๋ ๊ฒ์ธ๋ฐ,
์ด๋ฅผ ํผํ๊ธฐ ์ํด ๋ณดํต constructor
๋ช
์ prefix ๋ก ์ฌ์ฉํฉ๋๋ค.
data Person = Person { personName :: String, personAge :: Int }
{- โ
์ด์ ๋ค์๊ณผ ๊ฐ์ด ํํํ ์ ์์ต๋๋ค. -}
person = Person { personName = "owen", personAge = 28 }
Haskell
์ ๋ํ ํ๋๋ฅผ ์ถ์ถํ ์ ์๋ ํจ์๋ฅผ ์๋์ผ๋ก ์์ฑํด์ค๋๋ค.
์ ์์์์ ๋์ด
์ ๋ณด๋ฅผ ์ถ์ถํ๋ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
ghci > owen = Person { personName = "owen", personAge = 28 }
ghci > personAge owen // โ
personAge ํ๋๋ฅผ ์ถ์ถํ๋ ํจ์๊ฐ ์๋์์ฑ๋ฉ๋๋ค.
28
record syntax
์๋ ํ๋๋ฅผ ์
๋ฐ์ดํธ ํ ์ ์๋ ๋ฐฉ๋ฒ๋ ์ ๊ณตํด์ฃผ๋๋ฐ,
์ด๋ ์๋ณธ์ ๋ฐ๊พธ๋ ๊ฒ์ด ์๋๋ผ ์๋ก์ด ๊ฐ์ ๋ฐํํฉ๋๋ค.
ghci > personAge (owen { personAge = 20 })
20
ghci > personAge owen // โ
์๋ณธ์ ๋ณ๊ฒฝํ์ง ์์ต๋๋ค.
28
๐ Tuple & Either
data
๋ก ์ ์๋ ํ์
์ค ๋จผ์ ์ดํด๋ณผ๋งํ ๋๊ฐ์ง ํ์
Tuple
๊ณผ Either
๊ฐ ์์ต๋๋ค.
1๏ธโฃ Tuple
๋จผ์ Tuple
์ ์ฐ๋ฆฌ๊ฐ ํํ ์๋ ํํ ์๋ฃํ๊ณผ ๊ฐ์ต๋๋ค.
Haskell
์์๋ ๋ค์๊ณผ ๊ฐ์ด ํ์
์ด ์ ์๋์ด์์ต๋๋ค.
data Tuple a b = Tuple a b
์ฌ๊ธฐ์ a, b
๋ ๊ฐ๊ฐ ์ ๋ค๋ฆญ ํ์
์ด๊ธฐ ๋๋ฌธ์ ์ด๋ ํ์
์ด๋ ๋ฐ์ ์ ์์ต๋๋ค.
ํํ์ ๊ณ ์ ๊ธธ์ด์ ์๋ฃํ์ด๋ฉฐ ๋ค์๊ณผ ๊ฐ์ ์ถ์ฝ ๋ฌธ๋ฒ๋ ์ฌ์ฉ ๊ฐ๋ฅํฉ๋๋ค.
Tuple "apple" "banana"
{- ๋ค์์ผ๋ก ์ถ์ฝํํ ๊ฐ๋ฅํฉ๋๋ค. -}
("apple", "banana")
2๏ธโฃ Either
Either
์ ๋์ ๋ฐ๋ผ์ ๋๊ฐ์ง ํ์
์ค ํ๋๋ฅผ ์ ํํ ๊ฒฝ์ฐ ์ ์ฉํฉ๋๋ค.
ํํ ์๋ฌ ์ฒ๋ฆฌ๋ฅผ ํ ๋ ์ด ํ์ ์ ์ฌ์ฉํ๋ฉด ์ ์ฉํ๋ฐ, ๋ค์๊ณผ ๊ฐ์ด ์ ์๋์ด์์ต๋๋ค.
data Either a b = Left a | Right b
๋ค์๊ณผ ๊ฐ์ด ํจํด๋งค์นญ๊ณผ ํจ๊ป ํ์ฉํ๋ฉด ์๋ฌ ํธ๋ค๋ง์ด ๊ฐ๋ฅํ ๊ฒ์ ๋๋ค.
case response of
Left error -> {- ๐จ error case -}
Right result -> {- โ
200 response -}
๐ ์ฐธ๊ณ ์๋ฃ
'๐ archive' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Haskell Tutorial] Recursion (0) | 2022.12.31 |
---|---|
[Haskell Tutorial] High Order Function (0) | 2022.12.31 |
[Haskell Tutorial] Module (0) | 2022.11.28 |
[Haskell Tutorial] Type (0) | 2022.11.28 |
[Haskell Tutorial] Function & Chaining (0) | 2022.11.28 |
๐ฌ ๋๊ธ