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

Учитесь и получайте официальные документы БЕСПЛАТНО. Вы можете поддержать наш проект.

Регистрация Вход

Твой путь к знаниям!

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

Тема: Программирование

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

|

Вам нравится? Нравится 5 студентам

| Поделиться |

Поддержать курс

| Скачать электронную книгу

simpletype	$\to$	tycon tyvar₁ ... tyvar_k	(k>=0)
constrs	$\to$	constr₁ \| ... \| constr_n	(n>=1)
constr	$\to$	con [!] atype₁ ... [!] atype_k	(число аргументов конструктора con = k, k>=0 )
	\|	(btype \| ! atype) conop (btype \| ! atype)	(инфиксный оператор conop)
	\|	con { fielddecl₁ , ... , fielddecl_n }	(n>=0)
newconstr	$\to$	con atype
	\|	con { var :: type }
fielddecl	$\to$	vars :: (type \| ! atype)
deriving	$\to$	deriving (dclass \| (dclass₁, ... , dclass_n))	(n>=0)
dclass	$\to$	qtycls

Перевод:

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

inst	$\to$	gtycon
	\|	( gtycon tyvar₁ ... tyvar_k )	( k>=0, все tyvar различны)
	\|	( tyvar₁ , ... , tyvar_k )	( k>=2, все tyvar различны)
	\|	[ tyvar ]
	\|	( tyvar₁ -> tyvar₂ )	( tyvar₁ и tyvar₂ различны)

Перевод:

экземпляр	$\to$	общий-конструктор-типа
	\|	( общий-конструктор-типа переменная-типа₁ ... переменная-типа_k )	( k>=0, все переменные-типа различны)
	\|	( переменная-типа₁ , ... , переменная-типа_k )	( k>=2, все переменные-типа различны)
	\|	[ переменная-типа ]
	\|	( переменная-типа₁ $\to$ переменная-типа₂ )	(переменная-типа₁ и переменная-типа₂ различны)

funlhs	$\to$	var apat {apat }
	\|	patⁱ⁺¹ varop^(a,i) patⁱ⁺¹
	\|	lpatⁱ varop^(l,i) patⁱ⁺¹
	\|	patⁱ⁺¹ varop^(r,i) rpatⁱ
	\|	( funlhs ) apat {apat }
rhs	$\to$	= exp [where decls]
	\|	gdrhs [where decls]
gdrhs	$\to$	gd = exp [gdrhs]
gd	$\to$	\| exp⁰

Перевод:

левая-часть-функции	$\to$	переменная такой-как-образец {такой-как-образец }
	\|	образецⁱ⁺¹ оператор-переменной^(a,i) образецⁱ⁺¹
	\|	левый-образецⁱ оператор-переменной^(l,i) образецⁱ⁺¹
	\|	образецⁱ⁺¹ оператор-переменной^(r,i) правый-образецⁱ
	\|	( левая-часть-функции ) такой-как-образец {такой-как-образец }
правая-часть	$\to$	= выражение [where список-объявлений]
	\|	правая-часть-со-стражами [where список-объявлений]
правая-часть-со-стражами	$\to$	страж = выражение [правая-часть-со-стражами]
страж	$\to$	\| выражение⁰

exp	$\to$	exp⁰ :: [context =>] type	(сигнатура типа выражения)
	\|	exp⁰
expⁱ	$\to$	expⁱ⁺¹ [qop^(n,i) expⁱ⁺¹]
	\|	lexpⁱ
	\|	rexpⁱ
lexpⁱ	$\to$	(lexpⁱ \| expⁱ⁺¹) qop^(l,i) expⁱ⁺¹
lexp⁶	$\to$	- exp⁷
rexpⁱ	$\to$	expⁱ⁺¹ qop^(r,i) (rexpⁱ \| expⁱ⁺¹)
exp¹⁰	$\to$	\ apat₁ ... apat_n -> exp	(лямбда-абстракция, n>=1 )
	\|	let decls in exp	( let -выражение)
	\|	if exp tden exp else exp	(условное выражение)
	\|	case exp of { alts }	( case -выражение)
	\|	do { stmts }	( do -выражение)
	\|	fexp
fexp	$\to$	[fexp] aexp	(применение функции)

Перевод:

выражение	$\to$	выражение⁰ :: [контекст $\Rightarrow$ ] тип	(сигнатура типа выражения)
	\|	выражение⁰
выражениеⁱ	$\to$	выражениеⁱ⁺¹ [квалифицированный-оператор^(n,i) выражениеⁱ⁺¹]
	\|	левое-сечение-выраженияⁱ
	\|	правое-сечение-выраженияⁱ
