Grammar

Swift

public enum Visibility : Hashable

Swift

public enum Structure : Hashable

Swift

public enum Availability : Hashable

Swift

public struct Properties : Hashable

Swift

@propertyWrapper
public class Sym<In, Out, S> : SettableSymbol where In : Sort, Out : Sort, S : Symbol<In, Out>

Swift

public typealias Symbols = [SymbolName : Properties]

Swift

public typealias Rules = [SymbolName : Set<Rule>]

Swift

public var language: Language { get }

Swift

public var symbols: Symbols { get }

Swift

public var rules: Rules { get }

Swift

public func rulesOf(symbol: SymbolName) -> Set<Rule>

Swift

public var terminalPriorities: Set<TerminalPriority> { get }

Swift

public var lookaheads: [SymbolName : Bool] { get }

Swift

public init(parents: [Grammar] = [], sealed: Bool = true)

Swift

public var isSealed: Bool { get }

Swift

public func seal()

Swift

public func kindOf(_ name: SymbolName) -> SymbolKind?

Swift

public func propertiesOf(_ name: SymbolName) -> Properties?

Swift

public func exists(_ name: SymbolName) -> Bool

Swift

public func isDeep(_ name: SymbolName) -> Bool

Swift

public func isFlat(_ name: SymbolName) -> Bool

Swift

public func isVisible(_ name: SymbolName) -> Bool

Swift

public func isAuxiliary(_ name: SymbolName) -> Bool

Swift

public func isHidden(_ name: SymbolName) -> Bool

Swift

public func makeFlat(_ name: SymbolName)

Swift

public func makeDeep<I, O>(_ terminal: Terminal<I, O>) where I : Sort, O : Sort

Swift

public func install(sort: Sort)

Swift

public func install<In, Out>(symbol: Symbol<In, Out>, properties: Grammar.Properties) -> Bool where In : Sort, Out : Sort

Swift

public func terminal<In, Out>(_ name: SymbolName, in: In = In(), out: Out = Out()) -> Terminal<In, Out> where In : Sort, Out : Sort

Swift

public func terminal<In>(_ name: SymbolName, in: In = In()) -> Terminal<In, UNIT> where In : Sort

Swift

public func terminal<Out>(_ name: SymbolName, out: Out = Out()) -> Terminal<UNIT, Out> where Out : Sort

Swift

public func terminal(_ name: SymbolName) -> Terminal<UNIT, UNIT>

Swift

public func fresh<In, Out>(terminal name: SymbolName, in: In = In(), out: Out = Out()) -> Terminal<In, Out> where In : Sort, Out : Sort

Swift

public func nonterminal<In, Out>(_ name: SymbolName, in: In = In(), out: Out = Out()) -> Nonterminal<In, Out> where In : Sort, Out : Sort

Swift

public func nonterminal<In>(_ name: SymbolName, in: In = In()) -> Nonterminal<In, UNIT> where In : Sort

Swift

public func nonterminal<Out>(_ name: SymbolName, out: Out = Out()) -> Nonterminal<UNIT, Out> where Out : Sort

Swift

public func nonterminal(_ name: SymbolName) -> Nonterminal<UNIT, UNIT>

Swift

public func fresh<In, Out>(nonterminal name: SymbolName, in: In, out: Out) -> Nonterminal<In, Out> where In : Sort, Out : Sort

Swift

public var EMPTY: RuleBody { get }

Swift

