FSharpx.Core by Steffen Forkmann, Daniel Mohl, Tomas Petricek, Ryan Riley, Mauricio Scheffer, Phil Trelford

<PackageReference Include="FSharpx.Core" Version="1.6.94" />

---

API Diff between 1.6.94 and 1.6.62

583 Additions 36 Removals

FSharpx

• public class FSharpOption
  • public static a[] ToArray<a>(FSharpOption<a> o)
  • public static FSharpList<a> ToFSharpList<a>(FSharpOption<a> o)
• public static class JSON
  • public class Date : Infrastucture, IDocument
• public class RoseTree
  • public static RoseTree<a> Create<a>(a root, RoseTree<a>[] children)
  • public static RoseTree<a> Create<a>(a root, LazyList<RoseTree<a>> children)
  • public static RoseTree<b> Select<a, b>(RoseTree<a> tree, Func<a, b> f)
  • public static RoseTree<b> SelectMany<a, b>(RoseTree<a> o, Func<a, RoseTree<b>> f)
  • public static RoseTree<c> SelectMany<a, b, c>(RoseTree<a> o, Func<a, RoseTree<b>> f, Func<a, b, c> mapper)
  • public static RoseTree<a> Singleton<a>(a x)

FSharpx.DataStructures

• public static class AltBinaryRandomAccessList
• public static class BankersDeque
• public static class BatchedDeque
• public static class AltBinaryRandomAccessListModule
  • public static FSharpChoice<Tuple<a, AltBinRndAccList<a>>, Unit> |Cons|Nil|<a>(AltBinRndAccList<a> l)
  • public static AltBinRndAccList<a> append<a>(AltBinRndAccList<a> xs, AltBinRndAccList<a> ys)
  • public static AltBinRndAccList<a> cons<a>(a x, AltBinRndAccList<a> xs)
  • public static AltBinRndAccList<a> empty<a>()
  • public static a head<a>(AltBinRndAccList<a> xs)
  • public static bool isEmpty<a>(AltBinRndAccList<a> xs)
  • public static int length<a>(AltBinRndAccList<a> xs)
  • public static a lookup<a>(int i, AltBinRndAccList<a> xs)
  • public static AltBinRndAccList<a> ofSeq<a>(IEnumerable<a> s)
  • public static AltBinRndAccList<a> remove<a>(int i, AltBinRndAccList<a> xs)
  • public static AltBinRndAccList<a> rev<a>(AltBinRndAccList<a> xs)
  • public static AltBinRndAccList<a> tail<a>(AltBinRndAccList<a> xs)
  • public static FSharpOption<a> tryGetHead<a>(AltBinRndAccList<a> xs)
  • public static FSharpOption<AltBinRndAccList<a>> tryGetTail<a>(AltBinRndAccList<a> xs)
  • public static FSharpOption<a> tryLookup<a>(int i, AltBinRndAccList<a> xs)
  • public static FSharpOption<AltBinRndAccList<a>> tryRemove<a>(int i, AltBinRndAccList<a> xs)
  • public static FSharpOption<Tuple<a, AltBinRndAccList<a>>> tryUncons<a>(AltBinRndAccList<a> xs)
  • public static FSharpOption<AltBinRndAccList<a>> tryUpdate<a>(int i, a y, AltBinRndAccList<a> xs)
  • public static Tuple<a, AltBinRndAccList<a>> uncons<a>(AltBinRndAccList<a> xs)
  • public static AltBinRndAccList<a> update<a>(int i, a y, AltBinRndAccList<a> xs)
• public abstract class AltBinRndAccList<a> : IEquatable<AltBinRndAccList<a>>, IStructuralEquatable, IComparable<AltBinRndAccList<a>>, IComparable, IStructuralComparable, IRandomAccessList<a>
  • public class One<a> : AltBinRndAccList<a>
  • public static class Tags<a>
  • public class Zero<a> : AltBinRndAccList<a>
  • public static AltBinRndAccList<a> Nil { get; }
  • public a Head { get; }
  • public bool IsEmpty { get; }
  • public bool IsNil { get; }
  • public bool IsOne { get; }
  • public bool IsZero { get; }
  • public int Length { get; }
  • public AltBinRndAccList<a> Rev { get; }
  • public int Tag { get; }
  • public AltBinRndAccList<a> Tail { get; }
  • public FSharpOption<AltBinRndAccList<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, AltBinRndAccList<a>>> TryUncons { get; }
  • public Tuple<a, AltBinRndAccList<a>> Uncons { get; }
  • public static AltBinRndAccList<a> NewOne(a item1, AltBinRndAccList<Tuple<a, a>> item2)
  • public static AltBinRndAccList<a> NewZero(AltBinRndAccList<Tuple<a, a>> item)
  • public AltBinRndAccList<a> Cons(a x)
  • public a Lookup(int i)
  • public AltBinRndAccList<a> Remove(int i)
  • public FSharpOption<a> TryGetHead()
  • public FSharpOption<a> TryLookup(int i)
  • public FSharpOption<AltBinRndAccList<a>> TryRemove(int i)
  • public FSharpOption<AltBinRndAccList<a>> TryUpdate(int i, a y)
  • public AltBinRndAccList<a> Update(int i, a y)
• public class BankersDeque<a> : IEnumerable<a>, IDeque<a>
  • public a Head { get; }
  • public BankersDeque<a> Init { get; }
  • public bool IsEmpty { get; }
  • public a Last { get; }
  • public int Length { get; }
  • public BankersDeque<a> Rev { get; }
  • public BankersDeque<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<BankersDeque<a>> TryGetInit { get; }
  • public FSharpOption<a> TryGetLast { get; }
  • public FSharpOption<BankersDeque<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, BankersDeque<a>>> TryUncons { get; }
  • public FSharpOption<Tuple<BankersDeque<a>, a>> TryUnsnoc { get; }
  • public Tuple<a, BankersDeque<a>> Uncons { get; }
  • public Tuple<BankersDeque<a>, a> Unsnoc { get; }
  • public BankersDeque(int c, int frontLength, LazyList<a> front, int rBackLength, LazyList<a> rBack)
  • public BankersDeque<a> Cons(a x)
  • public a Lookup(int i)
  • public BankersDeque<a> Remove(int i)
  • public BankersDeque<a> Snoc(a x)
  • public FSharpOption<a> TryLookup(int i)
  • public FSharpOption<BankersDeque<a>> TryRemove(int i)
  • public FSharpOption<BankersDeque<a>> TryUpdate(int i, a y)
  • public BankersDeque<a> Update(int i, a y)