левое-сечение-выраженияⁱ	$\to$	(левое-сечение-выраженияⁱ \| выражениеⁱ⁺¹) квалифицированный-оператор^(l,i) выражениеⁱ⁺¹
левое-сечение-выражения⁶	$\to$	- выражение⁷
правое-сечение-выраженияⁱ	$\to$	выражениеⁱ⁺¹ квалифицированный-оператор^(r,i) (правое-сечение-выраженияⁱ \| выражениеⁱ⁺¹)
выражение¹⁰	$\to$	\ такой-как-образец₁ ... такой-как-образец_n $\to$ выражение	(лямбда-абстракция, n>=1 )
	\|	let списки-объявлений in выражение	( let -выражение)
	\|	if выражение tden выражение else выражение	(условное выражение)
	\|	case выражение of { список-альтернатив }	( case -выражение)
	\|	do { список-инструкций }	( do -выражение)
	\|	функциональное-выражение
функциональное-выражение	$\to$	[функциональное-выражение] выражение-аргумента	(применение функции)

aexp	$\to$	qvar	(переменная)
	\|	gcon	(общий конструктор)
	\|	literal
	\|	( exp )	(выражение в скобках)
	\|	( exp₁ , ... , exp_k )	(кортеж, k>=2 )
	\|	[ exp₁ , ... , exp_k ]	(список, k>=1 )
	\|	[ exp₁ [, exp₂] .. [exp₃] ]	(арифметическая последовательность)
	\|	[ exp \| qual₁ , ... , qual_n ]	(описание списка, n>=1 )
	\|	( expⁱ⁺¹ qop^(a,i) )	(левое сечение)
	\|	( lexpⁱ qop^(l,i) )	(левое сечение)
	\|	( qop^(a,i)<-> expⁱ⁺¹ )	(правое сечение)
	\|	( qop^(r,i)<-> rexpⁱ )	(правое сечение)
	\|	qcon { fbind₁ , ... , fbind_n }	(именованная конструкция, n>=0 )
	\|	aexp_<qcon> { fbind₁ , ... , fbind_n }	(именованное обновление, n >= 1 )

Перевод:

выражение-аргумента	$\to$	квалифицированная-переменная	(переменная)
	\|	общий-конструктор	(общий конструктор)
	\|	литерал
	\|	( выражение )	(выражение в скобках)
	\|	( выражение₁ , ... , выражение_k )	(кортеж, k>=2 )
	\|	[ выражение₁ , ... , выражение_k ]	(список, k>=1 )
	\|	[ выражение₁ [, выражение₂] .. [выражение₃] ]	(арифметическая последовательность)
	\|	[ выражение \| квалификатор₁ , ... , квалификатор_n ]	(описание списка, n>=1 )
	\|	( выражениеⁱ⁺¹ квалифицированный-оператор^(a,i) )	(левое сечение)
	\|	( левое-сечение-выраженияⁱ квалифицированный-оператор^(l,i) )	(левое сечение)
	\|	( квалифицированный-оператор^(a,i)< $\to$ выражениеⁱ⁺¹ )	(правое сечение)
	\|	( квалифицированный-оператор^(r,i)< $\to$ правое-сечение-выраженияⁱ )	(правое сечение)
	\|	квалифицированный-конструктор { связывание-имени-поля₁ , ... , связывание-имени-поля_n }	(именованная конструкция, n>=0 )
	\|	выражение-аргумента_{<квалифицированный-конструктор>} { связывание-имени-поля₁ , ... , связывание-имени-поля_n }	(именованное обновление, n>=1 )

qual	$\to$	pat <- exp	(генератор)
	\|	let decls	(локальное объявление)
	\|	exp	(страж)
alts	$\to$	alt₁ ; ... ; alt_n	(n>=1)
alt	$\to$	pat -> exp [where decls]
	\|	pat gdpat [where decls]
	\|		(пустая альтернатива)
gdpat	$\to$	gd -> exp [ gdpat ]
stmts	$\to$	stmt₁ ... stmt_n exp [;]	(n>=0)
stmt	$\to$	exp ;
	\|	pat <- exp ;
	\|	let decls ;
	\|	;	(пустая инструкция)
fbind	$\to$	qvar = exp

Перевод:

квалификатор	$\to$	образец $\gets$ выражение	(генератор)
	\|	let списки-объявлений	(локальное объявление)
	\|	выражение	(страж)
список-альтернатив	$\to$	альтернатива₁ ; ... ; альтернатива_n	(n>=1)
альтернатива	$\to$	образец $\to$ выражение [where список-объявлений]
	\|	образец образец-со-стражами [ where список-объявлений]
	\|		(пустая альтернатива)
образец-со-стражами	$\to$	страж $\to$ выражение [ образец-со-стражами ]
список-инструкций	$\to$	инструкция₁ ... инструкция_n выражение [;]	(n>=0)
инструкция	$\to$	выражение ;
	\|	образец $\gets$ выражение ;
	\|	let список-объявлений ;
	\|	;	(пустая инструкция)
связывание-имени-поля	$\to$	квалифицированная-переменная = выражение

Дальше >>