public func prioritise<In1 : Sort, Out1 : Sort, In2 : Sort, Out2 : Sort>(
    terminal terminal2 : Terminal<In1, Out1>,
    over terminal1 : Terminal<In2, Out2>,
    file : String = #file, line : Int = #line) -> TerminalPriority

Swift

public func prioritise<In1 : ASort, Out1 : ASort, In2 : ASort, Out2 : ASort>(
    terminal terminal2 : Terminal<In1, Out1>,
    over terminal1 : Terminal<In2, Out2>,
    when : TerminalPriority.Condition,
    file : String = #file, line : Int = #line) -> TerminalPriority

Swift

public func prioritiseLongest(_ terminals : SymbolWithName...,
                              file : String = #file, line : Int = #line) -> GrammarElement

Swift

public func prioritiseLongest(_ terminalNames : [IndexedSymbolName],
                              file : String = #file, line : Int = #line) -> GrammarElement

Swift

public func prioritiseExclusionary(_ terminals : SymbolWithName...,
                              file : String = #file, line : Int = #line) -> GrammarElement

Swift

public func prioritiseExclusionary(_ terminalNames : [IndexedSymbolName],
                                   file : String = #file, line : Int = #line) -> GrammarElement

Swift

public func andNext<In, Out>(_ symbol: Symbol<In, Out>) -> Terminal<In, UNIT> where In : Sort, Out : Sort

Swift

public func notNext<In, Out>(_ symbol: Symbol<In, Out>) -> Terminal<In, UNIT> where In : Sort, Out : Sort

Swift

public func add(@GrammarBuilder _ builder: () -> GrammarElement)

Swift

public func add(component: GrammarComponent)

Swift

open func build()

Swift

public func assign<S, T>(_ symbol1: Symbol<S, T>, _ symbol2: Symbol<S, T>) -> GrammarElement where S : Sort, T : Sort

Swift

public func freshTerminal<S, T>(_ name: String) -> Terminal<S, T> where S : Sort, T : Sort

Swift

public func freshNonterminal<S, T>(_ name: String) -> Nonterminal<S, T> where S : Sort, T : Sort

Swift

public func Empty<S>() -> Nonterminal<S, S> where S : Sort

Swift

public func Mute<S, T>(_ symbol: Symbol<S, T>) -> Nonterminal<S, UNIT> where S : Sort, T : Sort

Swift

public func Repeat<S>(_ symbol: Symbol<S, S>) -> Nonterminal<S, S> where S : Sort

Swift

public func RepeatGreedy<S>(_ symbol: Symbol<S, S>) -> Symbol<S, S> where S : Sort

Swift

public func Iterate<S>(_ symbol: Symbol<S, UNIT>) -> Nonterminal<S, UNIT> where S : Sort

Swift

public func IterateGreedy<S>(_ symbol: Symbol<S, UNIT>) -> Symbol<S, UNIT> where S : Sort

Swift

public func Repeat1<S>(_ symbol: Symbol<S, S>) -> Nonterminal<S, S> where S : Sort

Swift

public func Repeat1Greedy<S>(_ symbol: Symbol<S, S>) -> Symbol<S, S> where S : Sort

Swift

public func Maybe<S>(_ symbol: Symbol<S, S>) -> Nonterminal<S, S> where S : Sort

Swift

public func MaybeGreedy<S>(_ symbol: Symbol<S, S>) -> Nonterminal<S, S> where S : Sort

Swift

public func MaybeGreedy<S>(_ symbol: Symbol<S, UNIT>) -> Nonterminal<S, UNIT> where S : Sort

Swift

public func Or<S, T>(_ symbols: Symbol<S, T>...) -> Nonterminal<S, T> where S : Sort, T : Sort

Swift

public func OrGreedy<S, T>(_ symbols: Symbol<S, T>...) -> Nonterminal<S, T> where S : Sort, T : Sort

Swift

public func Seq<S, U, V>(_ symbol1: Symbol<S, U>, _ symbol2: Symbol<U, V>) -> Nonterminal<S, V> where S : Sort, U : Sort, V : Sort

Swift

public func Seq<S, U, V, W>(_ symbol1: Symbol<S, U>, _ symbol2: Symbol<U, V>, _ symbol3: Symbol<V, W>) -> Nonterminal<S, W> where S : Sort, U : Sort, V : Sort, W : Sort

Swift

public func Seq<S, U, V, W, X>(_ symbol1 : Symbol<S, U>, _ symbol2 : Symbol<U, V>, _ symbol3 : Symbol<V, W>,
                               _ symbol4 : Symbol<W, X>) -> Nonterminal<S, X>

Swift

public func Seq<S, U, V, W, X, Y>(_ symbol1 : Symbol<S, U>, _ symbol2 : Symbol<U, V>, _ symbol3 : Symbol<V, W>,
                                  _ symbol4 : Symbol<W, X>, _ symbol5 : Symbol<X, Y>) -> Nonterminal<S, Y>

Swift

public func Supply<S, T>(_ input: S = S.default(), _ symbol: Symbol<S, T>) -> Nonterminal<UNIT, T> where S : Sort, T : Sort

Swift

public func Greedy<S, T>(_ symbol: Symbol<S, T>) -> Terminal<S, T> where S : Sort, T : Sort