• public static class BankersDequeModule
  • public static FSharpChoice<Tuple<a, BankersDeque<a>>, Unit> |Cons|Nil|<a>(BankersDeque<a> q)
  • public static FSharpChoice<Tuple<BankersDeque<a>, a>, Unit> |Snoc|Nil|<a>(BankersDeque<a> q)
  • public static BankersDeque<a> append<a>(BankersDeque<a> xs, BankersDeque<a> ys)
  • public static BankersDeque<a> appendC<a>(int c, BankersDeque<a> xs, BankersDeque<a> ys)
  • public static BankersDeque<a> cons<a>(a x, BankersDeque<a> q)
  • public static BankersDeque<a> empty<a>(int c)
  • public static a head<a>(BankersDeque<a> q)
  • public static BankersDeque<a> init<a>(BankersDeque<a> q)
  • public static bool isEmpty<a>(BankersDeque<a> q)
  • public static a last<a>(BankersDeque<a> q)
  • public static int length<a>(BankersDeque<a> q)
  • public static a lookup<a>(int i, BankersDeque<a> q)
  • public static BankersDeque<a> ofCatLists<a>(FSharpList<a> xs, FSharpList<a> ys)
  • public static BankersDeque<a> ofCatListsC<a>(int c, FSharpList<a> xs, FSharpList<a> ys)
  • public static BankersDeque<a> ofCatSeqs<a>(IEnumerable<a> xs, IEnumerable<a> ys)
  • public static BankersDeque<a> ofCatSeqsC<a>(int c, IEnumerable<a> xs, IEnumerable<a> ys)
  • public static BankersDeque<a> ofSeq<a>(IEnumerable<a> xs)
  • public static BankersDeque<a> ofSeqC<a>(int c, IEnumerable<a> xs)
  • public static BankersDeque<a> remove<a>(int i, BankersDeque<a> q)
  • public static BankersDeque<a> rev<a>(BankersDeque<a> q)
  • public static BankersDeque<a> singleton<a>(a x)
  • public static BankersDeque<a> singletonC<a>(int c, a x)
  • public static BankersDeque<a> snoc<a>(a x, BankersDeque<a> q)
  • public static BankersDeque<a> tail<a>(BankersDeque<a> q)
  • public static FSharpOption<a> tryGetHead<a>(BankersDeque<a> q)
  • public static FSharpOption<BankersDeque<a>> tryGetInit<a>(BankersDeque<a> q)
  • public static FSharpOption<a> tryGetLast<a>(BankersDeque<a> q)
  • public static FSharpOption<BankersDeque<a>> tryGetTail<a>(BankersDeque<a> q)
  • public static FSharpOption<a> tryLookup<a>(int i, BankersDeque<a> q)
  • public static FSharpOption<BankersDeque<a>> tryRemove<a>(int i, BankersDeque<a> q)
  • public static FSharpOption<Tuple<a, BankersDeque<a>>> tryUncons<a>(BankersDeque<a> q)
  • public static FSharpOption<Tuple<BankersDeque<a>, a>> tryUnsnoc<a>(BankersDeque<a> q)
  • public static FSharpOption<BankersDeque<a>> tryUpdate<a>(int i, a y, BankersDeque<a> q)
  • public static Tuple<a, BankersDeque<a>> uncons<a>(BankersDeque<a> q)
  • public static Tuple<BankersDeque<a>, a> unsnoc<a>(BankersDeque<a> q)
  • public static BankersDeque<a> update<a>(int i, a y, BankersDeque<a> q)
• public class BankersQueue<a> : IEnumerable<a>, IQueue<a>
  • public a Head { get; }
  • public bool IsEmpty { get; }
  • public int Length { get; }
  • public BankersQueue<a> Rev { get; }
  • public BankersQueue<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<BankersQueue<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, BankersQueue<a>>> TryUncons { get; }
  • public Tuple<a, BankersQueue<a>> Uncons { get; }
  • public BankersQueue(int frontLength, LazyList<a> front, int backLength, LazyList<a> back)
  • public BankersQueue<a> Snoc(a x)
• public static class BankersQueueModule
  • public static FSharpChoice<Tuple<a, BankersQueue<a>>, Unit> |Cons|Nil|<a>(BankersQueue<a> q)
  • public static BankersQueue<a> empty<a>()
  • public static a head<a>(BankersQueue<a> q)
  • public static bool isEmpty<a>(Unit unitVar0, BankersQueue<a> q)
  • public static int length<a>(Unit unitVar0, BankersQueue<a> q)
  • public static BankersQueue<a> ofSeq<a>(IEnumerable<a> xs)
  • public static BankersQueue<a> rev<a>(BankersQueue<a> q)
  • public static BankersQueue<a> snoc<a>(a x, BankersQueue<a> q)
  • public static BankersQueue<a> tail<a>(BankersQueue<a> q)
  • public static FSharpOption<a> tryGetHead<a>(BankersQueue<a> q)
  • public static FSharpOption<BankersQueue<a>> tryGetTail<a>(BankersQueue<a> q)
  • public static FSharpOption<Tuple<a, BankersQueue<a>>> tryUncons<a>(BankersQueue<a> q)
  • public static Tuple<a, BankersQueue<a>> uncons<a>(BankersQueue<a> q)
• public class BatchedDeque<a> : IEnumerable<a>, IDeque<a>
  • public a Head { get; }
  • public BatchedDeque<a> Init { get; }
  • public bool IsEmpty { get; }
  • public a Last { get; }
  • public int Length { get; }
  • public BatchedDeque<a> Rev { get; }
  • public BatchedDeque<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<BatchedDeque<a>> TryGetInit { get; }
  • public FSharpOption<a> TryGetLast { get; }
  • public FSharpOption<BatchedDeque<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, BatchedDeque<a>>> TryUncons { get; }
  • public FSharpOption<Tuple<BatchedDeque<a>, a>> TryUnsnoc { get; }
  • public Tuple<a, BatchedDeque<a>> Uncons { get; }
  • public Tuple<BatchedDeque<a>, a> Unsnoc { get; }
  • public BatchedDeque(FSharpList<a> front, FSharpList<a> rBack)
  • public BatchedDeque<a> Cons(a x)
  • public a Lookup(int i)
  • public BatchedDeque<a> Remove(int i)
  • public BatchedDeque<a> Snoc(a x)
  • public FSharpOption<a> TryLookup(int i)
  • public FSharpOption<BatchedDeque<a>> TryRemove(int i)
  • public FSharpOption<BatchedDeque<a>> TryUpdate(int i, a y)
  • public BatchedDeque<a> Update(int i, a y)
