Rewrote the LaTeX parser to be more flexible

MathDisplay/DataTypes/AliasMap.fs → MathDisplay.Tests.Benchmarks/AliasMap.fs

@@ -19,7 +19,7 @@ type AliasMap<'Key, 'Value when 'Key : comparison and 'Value : comparison> =
     interface System.Collections.IEnumerable with
         member this.GetEnumerator() = (AliasMap.toSeq this :> System.Collections.IEnumerable).GetEnumerator()
     interface System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<'Key, 'Value>> with
-        member this.GetEnumerator() = match this with | AliasMap (k2v, _) -> (k2v :> System.Collections.Generic.IEnumerable<_>).GetEnumerator()
+        member this.GetEnumerator() = match this with AliasMap (k2v, _) -> (k2v :> System.Collections.Generic.IEnumerable<_>).GetEnumerator()
     interface System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<'Key, 'Value>> with
         member this.Count = AliasMap.count this
     interface System.Collections.Generic.IReadOnlyDictionary<'Key, 'Value> with
@@ -92,13 +92,4 @@ module AliasMap =
     /// Takes a list of (Primary key you get by indexing with the value, Other keys, Value)
     let ofListWithValueMap valueMap list = ofListWtihKeyKeysValueMap id id valueMap list
     /// Takes a list of (Primary key you get by indexing with the value, Other keys, Value)
-    let ofListWithKeyValueMap keyMap valueMap list = ofListWtihKeyKeysValueMap keyMap (List.map keyMap) valueMap list
-
-type INT = INT of int
-type L() =
-    class
-        member __.Item with get(f : INT) = f
-        member __.Item with get(f : int) = f
-        static member IUEWOKJU(this : L) = this.[1]
-    end
-
+    let ofListWithKeyValueMap keyMap valueMap list = ofListWtihKeyKeysValueMap keyMap (List.map keyMap) valueMap list

MathDisplay.Tests.Benchmarks/MathDisplay.Tests.Benchmarks.fsproj

@@ -8,6 +8,7 @@
 
   <ItemGroup>
     <Compile Include="MapBenchmark.fs" />
+    <Compile Include="AliasMap.fs" />
     <Compile Include="BiDictionary.fs" />
     <Compile Include="AliasMapBenchmark.fs" />
     <Compile Include="Program.fs" />

MathDisplay.Tests/UnitTests.fs

@@ -15,9 +15,8 @@ type TestClass () =
 
     [<Test>]
     member __.``Gather output`` () =
-        let fff = MathDisplay.DataTypes.List.partitionWhile ((=) 'a') ['a'; 'a'; 'a'; 'a'; 'b'; 'c']
         let x =
-            @"123"
-            |> LaTeX.toAtom LaTeX.Options.Default
+            @"\left.\frac\sqrt{23}4\right)"
+            |> LaTeX.ToAtom LaTeX.Options.Default
         (match x with Ok r -> r | Error e -> InfoException e |> raise).ToString() |>
         Assert.Pass

MathDisplay/DataTypes/AliasDictionary.fs

@@ -0,0 +1,53 @@
+namespace MathDisplay.DataTypes
+
+open System.Collections.Generic
+
+/// Holds a d:Dictionary<'X,'Y>, and an e:Dictionary<'Y,'X> which are quasi-inverses in the sense that
+/// for any key x in d, x.[d] is key in 'Y, and d.[e.[y]] = y.
+/// d-keys are "Aliases" of e-keys, and a e-key may have many aliases mapping to it (so d may not be injective),
+/// but there is a primary alias corresponding to each e-key (so e is injective).
+type AliasDictionary<'X, 'Y when 'X : equality and 'Y : equality> private(d:Dictionary<'X,'Y>, e:Dictionary<'Y,'X>) =
+    new() = AliasDictionary(Dictionary<'X, 'Y>(), Dictionary<'Y, 'X>())
+    member __.Aliases = d.Keys
+    /// Add primary aliases
+    member __.AddPrimary(primaryAlias:'X, value:'Y) =
+        d.Add(primaryAlias, value)
+        e.Add(value, primaryAlias)
+    /// Add secondary aliases
+    member __.AddMore(secondaryAliases:seq<'X>, value:'Y) =
+        for x in secondaryAliases do d.Add(x, value)
+    member this.Add(primaryAlias:'X, secondaryAliases : seq<'X>, value:'Y) =
+        d.Add(primaryAlias, value)
+        e.Add(value, primaryAlias)
+        this.AddMore(secondaryAliases, value)
+    /// The first item of aliases is primary.
+    member this.Add(aliases : 'X list, value:'Y) =
+        match aliases with
+        | primaryAlias::secondaryAliases ->
+            d.Add(primaryAlias, value)
+            e.Add(value, primaryAlias)
+            this.AddMore(secondaryAliases, value)
+        | [] -> ()
+    /// The first of any 'X list is primary.
+    member this.AddList(pairs:('X list * 'Y) list) =
+        pairs |> List.iter (fun (keys, value) ->
+            match keys with
+            | primaryKey::secondaryKeys ->
+                this.Add(primaryKey, secondaryKeys, value)
+            | [] -> ())
+    /// The first of any 'X list is primary.
+    new(pairs:('X list * 'Y) list) as this =
+        AliasDictionary<'X, 'Y>() then
+        this.AddList pairs
+    /// The first of any 'X list is primary.
+    new(valueComparer:IEqualityComparer<'Y>, pairs:('X list * 'Y) list) as this =
+        AliasDictionary<'X, 'Y>(Dictionary<'X, 'Y>(), Dictionary<'Y, 'X>(valueComparer)) then
+        this.AddList pairs
+    member __.TryGetKey value =
+        match e.TryGetValue value with
+        | true, v -> ValueSome v
+        | false, _ -> ValueNone
+    member __.TryGetValue key =
+        match d.TryGetValue key with
+        | true, v -> ValueSome v
+        | false, _ -> ValueNone

MathDisplay/DataTypes/ListExtensions.fs

@@ -4,8 +4,18 @@ module MathDisplay.DataTypes.List
   /// Partition elements of a list using the specified predicate.
   /// The result is a tuple containing elements (from the beginning 
   /// of the list that satisfy the predicate) and the rest of the list.
-  let inline partitionWhile f =
+  let partitionWhile (f: 'T -> bool) =
     let rec loop acc = function
       | x::xs when f x -> loop (x::acc) xs
       | xs -> List.rev acc, xs
-    loop [] 
+    loop []
+
+  // TODO: What is this? Simplify type signature and document, or remove
+  let mapFoldResult f (state:'State) (list: 'T list) : Result<'Result list * 'State, 'Error> =
+    let rec loop acc state = function
+      | [] -> (List.rev acc, state) |> Ok
+      | x::xs ->
+        match f state x with
+        | Ok (value, state) -> loop (value::acc) state xs
+        | Error e -> Error e
+    loop [] state list