All Classes Interface Summary Class Summary
| Class |
Description |
| AndExpression |
Logical and: (and expr1 expr2 ...)
|
| AndExpression.Builder |
|
| Application |
Function application: (function arg1 arg2 ...)
|
| Application.Builder |
|
| BeginExpression |
An explicit begin block (distinct from do for Scheme compatibility)
|
| BeginExpression.Builder |
|
| BooleanStyle |
The style of boolean literals in a dialect
|
| BooleanStyle.HashTF |
|
| BooleanStyle.PartialVisitor<R> |
|
| BooleanStyle.TNil |
|
| BooleanStyle.TrueFalse |
|
| BooleanStyle.Visitor<R> |
|
| CaseClause |
A clause in a case expression
|
| CaseClause.Builder |
|
| CaseExpression |
Case dispatch on a value.
|
| CaseExpression.Builder |
|
| CharacterLiteral |
A character literal.
|
| CharacterLiteral.Builder |
|
| Coder |
Lisp code generator: converts Hydra type and term modules to Lisp AST
|
| Comment |
A comment
|
| Comment.Builder |
|
| CommentStyle |
The style of a comment
|
| CommentStyle.Block |
|
| CommentStyle.Datum |
|
| CommentStyle.Line |
|
| CommentStyle.PartialVisitor<R> |
|
| CommentStyle.Visitor<R> |
|
| CondClause |
A clause in a cond expression
|
| CondClause.Builder |
|
| CondExpression |
Multi-branch conditional.
|
| CondExpression.Builder |
|
| ConsExpression |
A cons expression: (cons head tail)
|
| ConsExpression.Builder |
|
| ConstantDefinition |
A constant definition.
|
| ConstantDefinition.Builder |
|
| ConstructorPattern |
A constructor pattern matching a tagged value
|
| ConstructorPattern.Builder |
|
| DestructuringBinding |
A destructuring binding in a let expression
|
| DestructuringBinding.Builder |
|
| DestructuringPattern |
A destructuring pattern
|
| DestructuringPattern.Associative |
Associative/map destructuring: {:keys [a b]} in Clojure
|
| DestructuringPattern.PartialVisitor<R> |
|
| DestructuringPattern.Rest |
Destructuring with a rest element: [a b & rest] (leading symbols + rest symbol)
|
| DestructuringPattern.Sequential |
Sequential destructuring: [a b c] in Clojure, (a b c) in others
|
| DestructuringPattern.Visitor<R> |
|
| Dialect |
A Lisp dialect
|
| Dialect.Clojure |
|
| Dialect.CommonLisp |
|
| Dialect.EmacsLisp |
|
| Dialect.PartialVisitor<R> |
|
| Dialect.Scheme |
|
| Dialect.Visitor<R> |
|
| Docstring |
A documentation string
|
| Docstring.Builder |
|
| DoExpression |
Sequential evaluation of expressions, returning the last.
|
| DoExpression.Builder |
|
| DottedPair |
A dotted pair literal: '(a .
|
| DottedPair.Builder |
|
| ExportDeclaration |
An export/provide declaration.
|
| ExportDeclaration.Builder |
|
| Expression |
A Lisp expression
|
| Expression.And |
Logical and (short-circuiting)
|
| Expression.Application |
Function application: (f arg1 arg2 ...)
|
| Expression.Begin |
Sequential evaluation (explicit begin block)
|
| Expression.Case |
Case/match dispatch
|
| Expression.Cond |
Multi-branch conditional
|
| Expression.Cons |
A cons expression
|
| Expression.Do |
Sequential evaluation (progn/do/begin)
|
| Expression.DottedPair |
A dotted pair literal
|
| Expression.FieldAccess |
Field access on a record/struct
|
| Expression.If |
Conditional expression
|
| Expression.Lambda |
Anonymous function
|
| Expression.Let |
Local variable binding
|
| Expression.List |
A list literal
|
| Expression.Literal |
A literal value
|
| Expression.Map |
A map/association literal
|
| Expression.Not |
Logical negation
|
| Expression.Or |
Logical or (short-circuiting)
|
| Expression.PartialVisitor<R> |
|
| Expression.Quasiquote |
A quasiquoted expression
|
| Expression.Quote |
A quoted expression
|
| Expression.Set |
A set literal
|
| Expression.SExpression |
An arbitrary S-expression (escape hatch for dialect-specific forms)
|
| Expression.SplicingUnquote |
A splicing unquote within a quasiquote
|
| Expression.TypeAnnotation |
A type-annotated expression
|
| Expression.Unquote |
An unquoted expression within a quasiquote
|
| Expression.Variable |
Variable reference
|
| Expression.Vector |
A vector literal
|
| Expression.Visitor<R> |
|
| FieldAccess |
Field access on a record/struct.
|
| FieldAccess.Builder |
|
| FieldDefinition |
A field in a record type definition
|
| FieldDefinition.Builder |
|
| FloatLiteral |
A floating-point literal
|
| FloatLiteral.Builder |
|
| FunctionDefinition |
A named function definition.
|
| FunctionDefinition.Builder |
|
| IfExpression |
Conditional: (if test then else)
|
| IfExpression.Builder |
|
| ImportDeclaration |
An import/require declaration.
|
| ImportDeclaration.Builder |
|
| ImportSpec |
An import specification describing how to import symbols
|
| ImportSpec.Alias |
Import with an alias: (:require [name :as alias]) in Clojure
|
| ImportSpec.All |
Import everything
|
| ImportSpec.Only |
Import specific symbols: (:require [name :refer [sym1 sym2]]) in Clojure
|
| ImportSpec.PartialVisitor<R> |
|
| ImportSpec.Rename |
Import with renaming: list of (from, to) symbol pairs
|
| ImportSpec.Visitor<R> |
|
| IntegerLiteral |
An integer literal
|
| IntegerLiteral.Builder |
|
| Keyword |
A keyword (self-evaluating symbol).
|
| Keyword.Builder |
|
| Lambda |
An anonymous function.
|
| Lambda.Builder |
|
| Language |
Language constraints and reserved words for Lisp (covering Clojure, Emacs Lisp, Common Lisp, and Scheme)
|
| LetBinding |
A single binding in a let expression
|
| LetBinding.Destructuring |
A destructuring binding
|
| LetBinding.PartialVisitor<R> |
|
| LetBinding.Simple |
A simple name-value binding
|
| LetBinding.Visitor<R> |
|
| LetExpression |
Local variable bindings.
|
| LetExpression.Builder |
|
| LetKind |
The kind of let binding
|
| LetKind.Parallel |
|
| LetKind.PartialVisitor<R> |
|
| LetKind.Recursive |
|
| LetKind.Sequential |
|
| LetKind.Visitor<R> |
|
| ListLiteral |
A list literal: '(1 2 3) or (list 1 2 3)
|
| ListLiteral.Builder |
|
| Literal |
A Lisp literal value
|
| Literal.Boolean_ |
A boolean literal (dialect-specific rendering)
|
| Literal.Character_ |
A character literal
|
| Literal.Float_ |
A floating-point literal
|
| Literal.Integer_ |
An integer literal
|
| Literal.Keyword |
A keyword literal
|
| Literal.Nil |
Nil/null/empty list (dialect-specific rendering)
|
| Literal.PartialVisitor<R> |
|
| Literal.String_ |
A string literal
|
| Literal.Symbol |
A quoted symbol literal
|
| Literal.Visitor<R> |
|
| LiteralPattern |
A pattern matching a literal value
|
| LiteralPattern.Builder |
|
| MacroDefinition |
A macro definition.
|
| MacroDefinition.Builder |
|
| MapEntry |
A key-value pair in a map literal
|
| MapEntry.Builder |
|
| MapLiteral |
A map/dictionary literal.
|
| MapLiteral.Builder |
|
| ModuleDeclaration |
A module/namespace declaration.
|
| ModuleDeclaration.Builder |
|
| NamespaceName |
A namespace or package name
|
| NamespaceName.Builder |
|
| NilStyle |
The style of nil/null in a dialect
|
| NilStyle.EmptyList |
|
| NilStyle.Nil |
|
| NilStyle.PartialVisitor<R> |
|
| NilStyle.Visitor<R> |
|
| NotExpression |
Logical negation: (not expr)
|
| NotExpression.Builder |
|
| OrExpression |
Logical or: (or expr1 expr2 ...)
|
| OrExpression.Builder |
|
| Pattern |
A pattern for use in case expressions or match forms
|
| Pattern.Constructor |
A constructor pattern (for union/sum type matching)
|
| Pattern.Literal |
A literal pattern
|
| Pattern.PartialVisitor<R> |
|
| Pattern.Variable |
A variable pattern that binds the matched value
|
| Pattern.Visitor<R> |
|
| Pattern.Wildcard |
A wildcard pattern matching anything
|
| Program |
A Lisp program, consisting of a sequence of top-level forms
|
| Program.Builder |
|
| QualifiedSymbol |
A namespace-qualified symbol.
|
| QualifiedSymbol.Builder |
|
| QuasiquoteExpression |
A quasiquoted form: `expr
|
| QuasiquoteExpression.Builder |
|
| QuoteExpression |
A quoted form: 'expr or (quote expr)
|
| QuoteExpression.Builder |
|
| RecordTypeDefinition |
A record/struct type definition.
|
| RecordTypeDefinition.Builder |
|
| Serde |
Lisp serializer: converts Lisp AST to concrete syntax for Clojure, Emacs Lisp, Common Lisp, or Scheme
|
| SetLiteral |
A set literal.
|
| SetLiteral.Builder |
|
| SExpression |
A raw S-expression.
|
| SExpression.Atom |
An atomic value
|
| SExpression.List |
A list of S-expressions
|
| SExpression.PartialVisitor<R> |
|
| SExpression.Visitor<R> |
|
| SimpleBinding |
A simple name-value binding in a let expression
|
| SimpleBinding.Builder |
|
| SplicingUnquoteExpression |
A splicing unquote within a quasiquote: ~@expr or ,@expr
|
| SplicingUnquoteExpression.Builder |
|
| Symbol |
A Lisp symbol (identifier)
|
| Symbol.Builder |
|
| Syntax |
DSL functions for hydra.lisp.syntax
|
| TopLevelForm |
A top-level form in a Lisp program
|
| TopLevelForm.Constant |
A constant definition
|
| TopLevelForm.Expression |
A bare expression at the top level
|
| TopLevelForm.Function |
A named function definition
|
| TopLevelForm.Macro |
A macro definition
|
| TopLevelForm.PartialVisitor<R> |
|
| TopLevelForm.RecordType |
A record/struct type definition
|
| TopLevelForm.Variable |
A global variable definition
|
| TopLevelForm.Visitor<R> |
|
| TopLevelFormWithComments |
A top-level form together with optional documentation
|
| TopLevelFormWithComments.Builder |
|
| TypeAnnotation |
An expression with a type annotation
|
| TypeAnnotation.Builder |
|
| TypeHint |
A type hint or annotation.
|
| TypeHint.Builder |
|
| TypeSpecifier |
A type specifier
|
| TypeSpecifier.Either |
An either/union type (two type specifiers)
|
| TypeSpecifier.Function |
A function type (params and return)
|
| TypeSpecifier.List |
A list type
|
| TypeSpecifier.Map |
A map type (key and value type specifiers)
|
| TypeSpecifier.Maybe |
An optional type
|
| TypeSpecifier.Named |
A named type reference
|
| TypeSpecifier.Pair |
A pair/tuple type (two type specifiers)
|
| TypeSpecifier.PartialVisitor<R> |
|
| TypeSpecifier.Set |
A set type
|
| TypeSpecifier.Unit |
The unit type
|
| TypeSpecifier.Visitor<R> |
|
| UnquoteExpression |
An unquoted form within a quasiquote: ~expr or ,expr
|
| UnquoteExpression.Builder |
|
| VariableDefinition |
A global variable definition.
|
| VariableDefinition.Builder |
|
| VariableReference |
A reference to a variable by name
|
| VariableReference.Builder |
|
| VectorLiteral |
A vector literal.
|
| VectorLiteral.Builder |
|