• public static class BatchedDequeModule
  • public static FSharpChoice<Tuple<a, BatchedDeque<a>>, Unit> |Cons|Nil|<a>(BatchedDeque<a> q)
  • public static FSharpChoice<Tuple<BatchedDeque<a>, a>, Unit> |Snoc|Nil|<a>(BatchedDeque<a> q)
  • public static BatchedDeque<a> cons<a>(a x, BatchedDeque<a> q)
  • public static BatchedDeque<a> empty<a>()
  • public static a head<a>(BatchedDeque<a> q)
  • public static BatchedDeque<a> init<a>(BatchedDeque<a> q)
  • public static bool isEmpty<a>(BatchedDeque<a> q)
  • public static a last<a>(BatchedDeque<a> q)
  • public static int length<a>(BatchedDeque<a> q)
  • public static a lookup<a>(int i, BatchedDeque<a> q)
  • public static BatchedDeque<a> ofCatLists<a>(FSharpList<a> xs, FSharpList<a> ys)
  • public static BatchedDeque<a> ofSeq<a>(IEnumerable<a> xs)
  • public static BatchedDeque<a> remove<a>(int i, BatchedDeque<a> q)
  • public static BatchedDeque<a> rev<a>(BatchedDeque<a> q)
  • public static BatchedDeque<a> singleton<a>(a x)
  • public static BatchedDeque<a> snoc<a>(a x, BatchedDeque<a> q)
  • public static BatchedDeque<a> tail<a>(BatchedDeque<a> q)
  • public static FSharpOption<a> tryGetHead<a>(BatchedDeque<a> q)
  • public static FSharpOption<BatchedDeque<a>> tryGetInit<a>(BatchedDeque<a> q)
  • public static FSharpOption<a> tryGetLast<a>(BatchedDeque<a> q)
  • public static FSharpOption<BatchedDeque<a>> tryGetTail<a>(BatchedDeque<a> q)
  • public static FSharpOption<a> tryLookup<a>(int i, BatchedDeque<a> q)
  • public static FSharpOption<BatchedDeque<a>> tryRemove<a>(int i, BatchedDeque<a> q)
  • public static FSharpOption<Tuple<a, BatchedDeque<a>>> tryUncons<a>(BatchedDeque<a> q)
  • public static FSharpOption<Tuple<BatchedDeque<a>, a>> tryUnsnoc<a>(BatchedDeque<a> q)
  • public static FSharpOption<BatchedDeque<a>> tryUpdate<a>(int i, a y, BatchedDeque<a> q)
  • public static Tuple<a, BatchedDeque<a>> uncons<a>(BatchedDeque<a> q)
  • public static Tuple<BatchedDeque<a>, a> unsnoc<a>(BatchedDeque<a> q)
  • public static BatchedDeque<a> update<a>(int i, a y, BatchedDeque<a> q)
• public class BatchedQueue<a> : IEnumerable<a>, IQueue<a>
  • public a Head { get; }
  • public bool IsEmpty { get; }
  • public int Length { get; }
  • public BatchedQueue<a> Rev { get; }
  • public BatchedQueue<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<BatchedQueue<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, BatchedQueue<a>>> TryUncons { get; }
  • public Tuple<a, BatchedQueue<a>> Uncons { get; }
  • public BatchedQueue(FSharpList<a> front, FSharpList<a> rBack)
  • public BatchedQueue<a> Snoc(a x)
• public static class BatchedQueueModule
  • public static FSharpChoice<Tuple<a, BatchedQueue<a>>, Unit> |Cons|Nil|<a>(BatchedQueue<a> q)
  • public static BatchedQueue<a> empty<a>()
  • public static State fold<State, T>(FSharpFunc<State, FSharpFunc<T, State>> f, State state, BatchedQueue<T> q)
  • public static State foldBack<T, State>(FSharpFunc<T, FSharpFunc<State, State>> f, BatchedQueue<T> q, State state)
  • public static a head<a>(BatchedQueue<a> q)
  • public static bool isEmpty<a>(BatchedQueue<a> q)
  • public static int length<a>(BatchedQueue<a> q)
  • public static BatchedQueue<a> ofList<a>(FSharpList<a> xs)
  • public static BatchedQueue<a> ofSeq<a>(IEnumerable<a> xs)
  • public static BatchedQueue<a> rev<a>(BatchedQueue<a> q)
  • public static BatchedQueue<a> snoc<a>(a x, BatchedQueue<a> q)
  • public static BatchedQueue<a> tail<a>(BatchedQueue<a> q)
  • public static FSharpOption<a> tryGetHead<a>(BatchedQueue<a> q)
  • public static FSharpOption<BatchedQueue<a>> tryGetTail<a>(BatchedQueue<a> q)
  • public static FSharpOption<Tuple<a, BatchedQueue<a>>> tryUncons<a>(BatchedQueue<a> q)
  • public static Tuple<a, BatchedQueue<a>> uncons<a>(BatchedQueue<a> q)
