НОУ ИНТУИТ | Язык и библиотеки Haskell 98. Лекция 10: Синтаксический справочник

Опубликован: 19.09.2008 | Доступ: свободный | Студентов: 658 / 70 | Оценка: 4.50 / 5.00 | Длительность: 21:25:00

Специальности: Программист, Архитектор программного обеспечения

9.4 Грамотные комментарии

Соглашение о "грамотных комментариях", впервые разработанное Ричардом Бердом (Richard Bird) и Филиппом Уодлером (Philip Wadler) для Orwell, и позаимствованное в свою очередь Дональдом Кнутом (Donald Knutd) для "грамотного программирования", является альтернативным стилем программирования исходного кода на Haskell . Грамотный стиль поощряет комментарии, создавая их по умолчанию. Строка, в которой ">" является первым символом, интерпретируется как часть программы; все остальные строки являются комментарием.

Текст программы восстанавливается путем выбора только тех строк, которые начинаются с ">", и замены первого ">" на пробел. В полученном тексте размещение и комментарии применяются в точности как описано в главе "9" .

Чтобы охватить некоторые случаи, где можно по ошибке пропустить ">", возникнет ошибка, если строка программы появится рядом с непробельной строкой комментария; строка рассматривается как пробельная, если она состоит только из пробельных символов.

Условно на стиль комментария указывает расширение файла: ".hs" указывает на обычный файл на Haskell, а ".lhs" указывает на файл с грамотным Haskell. С использованием этого стиля простая программа вычисления факториала могла бы выглядеть так:

Эта грамотная программа запрашивает у пользователя число
   и выводит на экран факториал этого числа:

> main :: IO ()

> main = do putStr "Введите число: "
>           l <- readLine
>           putStr "n!= "
>           print (fact (read l))
          
  Это программа вычисления факториала.

> fact :: Integer -> Integer
> fact 0 = 1
> fact n = n * fact (n-1)

Альтернативный стиль грамотного программирования особенно подходит для использования вместе с системой обработки текста LaTeX. По этому соглашению только те части грамотной программы, которые полностью заключены между разделителями \begin{code}...\end{code}, рассматриваются как текст программы; все остальные строки --- комментарии. Более точно:

Код программы начинается на первой строке, следующей за строкой, которая начинает \begin{code}.
Код программы заканчивается сразу перед последующей строкой, которая начинает \end{code} (конечно, игнорируя строковые литералы).

Нет необходимости вставлять дополнительные пустые строки до или после этих разделителей, хотя со стилистической точки зрения это может быть желательно. Например,

\documentstyle{article}

\begin{document}

\section{Introduction}

Это тривиальная программа, которая выводит первые 20 факториалов.

\begin{code}
main :: IO ()
main =  print [ (n, product [1..n]) | n <- [1..20]]
\end{code}

\end{document}

Этот стиль использует то же расширение файла. Нежелательно смешивать эти два стиля в одном файле.

9.5 Контекстно-свободный синтаксис

module	$\to$	module modid [exports] where body
	\|	body
body	$\to$	{ impdecls ; topdecls }
	\|	{ impdecls }
	\|	{ topdecls }
impdecls	$\to$	impdecl₁ ; ... ; impdecl_n	(n>=1)

Перевод:

модуль	$\to$	module идентификатор-модуля [список-экспорта] where тело
	\|	тело
тело	$\to$	{ список-объявлений-импорта ; список-объявлений-верхнего-уровня }
	\|	{ список-объявлений-импорта }
	\|	{ список-объявлений-верхнего-уровня }
список-объявлений-импорта	$\to$	объявление-импорта₁ ; ... ; объявление-импорта_n	(n>=1)

exports	$\to$	( export₁ , ... , export_n [ , ] )	(n>=0)
export	$\to$	qvar
	\|	qtycon [(..) \| ( cname₁ , ... , cname_n )]	(n>=0)
	\|	qtycls [(..) \| ( qvar₁ , ... , qvar_n )]	(n>=0)
	\|	module modid

Перевод:

список-экспорта	$\to$	( экспорт₁ , ... , экспорт_n [ , ] )	(n>=0)
экспорт	$\to$	квалифицированная-переменная
	\|	квалифицированный-конструктор-типа [(..) \| ( c-имя₁ , ... , c-имя_n )]	(n>=0)
	\|	квалифицированный-класс-типа [(..) \| ( квалифицированная-переменная₁ , ... , квалифицированная-переменная_n )]	(n>=0)
	\|	module идентификатор-модуля

impdecl	$\to$	import [qualified] modid [as modid] [impspec]
	\|		(пустое объявление)
impspec	$\to$	( import₁ , ... , import_n [ , ] )	(n>=0)
	\|	hiding ( import₁ , ... , import_n [ , ] )	(n>=0)
import	$\to$	var
	\|	tycon [ (..) \| ( cname₁ , ... , cname_n )]	(n>=0)
	\|	tycls [(..) \| ( var₁ , ... , var_n )]	(n>=0)
cname	$\to$	var \| con

Перевод:

объявление-импорта	$\to$	import [qualified] идентификатор-модуля [ as идентификатор-модуля] [спецификатор-импорта]
	\|		(пустое объявление)
спецификатор-импорта	$\to$	( импорт₁ , ... , импорт_n [ , ] )	(n>=0)
	\|	hiding ( импорт₁ , ... , импорт_n [ , ] )	(n>=0)
импорт	$\to$	переменная
	\|	конструктор-типа [ (..) \| ( c-имя₁ , ... , c-имя_n )]	(n>=0)
	\|	класс-типа [(..) \| ( переменная₁ , ... , переменная_n )]	(n>=0)
c-имя	$\to$	переменная \| конструктор

