초보자를 위한 하스켈 프로그램 상세 안내

박준규 @curry@hackers.pub

이 글은 원문을 ChatGPT로 번역한 것입니다.

이 글은 여러 줄의 텍스트에서 등호(=) 기호를 맞춰 정렬하는 작은 하스켈 프로그램을 개발하는 과정을 단계별로 안내합니다. 초보 프로그래머를 대상으로 하고 있어서 몇몇 단계와 개념을 평소보다 더 자세히 설명합니다.

이 글에서는 실험과 학습이 쉽도록 하나의 파일로 된 하스켈 프로그램을 작성하고, 컴파일하고, 실행하는 방법을 설명합니다. 더 큰 규모의 하스켈 프로젝트를 만들 때는 cabal이나 stack을 사용해서 프로젝트 뼈대를 만들고 실행하며, 다른 사람들과 작업을 공유하게 될 것입니다. 이렇게 단일 파일 방식으로 설명하는 이유는 가볍게 시작해서 언어를 바로 시도해볼 수 있는 가장 간단한 방법이기 때문입니다.

배경

저는 코드를 쓰기 쉬움보다는 읽기 쉬움에 중점을 두기 때문에 시각적인 정갈함에 신경을 많이 씁니다. 그중 한 가지 방법이 등호(=) 기호를 맞춰 정렬하는 것입니다. 예를 들어 처음에는 다음과 같이 코드가 작성되어 있을 수 있습니다.

address = "192.168.0.44"
port = 22
hostname = "wind"

이후 등호를 모두 같은 위치에 맞추기 위해 손으로 들여쓰기를 조정해서 아래처럼 만듭니다.

address  = "192.168.0.44"
port     = 22
hostname = "wind"

제가 사용하는 에디터는 vim이고, 이를 위해 Tabular 플러그인을 설치해서 사용할 수 있습니다. 하지만 함수형 스타일로 프로그램을 작성하는 방법을 보여주는 예제로 직접 처음부터 구현하는 것이 교육적일 것이라 생각했습니다.

vim의 유용한 기능 중 하나는 어떤 명령줄 프로그램이든 이용해 에디터 내부의 텍스트를 변환할 수 있다는 점입니다. 예를 들어 비주얼 모드로 텍스트를 선택한 다음 다음과 같이 입력할 수 있습니다.

:!some-command

그러면 vim은 선택한 텍스트를 some-command라는 명령줄 프로그램의 표준 입력으로 보내고, 그 프로그램이 표준 출력으로 내보낸 내용으로 선택된 텍스트를 교체합니다.

즉, 표준 입력으로 정렬할 텍스트를 받아서 정렬된 텍스트를 표준 출력으로 내보내는 프로그램만 작성하면 됩니다. 이 프로그램의 이름을 align-equals라고 부르겠습니다.

개발 환경

제 “IDE”는 명령줄입니다. 그래서 보통 최대 세 개의 터미널 창을 열어둔 상태로 작업합니다.

  • 한 창에서는 vim으로 텍스트를 편집합니다.
  • 한 창에서는 ghcid로 타입 오류를 실시간으로 확인합니다.
  • 한 창에서는 작성한 하스켈 코드를 REPL에서 테스트합니다.

또한 저는 Nix를 사용하며, 특히 nix-shell로 개발 도구를 구성합니다. 개발 도구를 설정할 때 Nix를 선호하는 이유는 시스템 전체에 불필요한 프로그램이 쌓이는 것을 피하고 싶기 때문입니다. nix를 사용하면 nix-shell을 이용해 필요한 개발 도구나 라이브러리를 일시적으로 구성할 수 있습니다.

아래와 같은 Nix 셸 안에서 앞으로 나오는 모든 예제를 실행합니다.(각 터미널을 새로 열 때마다 다음을 실행합니다.)

$ nix-shell --packages 'haskellPackages.ghcWithHoogle (pkgs: [ pkgs.text pkgs.safe ])' haskellPackages.ghcid

이렇게 하면 text와 safe 하스켈 패키지가 포함된 상태로 ghc, ghci, ghcid, hoogle를 사용할 수 있는 임시 셸이 만들어집니다. 사용 가능한 하스켈 패키지 목록을 바꾸고 싶다면 명령줄을 수정해서 셸을 다시 만들면 됩니다.

라이브 타입 체크를 켜기 위해 다음 명령을 실행합니다.

$ ghcid --command='ghci align-equals.hs'

이 명령을 실행하면 align-equals.hs 파일이 변경될 때마다 자동으로 다시 로드되고, 하스켈 컴파일러가 찾아낸 오류나 경고를 표시해줍니다.