• public class BinaryRandomAccessList<a> : IRandomAccessList<a>
  • public static FSharpFunc<Tuple<int, a, TreeBRAL<a>>, FSharpOption<TreeBRAL<a>>> tryUpdateTree { get; }
  • public static FSharpFunc<Tuple<int, a, TreeBRAL<a>>, TreeBRAL<a>> updateTree { get; }
  • public a Head { get; }
  • public bool IsEmpty { get; }
  • public int Length { get; }
  • public FSharpList<Digit<a>> randomAccessList { get; }
  • public BinaryRandomAccessList<a> Rev { get; }
  • public BinaryRandomAccessList<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<BinaryRandomAccessList<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, BinaryRandomAccessList<a>>> TryUncons { get; }
  • public Tuple<a, BinaryRandomAccessList<a>> Uncons { get; }
  • public BinaryRandomAccessList(FSharpList<Digit<a>> randomAccessList)
  • public static FSharpFunc<FSharpList<Digit<a>>, FSharpOption<FSharpList<Digit<a>>>> tryUpdate(int i, a y)
  • public static FSharpFunc<FSharpList<Digit<a>>, FSharpList<Digit<a>>> update(int i, a y)
  • public BinaryRandomAccessList<a> Cons(a x)
  • public a Lookup(int i)
  • public FSharpOption<a> TryLookup(int i)
  • public FSharpOption<BinaryRandomAccessList<a>> TryUpdate(int i, a y)
  • public BinaryRandomAccessList<a> Update(int i, a y)
• public static class BinaryRandomAccessListModule
  • public static FSharpChoice<Tuple<a, BinaryRandomAccessList<a>>, Unit> |Cons|Nil|<a>(BinaryRandomAccessList<a> l)
  • public static BinaryRandomAccessList<a> cons<a>(a x, BinaryRandomAccessList<a> xs)
  • public static BinaryRandomAccessList<a> empty<a>()
  • public static a head<a>(BinaryRandomAccessList<a> xs)
  • public static bool isEmpty<a>(BinaryRandomAccessList<a> xs)
  • public static int length<a>(BinaryRandomAccessList<a> xs)
  • public static a lookup<a>(int i, BinaryRandomAccessList<a> xs)
  • public static BinaryRandomAccessList<a> ofSeq<a>(IEnumerable<a> s)
  • public static BinaryRandomAccessList<a> rev<a>(BinaryRandomAccessList<a> xs)
  • public static BinaryRandomAccessList<a> tail<a>(BinaryRandomAccessList<a> xs)
  • public static FSharpOption<a> tryGetHead<a>(BinaryRandomAccessList<a> xs)
  • public static FSharpOption<BinaryRandomAccessList<a>> tryGetTail<a>(BinaryRandomAccessList<a> xs)
  • public static FSharpOption<a> tryLookup<a>(int i, BinaryRandomAccessList<a> xs)
  • public static FSharpOption<Tuple<a, BinaryRandomAccessList<a>>> tryUncons<a>(BinaryRandomAccessList<a> xs)
  • public static FSharpOption<BinaryRandomAccessList<a>> tryUpdate<a>(int i, a y, BinaryRandomAccessList<a> xs)
  • public static Tuple<a, BinaryRandomAccessList<a>> uncons<a>(BinaryRandomAccessList<a> xs)
  • public static BinaryRandomAccessList<a> update<a>(int i, a y, BinaryRandomAccessList<a> xs)
• public static class Deque
• public class Deque<a> : IEnumerable<a>, IDeque<a>
  • public a Head { get; }
  • public Deque<a> Init { get; }
  • public bool IsEmpty { get; }
  • public a Last { get; }
  • public int Length { get; }
  • public Deque<a> Rev { get; }
  • public Deque<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<Deque<a>> TryGetInit { get; }
  • public FSharpOption<a> TryGetLast { get; }
  • public FSharpOption<Deque<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, Deque<a>>> TryUncons { get; }
  • public FSharpOption<Tuple<Deque<a>, a>> TryUnsnoc { get; }
  • public Tuple<a, Deque<a>> Uncons { get; }
  • public Tuple<Deque<a>, a> Unsnoc { get; }
  • public Deque(FSharpList<a> front, FSharpList<a> rBack)
  • public Deque<a> Cons(a x)
  • public a Lookup(int i)
  • public Deque<a> Remove(int i)
  • public Deque<a> Snoc(a x)
  • public FSharpOption<a> TryLookup(int i)
  • public FSharpOption<Deque<a>> TryRemove(int i)
  • public FSharpOption<Deque<a>> TryUpdate(int i, a y)
  • public Deque<a> Update(int i, a y)
• public static class DequeModule
  • public static FSharpChoice<Tuple<a, Deque<a>>, Unit> |Cons|Nil|<a>(Deque<a> q)
  • public static FSharpChoice<Tuple<Deque<a>, a>, Unit> |Snoc|Nil|<a>(Deque<a> q)
  • public static Deque<a> cons<a>(a x, Deque<a> q)
  • public static Deque<a> empty<a>()
  • public static a head<a>(Deque<a> q)
  • public static Deque<a> init<a>(Deque<a> q)
  • public static bool isEmpty<a>(Deque<a> q)
  • public static a last<a>(Deque<a> q)
  • public static int length<a>(Deque<a> q)
  • public static a lookup<a>(int i, Deque<a> q)
  • public static Deque<a> ofCatLists<a>(FSharpList<a> xs, FSharpList<a> ys)
  • public static Deque<a> ofSeq<a>(IEnumerable<a> xs)
  • public static Deque<a> remove<a>(int i, Deque<a> q)
  • public static Deque<a> rev<a>(Deque<a> q)
  • public static Deque<a> singleton<a>(a x)
  • public static Deque<a> snoc<a>(a x, Deque<a> q)
  • public static Deque<a> tail<a>(Deque<a> q)
  • public static FSharpOption<a> tryGetHead<a>(Deque<a> q)
  • public static FSharpOption<Deque<a>> tryGetInit<a>(Deque<a> q)
  • public static FSharpOption<a> tryGetLast<a>(Deque<a> q)
  • public static FSharpOption<Deque<a>> tryGetTail<a>(Deque<a> q)
  • public static FSharpOption<a> tryLookup<a>(int i, Deque<a> q)
  • public static FSharpOption<Deque<a>> tryRemove<a>(int i, Deque<a> q)
  • public static FSharpOption<Tuple<a, Deque<a>>> tryUncons<a>(Deque<a> q)
  • public static FSharpOption<Tuple<Deque<a>, a>> tryUnsnoc<a>(Deque<a> q)
  • public static FSharpOption<Deque<a>> tryUpdate<a>(int i, a y, Deque<a> q)
  • public static Tuple<a, Deque<a>> uncons<a>(Deque<a> q)
  • public static Tuple<Deque<a>, a> unsnoc<a>(Deque<a> q)
  • public static Deque<a> update<a>(int i, a y, Deque<a> q)
