This is an annotated EBNF grammar of the latest rewrite of Kitten. Items marked with a dagger (†) are explained in the surrounding prose, not in EBNF.
The source column of a token is the offset to its first character within the line in which it appears. The indentation of a line is the source column of the first token in the line. Tab characters are illegal.
| {-# Language | |
| BlockArguments, | |
| DataKinds, | |
| DerivingStrategies, | |
| GADTs, | |
| InstanceSigs, | |
| LambdaCase, | |
| PatternSynonyms, | |
| PolyKinds, | |
| RankNTypes, |
An expression beginning with a left arrow (<-) inside a do block statement is desugared to a monadic binding. This is syntactically a superset of existing Haskell, including extensions. It admits a clean notation that subsumes existing patterns and comes with few downsides.
do
f (<- x) (<- y)
-- ===
| #include <iostream> | |
| #include <numeric> | |
| #include <vector> | |
| using namespace std; | |
| // In Haskell, the Monoid typeclass is parameterised by only a type. Such a | |
| // definition requires “newtype hacks” to produce different monoids on the same | |
| // type. This definition is parameterised by both the type and the function, and | |
| // as such can be used to define different monoids on the same type without any | |
| // interference. |
| {-# LANGUAGE GADTs #-} | |
| {-# LANGUAGE DataKinds #-} | |
| {-# LANGUAGE TypeFamilies #-} | |
| {-# LANGUAGE RankNTypes #-} | |
| {-# LANGUAGE PolyKinds #-} | |
| module STLC where | |
| -- Defining type and the corresponding singletons |
| {-# LANGUAGE DataKinds #-} | |
| {-# LANGUAGE FlexibleContexts #-} | |
| {-# LANGUAGE GADTs #-} | |
| {-# LANGUAGE KindSignatures #-} | |
| {-# LANGUAGE LambdaCase #-} | |
| {-# LANGUAGE OverloadedStrings #-} | |
| {-# LANGUAGE RankNTypes #-} | |
| {-# LANGUAGE ScopedTypeVariables #-} | |
| {-# LANGUAGE TypeFamilies #-} | |
| {-# LANGUAGE TypeOperators #-} |
| {-# LANGUAGE BlockArguments #-} | |
| {-# LANGUAGE GADTs #-} | |
| {-# LANGUAGE RankNTypes #-} | |
| import Data.Function (fix) | |
| import Data.IORef | |
| -- INPUT: void M(ICounter) | |
| -- Usage: m intCounter | |
| m :: ICounter -> IO () |
| rzipWith :: (a -> b -> c) -> [a] -> [b] -> [c] | |
| rzipWith f xs0 ys0 = loop 0 0 xs0 ys0 | |
| where | |
| loop x y = curry \ case | |
| (_:xs, _:ys) -> loop (succ x) (succ y) xs ys | |
| (xs, []) -> done (x + length xs) y | |
| ([], ys) -> done x (y + length ys) |
| -_ | |
| trait debug<T> (T -> debug::Repr); | |
| about debug<T>: | |
| kitten::docs: | |
| """ | |
| Produce a debugging representation (`debug::Repr`) of a value. | |
| For uninspectable types such as functions, use `debug::opaque`. |
This is a list of notations and semantics I’ve wanted to use or have used in toy programming languages that I think are particularly nice but rare, and that I’d like to see in more languages. If you’re a PL dev and you fall in love with one, adopt it and let me know!
Most languages use the standard relational operators for comparisons (>, <, ≥/>=, ≤/<=/=<, =/==/===, ≠/!=//=/<>), but these are almost always presented as binary operators for comparing two values. Some languages (of which Python is the most notable) include “chained” comparisons like a <= b < c, meaning a <= b and b < c (but with b only evaluated for its side effects once, that is, (lambda x: a <= x and x < c)(b)). Some languages also allow unary versions of these operators, but they rarely denote anything related to comparisons. Some languages such as Haskell allow arguments to be omitted from operators via operator sections, denot