다른 터미널에서는 작업 중인 코드를 ghci REPL에서 열어서 작성 중인 함수들을 대화형으로 테스트합니다.

$ ghci align-equals.hs
GHCi, version 8.2.2: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Main             ( test.hs, interpreted )
Ok, one module loaded.
*Main>

그리고 세 번째 터미널에서는 실제로 파일을 편집합니다.

$ vi align-equals.hs

프로그램

먼저, 코드를 작성하기 전에 우리가 할 일을 영어[1] 문장으로 설명해보겠습니다.

등호(=) 기호 앞에서 가장 긴 문자열을 찾아내고, 다른 모든 문자열 끝에 공백을 추가하여 가장 긴 문자열과 길이를 맞추고자 합니다.

등호 앞 문자열 길이

이를 구현하기 위해 먼저 주어진 한 줄에서 등호(=) 기호 앞의 문자 수를 계산하는 함수를 정의해야 합니다. 이 함수는 다음 타입을 가져야 합니다.

import Data.Text (Text)

prefixLength :: Text -> Int

이 타입 선언은 다음과 같이 읽을 수 있습니다.
“prefixLength는 입력으로 Text 타입의 값을 받고(즉, 한 줄의 입력), 출력으로 Int를 반환하는 함수이다. 반환 값은 첫 번째 = 기호 앞의 문자 수를 나타낸다.”

이 설명을 주석으로 추가할 수도 있습니다.

prefixLength
    :: Text
    -- ^ 입력 한 줄
    -> Int
    -- ^ 첫 번째 @=@ 기호 앞의 문자 수

저는 하스켈의 Prelude[2]에서 제공하는 기본 String 타입은 비효율적이어서 사용하지 않고, 대신 Data.Text 패키지의 고성능 타입인 Text와 유용한 도구를 사용합니다.

prefixLength 함수의 구현은 설명과 거의 동일합니다.