• public abstract class Digit<a> : IEquatable<Digit<a>>, IStructuralEquatable, IComparable<Digit<a>>, IComparable, IStructuralComparable
  • public class One<a> : Digit<a>
  • public static class Tags<a>
  • public static Digit<a> Zero { get; }
  • public bool IsOne { get; }
  • public bool IsZero { get; }
  • public int Tag { get; }
  • public static Digit<a> NewOne(TreeBRAL<a> item)
• public class HoodMelvilleQueue<a> : IEnumerable<a>, IQueue<a>
  • public a Head { get; }
  • public bool IsEmpty { get; }
  • public int Length { get; }
  • public HoodMelvilleQueue<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<HoodMelvilleQueue<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, HoodMelvilleQueue<a>>> TryUncons { get; }
  • public Tuple<a, HoodMelvilleQueue<a>> Uncons { get; }
  • public HoodMelvilleQueue(int frontLength, FSharpList<a> front, RotationState<a> state, int rBackLength, FSharpList<a> rBack)
  • public HoodMelvilleQueue<a> Snoc(a x)
• public static class HoodMelvilleQueueModule
  • public static FSharpChoice<Tuple<a, HoodMelvilleQueue<a>>, Unit> |Cons|Nil|<a>(HoodMelvilleQueue<a> q)
  • public static HoodMelvilleQueue<a> empty<a>()
  • public static State fold<State, T>(FSharpFunc<State, FSharpFunc<T, State>> f, State state, HoodMelvilleQueue<T> q)
  • public static State foldBack<T, State>(FSharpFunc<T, FSharpFunc<State, State>> f, HoodMelvilleQueue<T> q, State state)
  • public static a head<a>(HoodMelvilleQueue<a> q)
  • public static bool isEmpty<a>(Unit unitVar0, HoodMelvilleQueue<a> q)
  • public static int length<a>(Unit unitVar0, HoodMelvilleQueue<a> q)
  • public static HoodMelvilleQueue<a> ofList<a>(IEnumerable<a> xs)
  • public static HoodMelvilleQueue<a> ofSeq<a>(IEnumerable<a> xs)
  • public static HoodMelvilleQueue<a> snoc<a>(a x, HoodMelvilleQueue<a> q)
  • public static HoodMelvilleQueue<a> tail<a>(HoodMelvilleQueue<a> q)
  • public static FSharpOption<a> tryGetHead<a>(HoodMelvilleQueue<a> q)
  • public static FSharpOption<HoodMelvilleQueue<a>> tryGetTail<a>(HoodMelvilleQueue<a> q)
  • public static FSharpOption<Tuple<a, HoodMelvilleQueue<a>>> tryUncons<a>(HoodMelvilleQueue<a> q)
  • public static Tuple<a, HoodMelvilleQueue<a>> uncons<a>(HoodMelvilleQueue<a> q)
• public static class Interfaces
  • public interface IHeap<a> : IEnumerable<a>, IEnumerable
  • public interface IHeap<c, a> : IHeap<a> where c : IHeap<c, a>
  • public interface IQueue<a> : IEnumerable<a>, IEnumerable
  • public interface IRandomAccessList<a> : IEnumerable<a>, IEnumerable
• public static class LazyList
• public static class LazyListHelpr
  • public static LazyList<a> lLdrop<a>(int n, LazyList<a> xs)
  • public static LazyList<a> lLrev<a>(LazyList<a> r)
  • public static Tuple<FSharpList<a>, LazyList<a>> lLsplit<a>(LazyList<a> ll, int n)
• public abstract class LeftistHeap<a> : IEquatable<LeftistHeap<a>>, IStructuralEquatable, IComparable<LeftistHeap<a>>, IComparable, IStructuralComparable, IHeap<LeftistHeap<a>, a>
  • public class E<a> : LeftistHeap<a>
  • public class T<a> : LeftistHeap<a>
  • public static class Tags<a>
  • public a Head { get; }
  • public bool IsE { get; }
  • public bool IsEmpty { get; }
  • public bool IsMaximalist { get; }
  • public bool IsT { get; }
  • public int Length { get; }
  • public int Tag { get; }
  • public LeftistHeap<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<LeftistHeap<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, LeftistHeap<a>>> TryUncons { get; }
  • public Tuple<a, LeftistHeap<a>> Uncons { get; }
  • public static LeftistHeap<a> NewE(bool item)
  • public static LeftistHeap<a> NewT(bool item1, int item2, int item3, a item4, LeftistHeap<a> item5, LeftistHeap<a> item6)
  • public LeftistHeap<a> Insert(a x)
  • public LeftistHeap<a> Merge(LeftistHeap<a> xs)
  • public FSharpOption<LeftistHeap<a>> TryMerge(LeftistHeap<a> xs)
• public static class LeftistHeapModule
  • public static FSharpChoice<Tuple<a, LeftistHeap<a>>, Unit> |Cons|Nil|<a>(LeftistHeap<a> h)
  • public static LeftistHeap<a> empty<a>(bool maximalist)
  • public static a head<a>(LeftistHeap<a> xs)
  • public static LeftistHeap<a> insert<a>(a x, LeftistHeap<a> xs)
  • public static bool isEmpty<a>(LeftistHeap<a> xs)
  • public static bool isMaximalist<a>(LeftistHeap<a> xs)
  • public static int length<a>(LeftistHeap<a> xs)
  • public static LeftistHeap<a> merge<a>(LeftistHeap<a> xs, LeftistHeap<a> ys)
  • public static LeftistHeap<a> ofSeq<a>(bool maximalist, IEnumerable<a> s)
  • public static LeftistHeap<a> tail<a>(LeftistHeap<a> xs)
  • public static FSharpOption<a> tryGetHead<a>(LeftistHeap<a> xs)
  • public static FSharpOption<LeftistHeap<a>> tryGetTail<a>(LeftistHeap<a> xs)
  • public static FSharpOption<LeftistHeap<a>> tryMerge<a>(LeftistHeap<a> xs, LeftistHeap<a> ys)
  • public static FSharpOption<Tuple<a, LeftistHeap<a>>> tryUncons<a>(LeftistHeap<a> xs)
  • public static Tuple<a, LeftistHeap<a>> uncons<a>(LeftistHeap<a> xs)
