mathlex 0.4.1

Mathematical expression parser for LaTeX and plain text notation, producing a language-agnostic AST
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

import MathLexBridge

public func parseText<GenericToRustStr: ToRustStr>(_ input: GenericToRustStr) throws -> Expression {
  return try input.toRustStr({ inputAsRustStr in
    try {
      let val = __swift_bridge__$parse_text(inputAsRustStr)
      if val.is_ok {
        return Expression(ptr: val.ok_or_err!)
      } else {
        throw RustString(ptr: val.ok_or_err!)
      }
    }()
  })
}
public func parseLatex<GenericToRustStr: ToRustStr>(_ input: GenericToRustStr) throws -> Expression
{
  return try input.toRustStr({ inputAsRustStr in
    try {
      let val = __swift_bridge__$parse_latex_ffi(inputAsRustStr)
      if val.is_ok {
        return Expression(ptr: val.ok_or_err!)
      } else {
        throw RustString(ptr: val.ok_or_err!)
      }
    }()
  })
}
public func toString(_ expr: ExpressionRef) -> RustString {
  RustString(ptr: __swift_bridge__$expression_to_string(expr.ptr))
}
public func toLatex(_ expr: ExpressionRef) -> RustString {
  RustString(ptr: __swift_bridge__$expression_to_latex(expr.ptr))
}
public func findVariables(_ expr: ExpressionRef) -> RustVec<RustString> {
  RustVec(ptr: __swift_bridge__$expression_find_variables(expr.ptr))
}
public func findFunctions(_ expr: ExpressionRef) -> RustVec<RustString> {
  RustVec(ptr: __swift_bridge__$expression_find_functions(expr.ptr))
}
public func findConstants(_ expr: ExpressionRef) -> RustVec<RustString> {
  RustVec(ptr: __swift_bridge__$expression_find_constants(expr.ptr))
}
public func depth(_ expr: ExpressionRef) -> UInt {
  __swift_bridge__$expression_depth(expr.ptr)
}
public func nodeCount(_ expr: ExpressionRef) -> UInt {
  __swift_bridge__$expression_node_count(expr.ptr)
}
public func toJSON(_ expr: ExpressionRef) throws -> RustString {
  try {
    let val = __swift_bridge__$expression_to_json(expr.ptr)
    if val.is_ok {
      return RustString(ptr: val.ok_or_err!)
    } else {
      throw RustString(ptr: val.ok_or_err!)
    }
  }()
}
public func toJSONPretty(_ expr: ExpressionRef) throws -> RustString {
  try {
    let val = __swift_bridge__$expression_to_json_pretty(expr.ptr)
    if val.is_ok {
      return RustString(ptr: val.ok_or_err!)
    } else {
      throw RustString(ptr: val.ok_or_err!)
    }
  }()
}

public class Expression: ExpressionRefMut {
  var isOwned: Bool = true

  public override init(ptr: UnsafeMutableRawPointer) {
    super.init(ptr: ptr)
  }

  deinit {
    if isOwned {
      __swift_bridge__$Expression$_free(ptr)
    }
  }
}
public class ExpressionRefMut: ExpressionRef {
  public override init(ptr: UnsafeMutableRawPointer) {
    super.init(ptr: ptr)
  }
}
public class ExpressionRef {
  var ptr: UnsafeMutableRawPointer

  public init(ptr: UnsafeMutableRawPointer) {
    self.ptr = ptr
  }
}
extension Expression: Vectorizable {
  public static func vecOfSelfNew() -> UnsafeMutableRawPointer {
    __swift_bridge__$Vec_Expression$new()
  }

  public static func vecOfSelfFree(vecPtr: UnsafeMutableRawPointer) {
    __swift_bridge__$Vec_Expression$drop(vecPtr)
  }

  public static func vecOfSelfPush(vecPtr: UnsafeMutableRawPointer, value: Expression) {
    __swift_bridge__$Vec_Expression$push(
      vecPtr,
      {
        value.isOwned = false
        return value.ptr
      }())
  }

  public static func vecOfSelfPop(vecPtr: UnsafeMutableRawPointer) -> Self? {
    let pointer = __swift_bridge__$Vec_Expression$pop(vecPtr)
    if pointer == nil {
      return nil
    } else {
      return (Expression(ptr: pointer!) as! Self)
    }
  }

  public static func vecOfSelfGet(vecPtr: UnsafeMutableRawPointer, index: UInt) -> ExpressionRef? {
    let pointer = __swift_bridge__$Vec_Expression$get(vecPtr, index)
    if pointer == nil {
      return nil
    } else {
      return ExpressionRef(ptr: pointer!)
    }
  }

  public static func vecOfSelfGetMut(vecPtr: UnsafeMutableRawPointer, index: UInt)
    -> ExpressionRefMut?
  {
    let pointer = __swift_bridge__$Vec_Expression$get_mut(vecPtr, index)
    if pointer == nil {
      return nil
    } else {
      return ExpressionRefMut(ptr: pointer!)
    }
  }

  public static func vecOfSelfAsPtr(vecPtr: UnsafeMutableRawPointer) -> UnsafePointer<ExpressionRef>
  {
    UnsafePointer<ExpressionRef>(OpaquePointer(__swift_bridge__$Vec_Expression$as_ptr(vecPtr)))
  }

  public static func vecOfSelfLen(vecPtr: UnsafeMutableRawPointer) -> UInt {
    __swift_bridge__$Vec_Expression$len(vecPtr)
  }
}