{-# LANGUAGE OverloadedStrings #-}

import Data.Text (Text)
import qualified Data.Text

prefixLength :: Text -> Int
prefixLength line = Data.Text.length prefix
  where
    (prefix, suffix) = Data.Text.breakOn "=" line

이름에서 알 수 있듯이, prefixLength는 등호 앞 문자열의 길이를 반환합니다. 유일하게 신경 쓸 부분은 이 목적을 위해 만들어진 Data.Text.breakOn 함수를 어떻게 찾는가입니다.

저는 보통 하스켈 패키지 문서를 찾을 때 구글에서 hackage ${패키지 이름}(예: hackage text)으로 검색합니다. 이렇게 해서 breakOn 함수를 찾았습니다.

또한 일부 사람들은 hoogle을 사용하여 함수 이름이나 타입으로 검색하기도 합니다. 예를 들어, Text 값을 등호 앞 문자열과 등호 뒤 문자열로 나누는 함수를 찾고 싶다면 다음과 같이 실행할 수 있습니다.

$ hoogle 'Text -> (Text, Text)'
Data.Text breakOn :: Text -> Text -> (Text, Text)
Data.Text breakOnEnd :: Text -> Text -> (Text, Text)
Data.Text.Lazy breakOn :: Text -> Text -> (Text, Text)
Data.Text.Lazy breakOnEnd :: Text -> Text -> (Text, Text)
Data.Text transpose :: [Text] -> [Text]
Data.Text.Lazy transpose :: [Text] -> [Text]
Data.Text intercalate :: Text -> [Text] -> Text
Data.Text.Lazy intercalate :: Text -> [Text] -> Text
Data.Text splitOn :: Text -> Text -> [Text]
Data.Text.Lazy splitOn :: Text -> Text -> [Text]
-- 더 많은 결과는 생략, --count=20 옵션으로 확인 가능

또한 제가 연 상태인 장시간 REPL에서 함수를 테스트하여 의도대로 동작하는지 확인할 수 있습니다.

*Main> :reload
Ok, one module loaded.
*Main> :set -XOverloadedStrings
*Main> Data.Text.breakOn "=" "foo = 1"
("foo ","= 1")
*Main> prefixLength "foo = 1"
4

OverloadedStrings 확장을 켜야 하는 이유는 Prelude의 기본 String 타입을 사용하지 않기 때문입니다. 이 확장은 다른 패키지가 문자열 리터럴을 대체 구현(Text 등)과 함께 사용할 수 있게 해줍니다.

하스켈의 멋진 점 중 하나는 코드 정의 순서에 크게 구애받지 않는다는 것입니다. 순서와 상관없이 정의할 수 있으며 컴파일러가 문제 삼지 않습니다. 따라서 다음과 같이 작성할 수 있습니다.

prefixLength line = Data.Text.length prefix
  where
    (prefix, suffix) = Data.Text.breakOn "=" line

이러한 순서 비의존적 코딩 스타일은 느린 평가(lazy evaluation)와도 잘 맞습니다. 하스켈은 “지연 평가(lazy)” 언어로, 사용되지 않는 값은 계산하지 않거나 평가 순서가 뒤바뀔 수도 있습니다. 예를 들어 prefixLength 함수는 실제로 suffix를 사용하지 않으므로 해당 값은 계산되지 않습니다.

하스켈로 프로그래밍할수록 코드를 단순한 명령문의 나열이 아니라, 서로 의존하는 계산들의 그래프로 생각하게 됩니다.

한 줄 들여쓰기

이제 등호 앞 문자열 끝에 공백을 추가하여 원하는 길이에 맞추는 함수를 정의해야 합니다.

adjustLine :: Int -> Text -> Text

주석을 추가하면 다음과 같이 쓸 수 있습니다.

adjustLine
    :: Int
    -- ^ 원하는 등호 앞 문자열 길이
    -> Text
    -- ^ 공백을 추가할 한 줄
    -> Text
    -- ^ 공백이 추가된 새 줄

이 함수는 길이가 조금 길지만, 여전히 직관적입니다.

adjustLine :: Int -> Text -> Text
adjustLine desiredPrefixLength oldLine = newLine
  where
    (prefix, suffix) = Data.Text.breakOn "=" oldLine

    actualPrefixLength = Data.Text.length prefix

    additionalSpaces = desiredPrefixLength - actualPrefixLength

    spaces = Data.Text.replicate additionalSpaces " "

    newLine = Data.Text.concat [ prefix, spaces, suffix ]

where 이후의 모든 줄은 순서를 바꿔도 프로그램 동작에는 영향을 주지 않습니다. 그러나 읽기 편하도록 다음과 같이 위에서 아래로 이해할 수 있는 순서로 나열합니다.

  • 한 줄을 등호 앞 문자열과 등호 뒤 문자열로 나눕니다.
  • 등호 앞 문자열의 실제 길이를 계산합니다.
  • 원하는 길이에서 실제 길이를 빼서 추가할 공백 수를 계산합니다.
  • 지정된 수만큼 공백을 반복하여 패딩을 생성합니다.
  • 등호 앞 문자열과 등호 뒤 문자열 사이에 패딩을 넣어 새 줄을 만듭니다.

이 코드 구조는 명령형 언어에서 정의한 함수처럼 읽힙니다. 예를 들어, 유사한 파이썬 코드는 다음과 같습니다.

def adjustLine(desiredPrefixLength, oldLine):
    (prefix, suffix) = oldLine.split("=")

    actualPrefixLength = len(prefix)

    additionalSpaces = desiredPrefixLength - actualPrefixLength

    spaces = " " * additionalSpaces

    # Python의 split은 '='를 제거하므로 다시 넣어야 함
    newLine = "".join([ prefix, spaces, "=", suffix ])

    return newLine

일반적으로, 함수형 프로그램이 단순 타입(문자열, 숫자, 레코드 등)을 사용하면 이렇게 명령형 프로그램으로 옮길 수 있습니다. 이러한 단순 프로그램에서 함수형 코드는 사실상 값을 재할당(“mutation”)하지 못하게 제한한 명령형 프로그램이라고 볼 수 있으며, 이는 프로그램 이해를 쉽게 하기 위한 좋은 습관입니다.

함수가 올바르게 동작하는지 확인하기 위해, 지금까지 작성한 전체 프로그램을 저장하고 REPL에서 다시 로드할 수 있습니다.

{-# LANGUAGE OverloadedStrings #-}

import Data.Text (Text)
import qualified Data.Text

prefixLength :: Text -> Int
prefixLength line = Data.Text.length prefix
  where
    (prefix, suffix) = Data.Text.breakOn "=" line

adjustLine :: Int -> Text -> Text
adjustLine desiredPrefixLength oldLine = newLine
  where
    (prefix, suffix) = Data.Text.breakOn "=" oldLine

    actualPrefixLength = Data.Text.length prefix

    additionalSpaces = desiredPrefixLength - actualPrefixLength

    spaces = Data.Text.replicate additionalSpaces " "

    newLine = Data.Text.concat [ prefix, spaces, suffix ]

그 다음, REPL에서 프로그램을 다시 로드합니다.

*Main> :reload
Ok, one module loaded.
*Main> adjustLine 10 "foo = 1"
"foo       = 1"

여러 줄 들여쓰기

이제 여러 줄을 들여쓰기 위한 함수를 정의할 수 있습니다.

import Safe

adjustText :: Text -> Text
adjustText oldText = newText
  where
    oldLines = Data.Text.lines oldText

    prefixLengths = map prefixLength oldLines

    newLines =
        case Safe.maximumMay prefixLengths of
            Nothing ->
                []
            Just desiredPrefixLength ->
                map (adjustLine desiredPrefixLength) oldLines

    newText = Data.Text.unlines newLines

이 함수는 lines와 unlines라는 두 가지 편리한 도구를 활용합니다.

Data.Text.lines는 한 블록의 Text를 여러 줄로 나누어 리스트로 반환합니다.

*Main> :type Data.Text.lines
Data.Text.lines :: Text -> [Text]

반대로 Data.Text.unlines는 여러 줄의 리스트를 다시 하나의 Text 블록으로 결합합니다.

*Main> :type Data.Text.unlines
Data.Text.unlines :: [Text] -> Text

이 두 도구를 사용하면 하스켈에서 줄 단위 Text 변환 작업을 간단하게 수행할 수 있습니다.

  • 한 블록의 Text를 여러 줄로 나눕니다.
  • 줄 리스트를 처리하여 새 줄 리스트를 만듭니다.
  • 새 줄 리스트를 다시 하나의 Text 블록으로 결합합니다.

adjustText 함수에서 흥미로운 부분은 줄 리스트를 처리하는 방식입니다.

prefixLengths = map prefixLength oldLines

newLines =
    case Safe.maximumMay prefixLengths of
        Nothing ->
            []
        Just desiredPrefixLength ->
            map (adjustLine desiredPrefixLength) oldLines

위 코드는 다음과 같이 읽을 수 있습니다.

  • 각 줄에 대해 prefixLength 함수를 적용(map)하여 등호 앞 문자열 길이 리스트를 만듭니다.
  • 최대 길이를 찾습니다.
  • 최대 길이가 없으면 빈 줄 리스트를 반환합니다.
  • 최대 길이가 있으면 각 줄을 해당 길이에 맞춰 공백을 추가합니다.

여기서 궁금할 수 있습니다. “왜 최대 길이가 없을 수 있지?”
예를 들어 입력이 0줄일 때, 빈 리스트의 최대값은 무엇일까요?
maximumMay 함수는 예외를 발생시키거나 실제 데이터와 혼동될 수 있는 잘못된 값을 반환하지 않습니다. 대신, maximumMay는 선택적 결과를 반환합니다.

data Maybe a = Just a | Nothing

maximumMay :: Ord a => [a] -> Maybe a

maximumMay 타입의 a는 비교 가능한 타입이면 무엇이든 될 수 있으며(Ord를 구현), 이 코드에서는 Int 타입이므로 실제로는 다음과 같이 생각할 수 있습니다.

maximumMay :: [Int] -> Maybe Int

즉, Int 리스트를 입력으로 받으면 maximumMay는 Int를 반환할 수도 있고 반환하지 않을 수도 있습니다. 결과는 Nothing(결과 없음) 또는 Just에 감싼 Int 값이 됩니다.

maximumMay의 결과는 다음과 같이 패턴 매칭으로 처리합니다.

case Safe.maximumMay prefixLengths of
    Nothing ->
        ...  -- 첫 번째 경우
    Just desiredPrefixLength ->
        ...  -- 두 번째 경우

첫 번째 경우는 리스트가 비어 있을 때입니다. 이때 desiredPrefixLength는 범위 내에 없으므로, 해당 값을 사용하려고 하면 타입 오류가 발생합니다. 이는 존재하지 않는 결과에 접근하지 못하도록 안전장치를 제공합니다. 다른 언어에서는 런타임에 java.lang.NullPointerException 또는 AttributeError: 'NoneType' object has no attribute 'x'와 같은 오류가 발생할 수 있지만, 하스켈에서는 패턴 매칭을 통해 컴파일 단계에서 이러한 버그를 미리 발견할 수 있습니다.

두 번째 경우는 리스트가 비어 있지 않고 합리적인 최대 길이를 가진 경우입니다. 이 길이를 사용하여 각 줄을 조정합니다.

패턴 매칭의 장점은 이러한 경우들을 반드시 처리해야 한다는 점입니다. 만약 maximumMay 결과를 직접 Int로 사용하려 하면 타입 오류가 발생합니다. maximumMay는 자신의 결과를 Maybe로 감싸서, 리스트가 비어 있을 가능성을 사용자가 신중하게 고려하도록 강제합니다.

모두 연결하기

지금까지 작성한 모든 함수는 “순수(pure)” 함수입니다.
즉, 입력을 출력으로 변환하는 과정이 결정적이며, 변수를 변경하지 않고 우리가 신경 쓰는 부작용도 발생시키지 않습니다.

여기서 중요한 표현은 “우리가 신경 쓰는 부작용”입니다. 실제로 이 함수들도 기술적으로는 부작용을 가집니다.

  • 메모리/레지스터 할당
  • 계산에 걸리는 유한한 시간

특정 상황에서는 이러한 부작용이 중요할 수 있습니다. 예를 들어, 암호학에서는 보안 정보가 부작용을 통해 유출될 수 있고, 임베디드 프로그래밍에서는 시간과 메모리에 주의를 기울여야 합니다. 하지만 간단한 프로그램에서는 이 함수들을 사실상 “순수”하다고 볼 수 있습니다.

이제 이 프로그램 함수를 명령줄에서 사용하려면, 프로그램이 실행할 수 있는 main 함수를 작성해야 합니다.

import qualified Data.Text.IO

main :: IO ()
main = Data.Text.IO.interact adjustText

interact 함수는 순수한 Text 변환을 표준 입력에서 표준 출력으로 실행할 수 있는 프로그램으로 변환합니다.

*Main> :type Data.Text.IO.interact
Data.Text.IO.interact :: (Text -> Text) -> IO ()

이것은 “고차 함수”의 예입니다. 즉, 입력으로 다른 함수를 받는 함수입니다.
interact 함수의 입력은 Text -> Text 타입의 함수입니다. 다행히 adjustText 함수의 타입이 정확히 일치합니다.

adjustText :: Text -> Text
Data.Text.IO.interact adjustText :: IO ()

그 다음, IO () 타입의 값을 main에 할당하면, 프로그램이 명령줄 실행 시 실행할 동작이 됩니다.

예를 들어, 다음 전체 예제를 align-equals.hs로 저장합니다.

{-# LANGUAGE OverloadedStrings #-}

module Main where

import Data.Text (Text)
import qualified Data.Text
import qualified Data.Text.IO
import qualified Safe

prefixLength :: Text -> Int
prefixLength line = Data.Text.length prefix
  where
    (prefix, suffix) = Data.Text.breakOn "=" line

adjustLine :: Int -> Text -> Text
adjustLine desiredPrefixLength oldLine = newLine
  where
    (prefix, suffix) = Data.Text.breakOn "=" oldLine

    actualPrefixLength = Data.Text.length prefix

    additionalSpaces = desiredPrefixLength - actualPrefixLength

    spaces = Data.Text.replicate additionalSpaces " "

    newLine = Data.Text.concat [ prefix, spaces, suffix ]

adjustText :: Text -> Text
adjustText oldText = newText
  where
    oldLines = Data.Text.lines oldText

    prefixLengths = map prefixLength oldLines

    newLines =
        case Safe.maximumMay prefixLengths of
            Nothing ->
                []
            Just desiredPrefixLength ->
                map (adjustLine desiredPrefixLength) oldLines

    newText = Data.Text.unlines newLines

main :: IO ()
main = Data.Text.IO.interact adjustText

그 후, 다음과 같이 컴파일할 수 있습니다.

$ ghc -O2 align-equals.hs

실행 파일이 올바르게 작동하는지 확인합니다.

$ ./align-equals
foo = 1
a = 2
asdf = 3
<Ctrl-D>
foo  = 1
a    = 2
asdf = 3

이제 ./align-equals를 사용하여 텍스트 블록을 정렬할 수 있습니다. 예를 들어:

address = "192.168.0.44"
port = 22
hostname = "wind"

명령줄에서 :!./align-equals를 실행하면 블록이 정렬됩니다.

address  = "192.168.0.44"
port     = 22
hostname = "wind"

이제 코드를 일일이 수동으로 정렬할 필요가 없습니다.

결론

이번 글을 통해 작은 실용적 프로그램을 작성하는 과정에서 하스켈 언어를 배우는 한 가지 방법을 보여드렸습니다.
하스켈은 흥미로운 기능과 개념이 많으며, 이 글에서는 그 극히 일부만 다루었습니다.

  1. 역자주: 여기서는 한글. ↩︎

  2. 역자주: 하스켈 기본 라이브러리. ↩︎

8
0
0

No comments

If you have a fediverse account, you can comment on this article from your own instance. Search https://hackers.pub/ap/articles/0198c239-3f5a-773b-82bd-2e54e2ac5f1f on your instance and reply to it.