topdecls	$\to$	topdecl₁ ; ... ; topdecl_n	(n>=0)
topdecl	$\to$	type simpletype = type
	\|	data [context =>] simpletype = constrs [deriving]
	\|	newtype [context =>] simpletype = newconstr [deriving]
	\|	class [scontext =>] tycls tyvar [where cdecls]
	\|	instance [scontext =>] qtycls inst [where idecls]
	\|	default (type₁ , ... , type_n)	(n>=0)
	\|	decl

Перевод:

список-объявлений-верхнего-уровня	$\to$	объявление-верхнего-уровня₁ ; ... ; объявление-верхнего-уровня_n	(n>=1)
объявление-верхнего-уровня	$\to$	type простой-тип = тип
	\|	data [контекст $\Rightarrow$ ] простой-тип = список-конструкций [ deriving -инструкция]
	\|	newtype [контекст $\Rightarrow$ ] простой-тип = новая-конструкция [ deriving -инструкция]
	\|	class [простой-контекст $\Rightarrow$ ] класс-типа переменная-типа [ where список-объявлений-классов]
	\|	instance [простой-контекст $\Rightarrow$ ] квалифицированный-класс-типа экземпляр [ where список-объявлений-экземпляров]
	\|	default (тип₁ , ... , тип_n)	(n>=0)
	\|	объявление

decls	$\to$	{ decl₁ ; ... ; decl_n }	(n>=0)
decl	$\to$	gendecl
	\|	(funlhs \| pat⁰) rhs
cdecls	$\to$	{ cdecl₁ ; ... ; cdecl_n }	(n>=0)
cdecl	$\to$	gendecl
	\|	(funlhs \| var) rhs
idecls	$\to$	{ idecl₁ ; ... ; idecl_n }	(n>=0)
idecl	$\to$	(funlhs \| var) rhs
	\|		(empty)
gendecl	$\to$	vars :: [context =>] type	(сигнатура типа)
	\|	fixity [integer] ops	( infix -объявление)
	\|		(пустое объявление)
ops	$\to$	op₁ , ... , op_n	(n>=1)
vars	$\to$	var₁ , ..., var_n	(n>=1)
fixity	$\to$	infixl \| infixr \| infix

Перевод:

список-объявлений	$\to$	{ объявление₁ ; ... ; объявление_n }	(n>=0)
объявление	$\to$	общее-объявление
	\|	(левая-часть-функции \| образец⁰) правая-часть
список-объявлений-классов	$\to$	{ объявление-класса₁ ; ... ; объявление-класса_n }	(n>=0)
объявление-класса	$\to$	общее-объявление
	\|	(левая-часть-функции \| переменная) правая-часть
список-объявлений-экземпляров	$\to$	{ объявление-экземпляра₁ ; ... ; объявление-экземпляра_n }	(n>=0)
объявление-экземпляра	$\to$	(левая-часть-функции \| переменная) правая-часть
	\|		(пусто)
общее-объявление	$\to$	список-переменных :: [контекст $\Rightarrow$ ] тип	(сигнатура типа)
	\|	ассоциативность [целый-литерал] список-операторов	( infix -объявление)
	\|		(пустое объявление)
список-операторов	$\to$	оператор₁ , ... , оператор_n	(n>=1)
список-переменных	$\to$	переменная₁ , ... , переменная_n	(n>=1)
ассоциативность	$\to$	infixl \| infixr \| infix

type	$\to$	btype [-> type]	(тип функции)
btype	$\to$	[btype] atype	(наложение типов)
atype	$\to$	gtycon
	\|	tyvar
	\|	( type₁ , ... , type_k )	(тип кортежа, k>=2 )
	\|	[ type ]	(тип списка)
	\|	( type )	(конструктор в скобках)
gtycon	$\to$	gtycon
	\|	()	(тип объединения)
	\|	[]	(конструктор списка)
	\|	( $\to$ )	(конструктор функции)
	\|	(,{,})	(конструкторы кортежей)
context	$\to$	class
	\|	( class₁ , ... , class_n )	(n>=0)
class	$\to$	qtycls tyvar
	\|	qtycls ( tyvar atype₁ ... atype_n )	(n>=1)
scontext	$\to$	simpleclass
	\|	( simpleclass₁ , ... , simpleclass_n )	(n>=0)
simpleclass	$\to$	qtycls tyvar

Перевод:

тип	$\to$	b -тип [ $\to$ тип]	(тип функции)
b -тип	$\to$	[ b -тип] a -тип	(наложение типов)
a -тип	$\to$	общий-конструктор-типа
	\|	переменная-типа
	\|	( тип₁ , ... , тип_k )	(тип кортежа, k>=2 )
	\|	[ тип ]	(тип списка)
	\|	( тип )	(конструктор в скобках)
общий-конструктор-типа	$\to$	квалифицированный-конструктор-типа
	\|	()	(тип объединения)
	\|	[]	(конструктор списка)
	\|	( $\to$ )	(конструктор функции)
	\|	(,{,})	(конструкторы кортежей)
контекст	$\to$	класс
	\|	( класс₁ , ... , класс_n )	(n>=0)
класс	$\to$	квалифицированный-класс-типа переменная-типа
	\|	квалифицированный-класс-типа ( переменная-типа a-тип₁ ... a-тип_n )	(n>=1)
простой-контекст	$\to$	простой-класс
	\|	( простой-класс₁ , ... , простой-класс_n )	(n>=0)
простой-класс	$\to$	квалифицированный-класс-типа переменная-типа

Дальше >>

Авторизоваться

Язык и библиотеки Haskell 98

Синтаксический справочник

9.4 Грамотные комментарии

9.5 Контекстно-свободный синтаксис

Вопросы и ответы