在Haskell中实现基本的数据结构，如栈、队列等

在Haskell中，我们可以使用列表（List）来实现基本的数据结构，例如栈和队列。下面是如何实现一个栈和一个队列，并提供一些使用例子。

1. 栈（Stack）的实现：

栈是一种后进先出（LIFO）的数据结构。我们可以使用Haskell的列表来模拟栈的操作。以下是一个栈的实现：

module Stack (
    Stack,
    empty,
    isEmpty,
    push,
    pop,
    top
) where

data Stack a = Stack [a] deriving Show

empty :: Stack a
empty = Stack []

isEmpty :: Stack a -> Bool
isEmpty (Stack []) = True
isEmpty _ = False

push :: a -> Stack a -> Stack a
push x (Stack xs) = Stack (x:xs)

pop :: Stack a -> Stack a
pop (Stack []) = error "Empty stack"
pop (Stack (_:xs)) = Stack xs

top :: Stack a -> a
top (Stack []) = error "Empty stack"
top (Stack (x:_)) = x

上面的代码中，我们使用data关键字定义了Stack类型，它包含一个列表作为内部存储结构。empty函数返回一个空栈，isEmpty函数检查栈是否为空，push函数将元素添加到栈的顶部，pop函数移除栈顶元素，top函数返回栈顶元素。

以下是一个使用栈的例子：

import Stack

example :: Stack Int
example = push 3 (push 2 (push 1 empty))

main :: IO ()
main = do
    putStrLn $ "Example stack: " ++ show example
    putStrLn $ "Is example stack empty? " ++ show (isEmpty example)
    putStrLn $ "Top of example stack: " ++ show (top example)
    putStrLn $ "Pop example stack: " ++ show (pop example)

输出结果如下：

Example stack: Stack [1,2,3]
Is example stack empty? False
Top of example stack: 1
Pop example stack: Stack [2,3]

2. 队列（Queue）的实现：

队列是一种先进先出（FIFO）的数据结构。我们可以使用Haskell的列表来实现一个简单的队列。以下是一个队列的实现：

module Queue (
    Queue,
    empty,
    isEmpty,
    enqueue,
    dequeue,
    front
) where

data Queue a = Queue [a] deriving Show

empty :: Queue a
empty = Queue []

isEmpty :: Queue a -> Bool
isEmpty (Queue []) = True
isEmpty _ = False

enqueue :: a -> Queue a -> Queue a
enqueue x (Queue xs) = Queue (xs ++ [x])

dequeue :: Queue a -> Queue a
dequeue (Queue []) = error "Empty queue"
dequeue (Queue (_:xs)) = Queue xs

front :: Queue a -> a
front (Queue []) = error "Empty queue"
front (Queue (x:_)) = x

上面的代码中，我们使用data关键字定义了Queue类型，它包含一个列表作为内部存储结构。empty函数返回一个空队列，isEmpty函数检查队列是否为空，enqueue函数将元素添加到队列的末尾，dequeue函数移除队列的第一个元素，front函数返回队列的第一个元素。

以下是一个使用队列的例子：

import Queue

example :: Queue Int
example = enqueue 1 (enqueue 2 (enqueue 3 empty))

main :: IO ()
main = do
    putStrLn $ "Example queue: " ++ show example
    putStrLn $ "Is example queue empty? " ++ show (isEmpty example)
    putStrLn $ "Front of example queue: " ++ show (front example)
    putStrLn $ "Dequeue example queue: " ++ show (dequeue example)

输出结果如下：

Example queue: Queue [1,2,3]
Is example queue empty? False
Front of example queue: 1
Dequeue example queue: Queue [2,3]

通过以上例子，我们可以看到如何在Haskell中使用列表实现基本的数据结构，如栈和队列。