• public static class ListHelpr
  • public static Tuple<a[], FSharpList<a>> loop2Array<a>(a[] left, FSharpList<a> right, int _arg1)
  • public static FSharpList<a> loopFromArray<a>(int frontLen, a[] left, FSharpList<a> right, int _arg1)
• public class PhysicistQueue<a> : IEnumerable<a>, IQueue<a>
  • public a Head { get; }
  • public bool IsEmpty { get; }
  • public int Length { get; }
  • public PhysicistQueue<a> Rev { get; }
  • public PhysicistQueue<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<PhysicistQueue<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, PhysicistQueue<a>>> TryUncons { get; }
  • public Tuple<a, PhysicistQueue<a>> Uncons { get; }
  • public PhysicistQueue(FSharpList<a> prefix, int frontLength, Lazy<FSharpList<a>> front, int rBackLength, FSharpList<a> rBack)
  • public PhysicistQueue<a> Snoc(a x)
• public static class PhysicistQueueModule
  • public static FSharpChoice<Tuple<a, PhysicistQueue<a>>, Unit> |Cons|Nil|<a>(PhysicistQueue<a> q)
  • public static PhysicistQueue<a> empty<a>()
  • public static State fold<State, T>(FSharpFunc<State, FSharpFunc<T, State>> f, State state, PhysicistQueue<T> q)
  • public static State foldBack<T, State>(FSharpFunc<T, FSharpFunc<State, State>> f, PhysicistQueue<T> q, State state)
  • public static a head<a>(PhysicistQueue<a> q)
  • public static bool isEmpty<a>(PhysicistQueue<a> q)
  • public static int length<a>(PhysicistQueue<a> q)
  • public static PhysicistQueue<a> ofList<a>(FSharpList<a> xs)
  • public static PhysicistQueue<a> ofSeq<a>(IEnumerable<a> xs)
  • public static PhysicistQueue<a> rev<a>(PhysicistQueue<a> q)
  • public static PhysicistQueue<a> snoc<a>(a x, PhysicistQueue<a> q)
  • public static PhysicistQueue<a> tail<a>(PhysicistQueue<a> q)
  • public static FSharpOption<a> tryGetHead<a>(PhysicistQueue<a> q)
  • public static FSharpOption<PhysicistQueue<a>> tryGetTail<a>(PhysicistQueue<a> q)
  • public static FSharpOption<Tuple<a, PhysicistQueue<a>>> tryUncons<a>(PhysicistQueue<a> q)
  • public static Tuple<a, PhysicistQueue<a>> uncons<a>(PhysicistQueue<a> q)
• public static class RealTimeDeque
  • public class RealTimeDeque<a> : IEnumerable<a>, IDeque<a>
  • public static FSharpChoice<Tuple<a, RealTimeDeque<a>>, Unit> |Cons|Nil|<a>(RealTimeDeque<a> q)
  • public static FSharpChoice<Tuple<RealTimeDeque<a>, a>, Unit> |Snoc|Nil|<a>(RealTimeDeque<a> q)
  • public static RealTimeDeque<a> append<a>(RealTimeDeque<a> xs, RealTimeDeque<a> ys)
  • public static RealTimeDeque<a> appendC<a>(int c, RealTimeDeque<a> xs, RealTimeDeque<a> ys)
  • public static RealTimeDeque<a> cons<a>(a x, RealTimeDeque<a> q)
  • public static RealTimeDeque<a> empty<a>(int c)
  • public static a head<a>(RealTimeDeque<a> q)
  • public static RealTimeDeque<a> init<a>(RealTimeDeque<a> q)
  • public static bool isEmpty<a>(RealTimeDeque<a> q)
  • public static a last<a>(RealTimeDeque<a> q)
  • public static int length<a>(RealTimeDeque<a> q)
  • public static a lookup<a>(int i, RealTimeDeque<a> q)
  • public static RealTimeDeque<a> ofCatLists<a>(FSharpList<a> xs, FSharpList<a> ys)
  • public static RealTimeDeque<a> ofCatListsC<a>(int c, FSharpList<a> xs, FSharpList<a> ys)
  • public static RealTimeDeque<a> ofCatSeqs<a>(IEnumerable<a> xs, IEnumerable<a> ys)
  • public static RealTimeDeque<a> ofCatSeqsC<a>(int c, IEnumerable<a> xs, IEnumerable<a> ys)
  • public static RealTimeDeque<a> ofSeq<a>(IEnumerable<a> xs)
  • public static RealTimeDeque<a> ofSeqC<a>(int c, IEnumerable<a> xs)
  • public static RealTimeDeque<a> remove<a>(int i, RealTimeDeque<a> q)
  • public static RealTimeDeque<a> rev<a>(RealTimeDeque<a> q)
  • public static RealTimeDeque<a> singleton<a>(a x)
  • public static RealTimeDeque<a> singletonC<a>(int c, a x)
  • public static RealTimeDeque<a> snoc<a>(a x, RealTimeDeque<a> q)
  • public static RealTimeDeque<a> tail<a>(RealTimeDeque<a> q)
  • public static FSharpOption<a> tryLookup<a>(int i, RealTimeDeque<a> q)
  • public static FSharpOption<RealTimeDeque<a>> tryRemove<a>(int i, RealTimeDeque<a> q)
  • public static FSharpOption<RealTimeDeque<a>> tryUpdate<a>(int i, a y, RealTimeDeque<a> q)
  • public static Tuple<a, RealTimeDeque<a>> uncons<a>(RealTimeDeque<a> q)
  • public static Tuple<RealTimeDeque<a>, a> unsnoc<a>(RealTimeDeque<a> q)
  • public static RealTimeDeque<a> update<a>(int i, a y, RealTimeDeque<a> q)
  • public static FSharpChoice<Tuple<a, RealTimeDeque<a>>, Unit> |Cons|Nil|<a>(RealTimeDeque<a> q)
  • public static FSharpChoice<Tuple<RealTimeDeque<a>, a>, Unit> |Snoc|Nil|<a>(RealTimeDeque<a> q)
  • public static RealTimeDeque<a> append<a>(RealTimeDeque<a> xs, RealTimeDeque<a> ys)
  • public static RealTimeDeque<a> appendC<a>(int c, RealTimeDeque<a> xs, RealTimeDeque<a> ys)
  • public static RealTimeDeque<a> cons<a>(a x, RealTimeDeque<a> q)
  • public static RealTimeDeque<a> empty<a>(int c)
  • public static a head<a>(RealTimeDeque<a> q)
  • public static RealTimeDeque<a> init<a>(RealTimeDeque<a> q)
  • public static bool isEmpty<a>(RealTimeDeque<a> q)
  • public static a last<a>(RealTimeDeque<a> q)
  • public static int length<a>(RealTimeDeque<a> q)
  • public static a lookup<a>(int i, RealTimeDeque<a> q)
  • public static RealTimeDeque<a> ofCatLists<a>(FSharpList<a> xs, FSharpList<a> ys)
  • public static RealTimeDeque<a> ofCatListsC<a>(int c, FSharpList<a> xs, FSharpList<a> ys)
  • public static RealTimeDeque<a> ofCatSeqs<a>(IEnumerable<a> xs, IEnumerable<a> ys)
  • public static RealTimeDeque<a> ofCatSeqsC<a>(int c, IEnumerable<a> xs, IEnumerable<a> ys)
  • public static RealTimeDeque<a> ofSeq<a>(IEnumerable<a> xs)
  • public static RealTimeDeque<a> ofSeqC<a>(int c, IEnumerable<a> xs)
  • public static RealTimeDeque<a> remove<a>(int i, RealTimeDeque<a> q)
  • public static RealTimeDeque<a> rev<a>(RealTimeDeque<a> q)
  • public static RealTimeDeque<a> singleton<a>(a x)
  • public static RealTimeDeque<a> singletonC<a>(int c, a x)
  • public static RealTimeDeque<a> snoc<a>(a x, RealTimeDeque<a> q)
  • public static RealTimeDeque<a> tail<a>(RealTimeDeque<a> q)
  • public static FSharpOption<a> tryGetHead<a>(RealTimeDeque<a> q)
  • public static FSharpOption<RealTimeDeque<a>> tryGetInit<a>(RealTimeDeque<a> q)
  • public static FSharpOption<a> tryGetLast<a>(RealTimeDeque<a> q)
  • public static FSharpOption<RealTimeDeque<a>> tryGetTail<a>(RealTimeDeque<a> q)
  • public static FSharpOption<a> tryLookup<a>(int i, RealTimeDeque<a> q)
  • public static FSharpOption<RealTimeDeque<a>> tryRemove<a>(int i, RealTimeDeque<a> q)
  • public static FSharpOption<Tuple<a, RealTimeDeque<a>>> tryUncons<a>(RealTimeDeque<a> q)
  • public static FSharpOption<Tuple<RealTimeDeque<a>, a>> tryUnsnoc<a>(RealTimeDeque<a> q)
  • public static FSharpOption<RealTimeDeque<a>> tryUpdate<a>(int i, a y, RealTimeDeque<a> q)
  • public static Tuple<a, RealTimeDeque<a>> uncons<a>(RealTimeDeque<a> q)
  • public static Tuple<RealTimeDeque<a>, a> unsnoc<a>(RealTimeDeque<a> q)
  • public static RealTimeDeque<a> update<a>(int i, a y, RealTimeDeque<a> q)
