Skip to content

GitLab

cloogle.org
cloogle.org
Verified Commit 9b9d2dd5 authored by Camil Staps's avatar Camil Staps 🚀
Browse files
Options

Some more SyntaxEntries

parent a4bfd012
Hide whitespace changes
Inline Side-by-side
Showing with 196 additions and 18 deletions
backend/BuiltinSyntax.icl
View file @ 9b9d2dd5
implementation module BuiltinSyntax
import StdBool
import StdEnum
import StdInt
import StdList
import StdOverloaded
import StdString
......@@ -12,18 +15,32 @@ import CloogleDB
builtin_syntax :: [([String], SyntaxEntry)]
builtin_syntax =
bs_arrays ++
[ bs_case
, bs_define_constant
, bs_define_graph
, bs_dotdot
, bs_exists
, bs_forall
, bs_import
, bs_infix
, bs_let
, bs_let_before
, bs_module
] ++ bs_lists ++
[ bs_module
, bs_otherwise
// TODO bs_selection (arrays and records)
, bs_strict
, bs_synonym
, bs_synonym_abstract
] ++ bs_tuples ++
[ bs_update_array
, bs_update_record
, bs_where_class
, bs_where_instance
, bs_where_local
, bs_with
// TODO bs_zf
]
CLR :: Int String String -> SyntaxDocLocation
......@@ -40,6 +57,23 @@ EX t c = {example=c, cleanjs_type=t, cleanjs_start=Nothing}
EXs :: String String String -> SyntaxExample
EXs t s c = {example=c, cleanjs_type=t, cleanjs_start=Just s}
bs_arrays = [make_array kind \\ kind <- [[], ['!'], ['#']]]
where
make_array :: [Char] -> ([SyntaxPattern], SyntaxEntry)
make_array k = (["array", typec, toString (['{':k]++['\\w}'])],
{ syntax_title = kind + "array"
, syntax_code = [typec]
, syntax_description = "An array contains a finite number of elements of the same type. Access time is constant."
, syntax_doc_location = [CLR 6 "4.4" "_Toc311798029"]
, syntax_examples = [EX "Function" ("xs :: {" <+ k <+ "Int}\nxs = {" <+ k <+ "1,3,6,10}")]
})
where
typec = toString (['{':k]++['}'])
kind = case k of
[] -> ""
['!'] -> "strict "
['#'] -> "unboxed "
bs_case = (["case", "of", "case of"],
{ syntax_title = "case expression"
, syntax_code = ["case ... of ..."]
......@@ -50,28 +84,88 @@ bs_case = (["case", "of", "case of"],
]
})
bs_define_constant = (["=:"],
{ syntax_title = "graph definition"
, syntax_code = ["... =: ..."]
, syntax_description =
"Defining constants with `=:` at the top level makes sure they are shared through out the program; hence, they are evaluated only once.\n" +
"This is the default understanding of `=` in local scope.\n" +
"The inverse is {{`=>`}}, which defines an identifier to be a constant function."
, syntax_doc_location = [CLR 5 "3.6" "_Toc311798007"]
, syntax_examples = [EXs "Function" "macro" "mylist =: [1..10000]"]
})
bs_define_graph = (["=>"],
{ syntax_title = "constant function definition"
, syntax_code = ["... => ..."]
, syntax_description =
"Defining constants with `=>` at the top level makes sure they are interpreted as constant functions; hence, they are evaluated every time they are needed.\n" +
"This is the default understanding of `=` in global scope.\n" +
"The inverse is {{`=:`}}, which defines an identifier to be a graph."
, syntax_doc_location = [CLR 5 "3.6" "_Toc311798007"]
, syntax_examples = [EXs "Function" "macro" "mylist => [1..10000]"]
})
bs_dotdot = (["[\\e..]", "[\\e..\e]", "[\\e,\\e..]", "[[\\e,\\e..\\e]", "dotdot", "dot-dot"],
{ syntax_title = "dotdot expression"
, syntax_code = ["[i..]", "[i..k]", "[i,j..]", "[i,j..k]"]
, syntax_description =
"A shorthand for lists of enumerable types.\n" +
"To use these expressions, you must import {{`StdEnum`}}. The underlying functions are defined in {{`_SystemEnum`}}."
, syntax_doc_location = [CLR 6 "4.2.1" "_Toc311798023"]
, syntax_examples = map (EXs "Function" "macro")
[ "xs = [0..] // 0, 1, 2, 3, ..."
, "xs = [0,2..] // 0, 2, 4, 6, ..."
, "xs = [0..10] // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10"
, "xs = [0,2..10] // 0, 2, 4, 6, 8, 10"
]
})
bs_exists = (["E", "E.*"],
{ syntax_title = "existential quantifier"
, syntax_code = [":: ... = E. ...: ..."]
, syntax_description = "Existential quantifiers make it possible to define (recursive) objects of the same type with different types of content."
, syntax_doc_location = [CLR 7 "5.1.3" "_Toc311798042"]
, syntax_examples = [EX "Function" ":: List = E.e: Cons e List | Nil\nStart = Cons 5 (Cons 'a' (Cons \"abc\" Nil))"] // TODO highlighting
})
bs_forall = (["A", "A.*"],
{ syntax_title = "universal quantifier"
, syntax_code = ["A. ...:"]
, syntax_description = "Explicitly marks polymorphic type variables. Clean does not yet allow universal quantifiers on the topmost level."
, syntax_doc_location = [CLR 5 "3.7.4" "_Toc311798013"]
, syntax_examples = map (EX "Function")
[ "hd :: A.a: [a] -> a // Not yet allowed: A. on the topmost level"
, "h :: (A.a: [a] -> Int) -> Int // The quantifier is needed to apply the function to both a [Int] and a [Char]\nh f = f [1..100] + f ['a'..'z']"
]
})
bs_import = (["import", "from", "qualified", "as"],
{ syntax_title = "imports"
, syntax_code = ["import [qualified] ... [as ...]", "from ... import ..."]
, syntax_description = "Imports code from other modules. With the `from` keyword, one can achieve more granularity. In case of name clashes, `qualified` can be used (undocumented)."
, syntax_description =
"Imports code from other modules.\n" +
"With the `from` keyword, one can achieve more granularity.\n" +
"In case of name clashes, `qualified` can be used (undocumented)."
, syntax_doc_location = [CLR 4 "2.5" "_Toc311797991"]
, syntax_examples =
[ EX "Function" "import ..."
, EX "Function" "import StdEnv // Import all code from the StdEnv definition module"
, EX "Function" "from StdFunc import o // Import only the o function from StdFunc"
, EX "Function" "import qualified Data.Map as M // Import Data.Map such that functions are available as e.g. 'M'.get."
, syntax_examples = map (EX "Function")
[ "import ..."
, "import StdEnv // Import all code from the StdEnv definition module"
, "from StdFunc import o // Import only the o function from StdFunc"
, "import qualified Data.Map as M // Import Data.Map such that functions are available as e.g. 'M'.get."
]
})
bs_infix = (["infix", "infixl", "infixr"],
{ syntax_title = "infix operator"
, syntax_code = ["infix[l,r]"]
, syntax_description = "Defines a function with arity 2 that can be used in infix position. `n` determines the precedence. `infixl` and `infixr` indicate associativity."
, syntax_code = ["infix[l,r] [...]"]
, syntax_description =
"Defines a function with arity 2 that can be used in infix position.\n" +
"The following number, if any, determines the precedence.\n" +
"`infixl` and `infixr` indicate associativity."
, syntax_doc_location = [CLR 5 "3.7.2" "_Toc311798011"]
, syntax_examples =
[ EX "Function" "(...) infix n :: ..."
, EX "Function" "(bitor) infixl 6 :: !Int !Int -> Int // Left-associative infix function with precedence 6"
, EXs "Function" "macro" "(o) infixr 9 // Infix macro\n(o) f g :== \x -> f (g x)"
[ EX "Function" "(bitor) infixl 6 :: !Int !Int -> Int // Left-associative infix function with precedence 6"
, EXs "Function" "macro" "(o) infixr 9 // Infix macro\n(o) f g :== \\x -> f (g x)"
, EX "TypeDef" ":: MyType = (:+:) infixl 6 Int Int // Infix data constructor, can be used as (5 :+: 10)"
]
})
......@@ -89,13 +183,47 @@ bs_let = (["let", "in", "let in"],
bs_let_before = (["#", "#!"],
{ syntax_title = "let before"
, syntax_code = ["# ... = ...", "#! ... = ..."]
, syntax_description = "A let expression that can be defined before a guard or function body, which eases the syntax of sequential actions."
, syntax_description = "A {{`let`}} expression that can be defined before a guard or function body, which eases the syntax of sequential actions."
, syntax_doc_location = [CLR 5 "3.5.4" "_Toc311798006"]
, syntax_examples =
[ EX "Function" "readchars :: *File -> *([Char], *File)\nreadchars f\n# (ok,c,f) = freadc file\n| not ok = ([], f)\n# (cs,f) = readchars f\n= ([c:cs], f)"
]
})
bs_lists = [make_list kind spine \\ kind <- [[], ['#'], ['!'], ['|']], spine <- [[], ['!']] | kind <> ['|'] || spine <> ['!']]
where
make_list :: [Char] [Char] -> ([SyntaxPattern], SyntaxEntry)
make_list k s = ([higherorder, listany, "list"],
{ syntax_title = "lists"
, syntax_code = [higherorder]
, syntax_description = "A" + kind + spine + " list.\n\n" + description
, syntax_doc_location = [CLR 6 "4.2" "_Toc311798019"]
, syntax_examples = map (EXs "Function" "macro") ["f :: " <+ lista <+ " -> a", "ints = " <+ listints]
})
where
higherorder = toString (['[':k] ++ s` ++ [']'])
with s` = if (s == ['!'] && k == []) [' !'] s
lista = toString (['[':k] ++ ['a':s] ++ [']'])
listints = toString (['[':k] ++ ['1,1,2,3,5':s] ++ [']'])
listany = toString (['[':k] ++ ['\\','w':s] ++ [']'])
kind = case k of
[] -> " normal"
['#'] -> "n unboxed"
['!'] -> " head strict"
['|'] -> "n overloaded"
spine = case s of
[] -> ""
['!'] -> " spine strict"
description = "These types of list are available:\n" +
"- {{`[a]`}}, a normal list\n" +
"- {{`[#a]`}}, an unboxed head-strict list (elements are stored directly, without pointers)\n" +
"- {{`[!a]`}}, a head-strict list (the first element is in root normal form)\n" +
"- {{`[a!]`}}, a spine-strict list (the last element is known)\n" +
"- {{`[#a!]`}}, an unboxed spine-strict list\n" +
"- {{`[!a!]`}}, a head-strict spine-strict list\n" +
"- {{`[|a]`}}, an overloaded list (one of the types above)"
bs_module = (["module", "definition", "implementation", "system", "definition module", "implementation module", "system module"],
{ syntax_title = "module heading"
, syntax_code = ["[definition,implementation,system] module ..."]
......@@ -129,24 +257,74 @@ bs_strict = (["strict", "!"],
, syntax_examples = [EX "Function" "acker :: !Int !Int -> Int"]
})
bs_synonym = (["synonym", ":=="],
{ syntax_title = "synonym type definition"
, syntax_code = [":: ... :== ..."]
, syntax_description = "Defines a new type name for an existing type."
, syntax_doc_location = [CLR 7 "5.3" "_Toc311798052"]
, syntax_examples = [EX "TypeDef" ":: String :== {#Char}"]
})
bs_synonym_abstract = (["synonym", ":=="],
{ syntax_title = "abstract synonym type definition"
, syntax_code = [":: ... (:== ...)"]
, syntax_description = "Defines a new type name for an existing type, while the type behaves as an abstract type for the programmer. This allows compiler optimisations on abstract types."
, syntax_doc_location = [CLR 7 "5.4.1" "_Toc311798054"]
, syntax_examples = [EX "TypeDef" ":: Stack a (:== [a])"]
})
bs_tuples = [make_tuple n \\ n <- [1..31]]
where
make_tuple :: Int -> ([SyntaxPattern], SyntaxEntry)
make_tuple n = ([toString ['(':repeatn n ','++[')']], withargs, "tuple"],
{ syntax_title = ary + "ary tuple"
, syntax_code = [withvars]
, syntax_description =
"Tuples allow bundling a finite number of expressions of different types into one object without defining a new data type.\n" +
"Clean supports tuples of arity 2 to 32."
, syntax_doc_location = [CLR 6 "4.3" "_Toc311798026"]
, syntax_examples = []
})
where
withargs = toString ['(\\w':foldl (++) [] [[',\\w'] \\ _ <- [1..n]] ++ [')']]
withvars = toString ['(a' :foldl (++) [] [[',':v] \\ _ <- [1..n] & v <- map (\x->[x]) ['b'..'z'] ++ [[v,'`'] \\ v <- ['a'..]]] ++ [')']]
ary = case n of
1 -> "bin"
2 -> "tren"
n -> n+1 <+ "-"
bs_update_array = (["&", "{*&*[\\e]*=*}"],
{ syntax_title = "array update"
, syntax_code = ["{ a & [i]=x, [j]=y, ... } // Updates a by setting index i to x, j to y, ..."]
, syntax_description = "Updates an array by creating a copy and replacing one or more elements"
, syntax_doc_location = [CLR 6 "4.4.1" "_Toc311798032"]
, syntax_examples = []
})
bs_update_record = (["&", "{*&*=*}"],
{ syntax_title = "record update"
, syntax_code = ["{ r & f1=x, f2=y, ... } // Updates r by setting f1 to x, f2 to y, ..."]
, syntax_description = "Updates a record by creating a copy and replacing one or more fields"
, syntax_doc_location = [CLR 7 "5.2.1" "_Toc311798049"]
, syntax_examples = []
})
bs_where_class = (["where"],
{ syntax_title = "where"
, syntax_code = ["where"]
, syntax_description = "Introduces the members of a class definition."
, syntax_description = "Introduces the members of a {{`class`}} definition."
, syntax_doc_location = [CLR 8 "6.1" "_Toc311798056"]
, syntax_examples = [EX "ClassDef" "class Arith a // Class definition\nwhere\n\t(+) infixl 6 :: a a -> a\n\t(-) infixl 6 :: a a -> a"] // TODO highlighting
})
bs_where_instance = (["where"],
{ syntax_title = "where"
, syntax_code = ["where"]
, syntax_description = "Introduces the implementation of an instance."
, syntax_description = "Introduces the implementation of an {{`instance`}}."
, syntax_doc_location = [CLR 8 "6.1" "_Toc311798056"]
, syntax_examples = [EX "Function" "instance Arith Int // Instance definition\nwhere\n\t(+) x y = // ...\n\t(-) x y = // ..."]
})
bs_where_local = (["where"],
{ syntax_title = "where"
, syntax_code = ["where"]
, syntax_description = "Introduces local definitions."
, syntax_description = "Introduces local definitions. For guard-local definitions, see {{`with`}}."
, syntax_doc_location = [CLR 5 "3.5.2" "_Toc311798004"]
, syntax_examples = [EXs "Function" "macro" "primes = sieve [2..] // Local definitions\nwhere\n\tsieve [pr:r] = [pr:sieve (filter pr r)]"]
})
......@@ -154,7 +332,7 @@ bs_where_local = (["where"],
bs_with = (["with"],
{ syntax_title = "with"
, syntax_code = ["with"]
, syntax_description = "Introduces guard-local definitions."
, syntax_description = "Introduces guard-local definitions. For function-local definitions, see {{`where`}}."
, syntax_doc_location = [CLR 5 "3.5.3" "_Toc311798005"]
, syntax_examples = [EXs "Function" "macro" "f x y\n| guard1 = alt1\n\twith local = expr1\n| guard2 = alt2\n\twith local = expr2"]
})
Cloogle @ f754dbf8
Compare 133d7157...f754dbf8
Subproject commit 133d71574c9a1671e4a307751c9cec670219892b
Subproject commit f754dbf8c7ff1b56957bb1094ba49f3441e33a84
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment