lass
0.6.0Lisp Augmented Style Sheets. Compiles LASS to CSS.
Table of Contents
About LASS
Writing CSS files comes with a lot of repetition and is generally much too verbose. With lispy syntax, shortcuts, and improvements, LASS aims to help you out in writing CSS quick and easy. LASS was largely inspired by SASS.
How To & Examples
LASS supports two modes, one being directly in your lisp code, the other in pure LASS files. Adding LASS into your code is easy:
(lass:compile-and-write
2 | '(div
3 | :background black))
4 |
5 | "div{
6 | background: black;
7 | }"
8 | LASS works on the following simple principles: A list is a block. The first argument in the list is a selector. The body of the list makes up the properties and sub-blocks. A property is started with a keyword that is used as the property name. Following is a bunch of property arguments until a new keyword, list, or the end is reached. A list inside a block is, again, a block with the twist that the parent block's selector is prepended to the sub-block's selector.
(lass:compile-and-write
9 | '(nav
10 | (ul
11 | :list-style none
12 | (li
13 | :margin 0 :padding 0
14 | :display inline-block)))))
15 |
16 | "nav ul{
17 | list-style: none;
18 | }
19 |
20 | nav ul li{
21 | margin: 0;
22 | padding: 0;
23 | display: inline-block;
24 | }"
25 | Since LASS' COMPILE-SHEET simply takes a bunch of lists as its argument, you can use the backquote and comma to integrate variables from your lisp environment:
(let ((color "#0088EE"))
26 | (lass:compile-and-write
27 | `(div
28 | :background ,color))))
29 |
30 | "div{
31 | background: #0088EE;
32 | }"
33 | Alternatively however, and this is especially useful in pure LASS files, you can use the LET block to create LASS-specific bindings:
(lass:compile-and-write
34 | '(:let ((color "#0088EE"))
35 | (div
36 | :background #(color))))
37 |
38 | "div{
39 | background: #0088EE;
40 | }"
41 | You can also let bind entire property blocks:
(lass:compile-and-write 42 | '(:let ((colors :background "#0088EE")) 43 | (div #(colors)) 44 | (:media "(prefers-color-scheme: light)" (div #(colors)))))
"div{
45 | background: #0088EE;
46 | }
47 |
48 | @media (prefers-color-scheme: light){
49 | div{
50 | background: #0088EE;
51 | }
52 | }"
53 | LASS' selector mechanism is very flexible and allows for some complex logic to reduce duplication:
(lass:compile-and-write
54 | '(article
55 | ((:or p blockquote)
56 | :margin 0 :padding 0
57 |
58 | (a
59 | :color black)
60 |
61 | ((:and a :hover)
62 | :color darkred))))
63 |
64 | "article p, article blockquote{
65 | margin: 0;
66 | padding: 0;
67 | }
68 |
69 | article p a, article blockquote a{
70 | color: black;
71 | }
72 |
73 | article p a:hover, article blockquote a:hover{
74 | color: darkred;
75 | }"
76 | But it can go even further:
(lass:compile-and-write
77 | '((:and
78 | (:or article section)
79 | (:= data-author (:or yukari ran chen))
80 | (:nth-child (:or 1 2 3)))
81 | :display none))
82 |
83 | "article[data-author=\"yukari\"]:nth-child(1),
84 | article[data-author=\"yukari\"]:nth-child(2),
85 | article[data-author=\"yukari\"]:nth-child(3),
86 | article[data-author=\"ran\"]:nth-child(1),
87 | article[data-author=\"ran\"]:nth-child(2),
88 | article[data-author=\"ran\"]:nth-child(3),
89 | article[data-author=\"chen\"]:nth-child(1),
90 | article[data-author=\"chen\"]:nth-child(2),
91 | article[data-author=\"chen\"]:nth-child(3),
92 | section[data-author=\"yukari\"]:nth-child(1),
93 | section[data-author=\"yukari\"]:nth-child(2),
94 | section[data-author=\"yukari\"]:nth-child(3),
95 | section[data-author=\"ran\"]:nth-child(1),
96 | section[data-author=\"ran\"]:nth-child(2),
97 | section[data-author=\"ran\"]:nth-child(3),
98 | section[data-author=\"chen\"]:nth-child(1),
99 | section[data-author=\"chen\"]:nth-child(2),
100 | section[data-author=\"chen\"]:nth-child(3){
101 | display: none;
102 | }"
103 | Whoa nelly!
If you ever need to expand a selector into a parent block, for instance to specialise on different classes of the block, you can use the parent pseudo-selector:
(lass:compile-and-write
104 | '((:or article section)
105 | :background black
106 | ((:parent .bright)
107 | :background white)))
108 |
109 | "article,
110 | section{
111 | background: black;
112 | }
113 |
114 | article.bright,
115 | section.bright{
116 | background: white;
117 | }"
118 | Some CSS properties are not fully specified yet and require browser-specific prefixes. LASS can help you with that, too:
(lass:compile-and-write
119 | '(.fun
120 | :linear-gradient "deg(45)" black 0% darkgray 100%
121 | :transform rotate -45deg))
122 |
123 | ".fun{
124 | background: -moz-linear-gradient(deg(45), black 0%, darkgray 100%);
125 | background: -o-linear-gradient(deg(45), black 0%, darkgray 100%);
126 | background: -webkit-linear-gradient(deg(45), black 0%, darkgray 100%);
127 | background: -ms-linear-gradient(deg(45), black 0%, darkgray 100%);
128 | background: linear-gradient(deg(45), black 0%, darkgray 100%);
129 | -moz-transform: rotate(-45deg);
130 | -o-transform: rotate(-45deg);
131 | -webkit-transform: rotate(-45deg);
132 | -ms-transform: rotate(-45deg);
133 | transform: rotate(-45deg);
134 | }"
135 | LASS also supports the various @QUERY operator blocks:
(lass:compile-and-write
136 | '(:media "(max-width: 800px)"
137 | (div
138 | :margin 0)))
139 |
140 | "@media (max-width: 800px){
141 | div{
142 | margin: 0;
143 | }
144 | }"
145 | By default LASS activates pretty-printing and inserts newlines and spaces where appropriate in order to make the result readable and easy to debug. However, you can also deactivate that and directly produce minified CSS:
(let ((lass:*pretty* NIL))
146 | (lass:compile-and-write
147 | '(:media "(max-width: 800px)"
148 | (div
149 | :margin 0))))
150 |
151 | "@media (max-width: 800px){div{margin:0;}}"
152 | As mentioned above you can write pure LASS files to compile down to a CSS file. To do that, simply use GENERATE:
Blocks
Each block in a LASS sheet consists of a list containing a selector followed by one or more properties or sub-blocks.
(selector [property | block]*)
153 | Selectors
The following list contains examples for the various uses of selectors.
- Any element
* - An element with tag-name
e
e - An element with tag-name
eorf
(:or e f) - An
eelement with the:linkpseudo-selector
(:and e :link) - The first formatted line of an
eelement
(:and e |::first-line|)or(:and e "::first-line") - An
eelement with a "warning" class
e.warning - An
eelement with ID equal towarning
|e#warning|or"e#warning" - An
eelement with afooattribute
e[foo] - An
eelement whosefooattribute value is exactly equal tobar
(:and :a (:= foo "bar")) - An
eelement whosefooattribute value is a list of whitespace-separated values, one of which is exactly equal tobar
(:and :a (:~= foo "bar")) - An
eelement whosefooattribute has a hyphen-separated list of values beginning (from the left) withbar
(:and :a (:/= foo "bar")) - An
eelement whosefooattribute value begins exactly with the stringbar
(:and :a (:^= foo "bar")) - An
eelement whosefooattribute value ends exactly with the stringbar
(:and :a (:$= foo "bar")) - An
eelement whosefooattribute value contains the substringbar
(:and :a (:*= foo "bar")) - An
eelement that matches the pseudo-selectornth-child(2)
(e (:nth-child 2)) - An
felement preceded by aneelement
(e ~ f) - An
felement immediately precede by aneelement
(e + f) - An
felement which is a descendant ofe
(e f) - An
felement which is a direct descendant ofe
(e > f)
Selector Combinations
As illustrated briefly above, LASS includes two combinators for selectors, :and and :or. These combinators are combinatoric, meaning that all possible combinations are explored. Consider the following selector:
((foo (:and a .title (:or :active :hover)) (:or span div)))
154 | Enumerating all possible answers to this combination would result in the following list
foo a.title:active span
155 | foo a.title:active div
156 | foo a.title:hover span
157 | foo a.title:hover div
158 | The number of possible combinations can quickly explode in size the more options are available. This means that for complex relations and expressions, LASS can be extremely concise. Note that combinators are available at any position in a selector, this includes the arguments of a pseudo-selector like :nth-child.
Properties
A property consists of a keyword symbol and a sequence of values. The values to a property are gathered up until either a non-value list or a new keyword is encountered. Originally it stopped as soon as a list was encountered, but this behaviour was changed and specially recognised lists are integrated to allow a more native look for certain values like colours, urls, and so on. Certain properties are specifically declared and will error if they are passed the wrong number or invalid kind of values. For most however, LASS will just blindly put things into the CSS file as you give them. It is up to you to make sure that the values are valid.
:text-style underline
159 | :color (rgb 212 112 30)
160 | :background (url "/foo")
161 | :border 1px solid black
162 | Certain properties currently still require vendor-specific declarations. LASS tries to do that automatically for you, but it also needs to know about these declarations and as such, they need to be manually added. Some of the more common ones are included in LASS by default, but if you encounter one that isn't, you are welcome to send a pull request (see Extending LASS on how to do it).
Sub-Blocks
A block can contain other blocks. These sub-blocks are recursively flattened into the structure by simply prepending the selector of the parent block. Thus
(foo (bar (baz) (bam)))
163 | Is equivalent to
(foo) ((foo bar)) ((foo bar baz)) ((foo bar bam))
164 | Allowing this kind of nesting allows you to more closely mirror the structure present in your HTML file that you want to style. Combining this with the selector combinations, this system allows reducing code duplication a lot.
Special Blocks
In CSS3 there are special properties and blocks that are preceded by an @ symbol. The most well-known examples therefore are probably @include and @media. LASS implements all of these special blocks by a keyword symbol equivalent selector. Therefore the above two would translate to the following in LASS.
(:include (url "foo"))
165 | (:media "(max-width: 800px)"
166 | (foo))
167 | Variables
Often times it is useful to define variables that you can use within your style so that colours and fonts can quickly be exchanged. LASS allows you to do that too using the :let directive and by abusing the vector type. It is probably best illustrated using an example:
(:let ((foo "#0088EE"))
168 | ((a:active) :color #(foo)))
169 | Extending LASS
Pretty much every part of LASS is extensible through methods. Most useful will however probably be the DEFINE-SPECIAL-PROPERTY, DEFINE-BROWSER-PROPERTY and DEFINE-SPECIAL-SELECTOR helper-macros. Here's some examples from the SPECIAL.LISP file that defines some standard special handlers:
(define-special-property font-family (&rest faces)
170 | (list (make-property "font-family" (format NIL "~{~a~^, ~}" (mapcar #'resolve faces)))))
171 |
172 | (define-browser-property linear-gradient (direction &rest colors)
173 | (:default (property)
174 | (make-property "background" (format NIL "~a(~a~{, ~a ~a~})"
175 | property (resolve direction) (mapcar #'resolve colors)))))
176 | For more control, have a look at the various COMPILE-* generic functions.
Emacs Support
LASS includes a tiny elisp file, lass.el. Add LASS' directory to your emacs LOAD-PATH and REQUIRE lass.
(add-to-list 'load-path "[path-to-lass-source-dir]/")
177 | (require 'lass)
178 | Once you visit a .lass file, it will automatically start in the LASS major-mode, which is a derived-mode from COMMON-LISP-MODE. Whenever you save, it will automatically try to compile the lass file to its CSS equivalent. If slime is connected, it will try to quickload LASS and evaluate GENERATE. If slime is not connected, it instead executes a shell command. In order for that to work, the lass binary must be in your path.
If your operating system is not directly supported with a binary, you can build it yourself using a build tool like Buildapp, the ASDF system BINARY-LASS and the entry-point BINARY-LASS:CMD-WRAPPER.
To generate pretty .lass files, set lass-generate-pretty-p to t.
ASDF Integration
If you want to compile LASS files to CSS in your systems, you can now (v0.4+) do this via a lass-file component type, and :defsystem-depends-on-ing LASS.
(asdf:defsystem my-system
179 | :defsystem-depends-on (:lass)
180 | :components ((:lass-file "test-file")))
181 | You can also specify an :output argument to a lass-file to specify what the target css file should be.
Support
If you'd like to support the continued development of LASS, please consider becoming a backer on Patreon:
System Information
Definition Index
-
LASS
- ORG.TYMOONNEXT.LASS
No documentation provided.-
EXTERNAL SPECIAL-VARIABLE *INDENT-LEVEL*
Directs the current amount of spaces used to indent.
-
EXTERNAL SPECIAL-VARIABLE *INDENT-SPACES*
Specifies the number of spaces to use for indentation.
-
EXTERNAL SPECIAL-VARIABLE *PRETTY*
Directs whether to pretty-print using whitespace or not.
-
EXTERNAL SPECIAL-VARIABLE *VARS*
Special variable containing LASS-environment variables. 182 | 183 | See the definition of the LET block.
-
EXTERNAL CLASS LASS-FILE
An ASDF source-file component to allow compilation of LASS to CSS in ASDF systems.
-
EXTERNAL FUNCTION COMPILE-AND-WRITE
- &REST
- FORMS
- &REST
Shortcut for (WRITE-SHEET (COMPILE-SHEET FORMS*))
-
EXTERNAL FUNCTION COMPILE-SHEET
- &REST
- BLOCKS
- &REST
Compiles a LASS sheet composed of BLOCKS. 184 | Each BLOCK is passed to COMPILE-BLOCK. The results thereof are appended 185 | together into one list of blocks and properties.
-
EXTERNAL FUNCTION GENERATE
- IN
- &KEY
- OUT
- PRETTY
- IF-EXISTS
- &REST
Generate a CSS file from a LASS file. 186 | 187 | IN --- The LASS input file. Has to be READable. 188 | OUT --- The target file, by default a file of same location and name, but with CSS type. 189 | PRETTY --- Whether to minify or not. See WRITE-SHEET. 190 | IF-EXISTS --- See WITH-OPEN-FILE 191 | 192 | Returns OUT
-
EXTERNAL FUNCTION INDENT
Returns a string of the appropriate number of spaces depending on *PRETTY* and *INDENT-LEVEL*
-
EXTERNAL FUNCTION MAKE-BLOCK
- SELECTOR
- VALUES
- &REST
Creates a block object with SELECTOR and VALUES.
-
EXTERNAL FUNCTION MAKE-PROPERTY
- PROPERTY
- &OPTIONAL
- VALUE
- &REST
Creates a property object with PROPERTY as its key and VALUE as its value.
-
EXTERNAL FUNCTION PROPERTY-FUNCTION
- NAME
- &REST
Returns a function to process a property function of NAME, if any.
-
EXTERNAL FUNCTION (SETF PROPERTY-FUNCTION)
- FUNCTION
- NAME
- &REST
Sets FUNCTION as the new processor for the property function NAME.
-
EXTERNAL FUNCTION REMOVE-PROPERTY-FUNCTION
- NAME
- &REST
Removes the property function NAME.
-
EXTERNAL FUNCTION RESOLVE-FUNCTION
- FUNCTION
- &REST
- ARGS
- &REST
Turns the FUNCTION with its ARGS into a properly usable property value.
-
EXTERNAL FUNCTION WRITE-SHEET
- SHEET
- &KEY
- STREAM
- PRETTY
- &REST
Writes the compiled SHEET object to STREAM. 193 | If PRETTY is non-NIL, spaces and newlines are inserted as appropriate 194 | in order to create a human-readable stylesheet. Otherwise whitespace is 195 | only used where necessary, producing a minified version. 196 | 197 | STREAM can be a STREAM, T for *STANDARD-OUTPUT*, or NIL for a STRING.
-
EXTERNAL FUNCTION WRITE-SHEET-PART
- STREAM
- BLOCK
- CP
- AP
- &REST
Wrapper around WRITE-SHEET-OBJECT so that we can call it from FORMAT. 198 | Calls WRITE-SHEET-OBJECT with (CAR BLOCK) (CDR BLOCK) STREAM.
-
EXTERNAL GENERIC-FUNCTION COMPILE-BLOCK
- HEADER
- FIELDS
- &REST
Compiles the block with given HEADER and FIELDS list. 199 | By default, the following case is handled: 200 | 201 | (T T) 202 | Blocks are handled in the following way: 203 | The HEADER is used as a selector and compiled through COMPILE-SELECTOR. 204 | Fields are semantically segregated through KEYWORDS and LISTS. 205 | 206 | Every time a KEYWORD is encountered, it is taken as the current property 207 | and all following objects until either a LIST or a KEYWORD is encountered 208 | are gathered as the property's values. 209 | 210 | Every time a LIST is encountered, it is taken as a SUB-BLOCK and is 211 | passed to COMPILE-BLOCK with the HEADER being the current block's 212 | selector prepended to the selector of the sub-block. 213 | 214 | 215 | Special handling of blocks may occur. 216 | See DEFINE-SPECIAL-BLOCK.
-
EXTERNAL GENERIC-FUNCTION COMPILE-CONSTRAINT
- FUNC
- ARGS
- &REST
Compiles a constraint of type FUNC with arguments ARGS to a list of alternative selectors. 217 | By default, the following cases are handled: 218 | 219 | (T T) 220 | Concatenates its ARGS together with spaces. 221 | Preserves OR combinations. 222 | 223 | (NULL NULL) 224 | Returns NIL 225 | 226 | (T NULL) 227 | Returns FUNC 228 | 229 | (:OR T) 230 | Passes all ARGS to COMPILE-SELECTOR individually and then APPENDS 231 | all the results together. 232 | 233 | (:AND T) 234 | Concatenates its ARGS together without spaces. 235 | Preserves OR combinations. 236 | 237 | 238 | Special handling of constraints may occur. 239 | See DEFINE-SPECIAL-SELECTOR.
-
EXTERNAL GENERIC-FUNCTION COMPILE-PROPERTY
- KEY
- VALUE
- &REST
Compile a property of KEY and VALUE to a list of property objects. 240 | By default, the following cases are handled: 241 | 242 | (T LIST) 243 | A list is created with one property object, wherein the property-value is the 244 | Space-concatenated list of RESOLVEd VALUEs. The KEY is DOWNCASEd. 245 | 246 | (T T) 247 | A list is created with one property object, wherein the property-value is the 248 | RESOLVEd VALUE. The KEY is DOWNCASEd. 249 | 250 | 251 | Special handling of properties may occur. 252 | See DEFINE-SPECIAL-PROPERTY
-
EXTERNAL GENERIC-FUNCTION COMPILE-SELECTOR
- SELECTOR
- &REST
Compiles the SELECTOR form into a list of alternative selectors. 253 | By default, the following cases are handled: 254 | 255 | (NULL) 256 | Returns NIL. 257 | 258 | (LIST) 259 | Calls COMPILE-CONSTRAINT with the SELECTOR's CAR and CDR. 260 | 261 | (T) 262 | Returns a list with the RESOLVEd SELECTOR.
-
EXTERNAL GENERIC-FUNCTION CONSUME-ITEM
- ITEM
- READABLE-LIST
- &REST
Consumes items from READABLE-LIST as required by the ITEM. 263 | Returned should be two values, the first being a property to compile (or NIL) 264 | and the second a block to compile (or NIL). 265 | By default, the following cases are handled: 266 | 267 | (LIST) 268 | Simply returns the ITEM as a block. 269 | 270 | (SYMBOL) 271 | If it's a keyword, reads until the next keyword or list and returns that as a 272 | property to compile. With property-functions, some sublists may also be read 273 | in automatically. See DEFINE-PROPERTY-FUNCTION. If it is a regular symbol, 274 | CALL-NEXT-METHOD is invoked. 275 | 276 | (T) 277 | Signals an error.
-
EXTERNAL GENERIC-FUNCTION RESOLVE
- THING
- &REST
Resolves THING to a value that makes sense for LASS. 278 | 279 | By default the following types are handled: 280 | NULL: NIL 281 | STRING: the THING itself 282 | ARRAY: the variable stored in *VARS* under THING 283 | KEYWORD: Colon-prefixed, downcased symbol-name of THING 284 | SYMBOL: Downcased symbol-name of THING 285 | PATHNAME: If designating an image, base64 encoded inline image data. 286 | T: PRINC-TO-STRING of THING
-
EXTERNAL GENERIC-FUNCTION WRITE-SHEET-OBJECT
- TYPE
- OBJECT
- STREAM
- &REST
Writes the OBJECT of type TYPE to STREAM. 287 | 288 | By default the following TYPEs are handled: 289 | :BLOCK (SELECTOR-LIST OBJECTS*) 290 | Prints the SELECTOR-LIST separated by commas, followed by an opening brace 291 | and the printed list of OBJECTS using WRITE-SHEET-PART. Finally the body is 292 | closed off with a closing brace. Newlines and spaces may be inserted where 293 | necessary if *PRETTY* is non-NIL. 294 | 295 | :PROPERTY (KEY VALUE) 296 | Prints the KEY. If VALUE is non-NIL, a colon is printed followed by the 297 | VALUE. Finally a semicolon is printed. Spaces may be inserted where necessary 298 | if *PRETTY* is non-NIL.
-
EXTERNAL MACRO DEFINE-BROWSER-PROPERTY
- NAME
- ARGS
- &BODY
- BROWSER-OPTIONS
- &REST
Helper macro to define properties that have browser-dependant versions. 299 | 300 | NAME --- The base name of the property name or value. 301 | ARGS --- Property arguments, see DEFINE-SPECIAL-PROPERTY. 302 | BROWSER-OPTIONS ::= (OPTION (symbol) FORM*) 303 | OPTION ::= :MOZ | :O | :WEBKIT | :MS | :W3C | :DEFAULT 304 | 305 | Each browser-option body should return a single property. The SYMBOL 306 | in the option definition is bound to the computed property name 307 | (eg -moz-NAME for the :MOZ option). 308 | You can define special handling of the browsers by defining options 309 | specifically for them. If no handling is defined, the DEFAULT option 310 | is used as a fallback.
-
EXTERNAL MACRO DEFINE-PRIMITIVE-PROPERTY-CONSUMER
- SPECIALIZER
- PROPVALS
- READABLE
- NEXT
- &REST
- &BODY
- LOOP-BODY
- &REST
Defines a CONSUME-ITEM method for the given item SPECIALIZER. 311 | 312 | SPECIALIZER --- The method specializer for the item. 313 | PROPVALS --- The list that should contain the property values. 314 | READABLE --- The readable-list being operated on currently. 315 | NEXT --- Bound to the next (unconsumed) item in the readable-list. 316 | LOOP-BODY --- The body of the reading loop to execute until the readable is empty. 317 | 318 | The return value of the loop-body is discarded. You can use (RETURN) to exit the loop, 319 | for example for when you encounter an item you don't want to read.
-
EXTERNAL MACRO DEFINE-PROPERTY-FUNCTION
- NAME
- ARGS
- &BODY
- BODY
- &REST
Define a new property function NAME, accepting ARGS. 320 | The body should return a value to use directly, if possible a string. 321 | The results of a property-function should not be RESOVLEd. 322 | 323 | Property functions are function calls that occur as (part of) the 324 | value of a property. Due to ambiguity issues with a general sub-block, 325 | property functions need to be explicitly defined and may completely 326 | differ depending on the property. Property functions defined with this 327 | are only the defaults available for all properties. If you want to 328 | minimise collision probability or avoid an illegal function for a 329 | certain property, you should define a direct method on CONSUME-ITEM 330 | to handle the reading of the property values manually.
-
EXTERNAL MACRO DEFINE-PROPERTY-FUNCTION-CASE
- PROPERTY
- ARGS
- &REST
- &BODY
- FUNCTION-CLAUSES
- &REST
Defines a CONSUME-ITEM method for PROPERTY that has special handling for property-functions. 331 | 332 | FUNCTION-CLAUSES ::= function-clause* 333 | FUNCTION-CLAUSE ::= (function-name form*) 334 | 335 | Each function-name is compared by STRING-EQUAL and each clause should return the 336 | property-value to use in its place, or NIL if it should be skipped. 337 | 338 | You can use (RETURN) in a clause body to stop reading values altogether.
-
EXTERNAL MACRO DEFINE-SIMPLE-PROPERTY-FUNCTION
- NAME
- ARGS
- &REST
Defines a property function that returns name(arg1,arg2...). 339 | Only required arguments are allowed.
-
EXTERNAL MACRO DEFINE-SIMPLE-PROPERTY-FUNCTIONS
- PROPERTY
- &REST
- FUNCSPECS
- &REST
Defines a CONSUME-ITEM method for PROPERTY that has special handling for property-functions. 340 | 341 | FUNCSPECS ::= funcspec* 342 | FUNCSPEC ::= (funcname arg* [&optional arg*] [&key arg*]) 343 | 344 | See DEFINE-PROPERTY-FUNCTION-CASE.
-
EXTERNAL MACRO DEFINE-SINGLE-ARG-SELECTOR
- NAME
- &REST
Helper macro to define a single-argument pseudo-selector like NOT or NTH-CHILD.
-
EXTERNAL MACRO DEFINE-SPECIAL-BLOCK
- NAME
- ARGS
- &BODY
- BODY
- &REST
Define handling of a special block type. 345 | In order for the block to be recognised, it has to begin with the NAME as a keyword. 346 | The ARGS is a lambda-list that parses the block contents. 347 | 348 | Expected as a return value is a /list/ of either attributes or blocks. 349 | 350 | See COMPILE-BLOCK
-
EXTERNAL MACRO DEFINE-SPECIAL-PROPERTY
- NAME
- ARGS
- &BODY
- BODY
- &REST
Define handling of a special property. 351 | The ARGS is a lambda-list that parses the arguments passed to the property. 352 | 353 | Expected as a return value is a /list/ of either attributes or blocks. 354 | 355 | See COMPILE-PROPERTY
-
EXTERNAL MACRO DEFINE-SPECIAL-SELECTOR
- NAME
- ARGS
- &BODY
- BODY
- &REST
Define handling of a special selector type. 356 | In order for the selector to be recognised, it has to begin with the NAME as a keyword. 357 | The ARGS is a lambda-list that parses the selector contents. 358 | 359 | Expected as a return value is a /list/ of alternate versions of selectors. 360 | 361 | See COMPILE-CONSTRAINT.