• public class RealTimeDeque<a> : IEnumerable<a>, IDeque<a>
  • public a Head { get; }
  • public RealTimeDeque<a> Init { get; }
  • public bool IsEmpty { get; }
  • public a Last { get; }
  • public int Length { get; }
  • public RealTimeDeque<a> Rev { get; }
  • public RealTimeDeque<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<RealTimeDeque<a>> TryGetInit { get; }
  • public FSharpOption<a> TryGetLast { get; }
  • public FSharpOption<RealTimeDeque<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, RealTimeDeque<a>>> TryUncons { get; }
  • public FSharpOption<Tuple<RealTimeDeque<a>, a>> TryUnsnoc { get; }
  • public Tuple<a, RealTimeDeque<a>> Uncons { get; }
  • public Tuple<RealTimeDeque<a>, a> Unsnoc { get; }
  • public RealTimeDeque(int c, int frontLength, LazyList<a> front, LazyList<a> streamFront, int rBackLength, LazyList<a> rBack, LazyList<a> streamRBack)
  • public RealTimeDeque<a> Cons(a x)
  • public a Lookup(int i)
  • public RealTimeDeque<a> Remove(int i)
  • public RealTimeDeque<a> Snoc(a x)
  • public FSharpOption<a> TryLookup(int i)
  • public FSharpOption<RealTimeDeque<a>> TryRemove(int i)
  • public FSharpOption<RealTimeDeque<a>> TryUpdate(int i, a y)
  • public RealTimeDeque<a> Update(int i, a y)
• public sealed class RoseTree<a> : IEquatable<RoseTree<a>>
  • public LazyList<RoseTree<a>> Children { get; }
  • public a Root { get; }
  • public RoseTree(a root, LazyList<RoseTree<a>> children)
• public static class RoseTreeModule
  • public static RoseTree<b> ap<a, b>(RoseTree<a> x, RoseTree<FSharpFunc<a, b>> f)
  • public static RoseTree<b> bind<a, b>(FSharpFunc<a, RoseTree<b>> f, RoseTree<a> x)
  • public static RoseTree<a> create<a>(a root, LazyList<RoseTree<a>> children)
  • public static IEnumerable<a> DfsPost<a>(this RoseTree<a> x)
  • public static IEnumerable<a> DfsPre<a>(this RoseTree<a> x)
  • public static RoseTree<c> lift2<a, b, c>(FSharpFunc<a, FSharpFunc<b, c>> f, RoseTree<a> a, RoseTree<b> b)
  • public static RoseTree<b> map<a, b>(FSharpFunc<a, b> f, RoseTree<a> x)
  • public static RoseTree<a> singleton<a>(a x)
  • public static RoseTree<b> unfold<a, b>(FSharpFunc<a, Tuple<b, LazyList<a>>> f, a seed)
  • public static FSharpFunc<LazyList<a>, LazyList<RoseTree<b>>> unfoldForest<a, b>(FSharpFunc<a, Tuple<b, LazyList<a>>> f)
• public class RotationState<a> : IEquatable<RotationState<a>>, IStructuralEquatable, IComparable<RotationState<a>>, IComparable, IStructuralComparable
  • public class Appending<a> : RotationState<a>
  • public class Done<a> : RotationState<a>
  • public class Reversing<a> : RotationState<a>
  • public static class Tags<a>
  • public static RotationState<a> Idle { get; }
  • public bool IsAppending { get; }
  • public bool IsDone { get; }
  • public bool IsIdle { get; }
  • public bool IsReversing { get; }
  • public int Tag { get; }
  • public static RotationState<a> NewAppending(int item1, FSharpList<a> item2, FSharpList<a> item3)
  • public static RotationState<a> NewDone(FSharpList<a> item)
  • public static RotationState<a> NewReversing(int item1, FSharpList<a> item2, FSharpList<a> item3, FSharpList<a> item4, FSharpList<a> item5)
• public class SkewBinaryRandomAccessList<a> : IRandomAccessList<a>
  • public static FSharpFunc<Tuple<int, int, a, TreeSBRAL<a>>, FSharpOption<TreeSBRAL<a>>> tryUpdateTree { get; }
  • public static FSharpFunc<Tuple<int, int, a, TreeSBRAL<a>>, TreeSBRAL<a>> updateTree { get; }
  • public a Head { get; }
  • public bool IsEmpty { get; }
  • public int Length { get; }
  • public FSharpList<Tuple<int, TreeSBRAL<a>>> randomAccessList { get; }
  • public SkewBinaryRandomAccessList<a> Rev { get; }
  • public SkewBinaryRandomAccessList<a> Tail { get; }
  • public FSharpOption<a> TryGetHead { get; }
  • public FSharpOption<SkewBinaryRandomAccessList<a>> TryGetTail { get; }
  • public FSharpOption<Tuple<a, SkewBinaryRandomAccessList<a>>> TryUncons { get; }
  • public Tuple<a, SkewBinaryRandomAccessList<a>> Uncons { get; }
  • public SkewBinaryRandomAccessList(FSharpList<Tuple<int, TreeSBRAL<a>>> randomAccessList)
  • public static FSharpFunc<FSharpList<Tuple<int, TreeSBRAL<a>>>, FSharpOption<FSharpList<Tuple<int, TreeSBRAL<a>>>>> tryUpdate(int i, a y)
  • public static FSharpFunc<FSharpList<Tuple<int, TreeSBRAL<a>>>, FSharpList<Tuple<int, TreeSBRAL<a>>>> update(int i, a y)
  • public SkewBinaryRandomAccessList<a> Cons(a x)
  • public a Lookup(int i)
  • public FSharpOption<a> TryLookup(int i)
  • public FSharpOption<SkewBinaryRandomAccessList<a>> TryUpdate(int i, a y)
  • public SkewBinaryRandomAccessList<a> Update(int i, a y)
• public static class SkewBinaryRandomAccessListModule
  • public static FSharpChoice<Tuple<a, SkewBinaryRandomAccessList<a>>, Unit> |Cons|Nil|<a>(SkewBinaryRandomAccessList<a> l)
  • public static SkewBinaryRandomAccessList<a> cons<a>(a x, SkewBinaryRandomAccessList<a> xs)
  • public static SkewBinaryRandomAccessList<a> empty<a>()
  • public static a head<a>(SkewBinaryRandomAccessList<a> xs)
  • public static bool isEmpty<a>(SkewBinaryRandomAccessList<a> xs)
  • public static int length<a>(SkewBinaryRandomAccessList<a> xs)
  • public static a lookup<a>(int i, SkewBinaryRandomAccessList<a> xs)
  • public static SkewBinaryRandomAccessList<a> ofSeq<a>(IEnumerable<a> s)
  • public static SkewBinaryRandomAccessList<a> rev<a>(SkewBinaryRandomAccessList<a> xs)
  • public static SkewBinaryRandomAccessList<a> tail<a>(SkewBinaryRandomAccessList<a> xs)
  • public static FSharpOption<a> tryGetHead<a>(SkewBinaryRandomAccessList<a> xs)
  • public static FSharpOption<SkewBinaryRandomAccessList<a>> tryGetTail<a>(SkewBinaryRandomAccessList<a> xs)
  • public static FSharpOption<a> tryLookup<a>(int i, SkewBinaryRandomAccessList<a> xs)
  • public static FSharpOption<Tuple<a, SkewBinaryRandomAccessList<a>>> tryUncons<a>(SkewBinaryRandomAccessList<a> xs)
  • public static FSharpOption<SkewBinaryRandomAccessList<a>> tryUpdate<a>(int i, a y, SkewBinaryRandomAccessList<a> xs)
  • public static Tuple<a, SkewBinaryRandomAccessList<a>> uncons<a>(SkewBinaryRandomAccessList<a> xs)
  • public static SkewBinaryRandomAccessList<a> update<a>(int i, a y, SkewBinaryRandomAccessList<a> xs)
• public abstract class TreeBRAL<a> : IEquatable<TreeBRAL<a>>, IStructuralEquatable, IComparable<TreeBRAL<a>>, IComparable, IStructuralComparable
  • public class Leaf<a> : TreeBRAL<a>
  • public class Node<a> : TreeBRAL<a>
  • public static class Tags<a>
  • public bool IsLeaf { get; }
  • public bool IsNode { get; }
  • public int Tag { get; }
  • public static TreeBRAL<a> NewLeaf(a item)
  • public static TreeBRAL<a> NewNode(int item1, TreeBRAL<a> item2, TreeBRAL<a> item3)
• public abstract class TreeSBRAL<a> : IEquatable<TreeSBRAL<a>>, IStructuralEquatable, IComparable<TreeSBRAL<a>>, IComparable, IStructuralComparable
  • public class Leaf<a> : TreeSBRAL<a>
  • public class Node<a> : TreeSBRAL<a>
  • public static class Tags<a>
  • public bool IsLeaf { get; }
  • public bool IsNode { get; }
  • public int Tag { get; }
  • public static TreeSBRAL<a> NewLeaf(a item)
  • public static TreeSBRAL<a> NewNode(a item1, TreeSBRAL<a> item2, TreeSBRAL<a> item3)