Variable foldsConst

Type Declaration

• allLeaves: TreeFolderK<NonEmptyArrayTypeLambda>

• arrays: TreeFolderK<TreeArrayLambda>

• boolean: (M: Monoid<boolean>) => <A>(predicate: Predicate<A>) => TreeFolder<A, boolean>

• countOf: <A>(predicate: Predicate<A>) => TreeFolder<A, number>

• degree: TreeFolderOf<number>

• descendantCount: TreeFolderOf<number>

• edges: TreeFolderK<EdgeListTypeLambda>

• eqv: BooleanFolder

• every: BooleanFolder

• filterLeaves: <A>(predicate: Predicate<A>) => TreeFolder<A, Tree<A>>

• filterNodes: <A>(predicate: Predicate<Tree<A>>) => TreeFolder<A, Tree<A>>

• flatten: <A>(self: TreeF.TreeF<Tree<A>, Tree<A>>) => Tree<A>

• growLeaves: <A>(grow: TreeUnfold<A, A>) => TreeFolder<A, Tree<A>>

• includes: <A>(equals: Equivalence<A>) => (needle: A) => TreeFolder<A, boolean>

• levels: <A>(
      self: TreeF.TreeF<A, [[A, ...A[]], ...[A, ...A[]][]]>,
  ) => [[A, ...A[]], ...[A, ...A[]][]]

• maximumDegree: TreeFolderOf<number>

• maximumHeight: TreeFolderOf<number>

• monoid: <A>(M: Monoid<A>) => TreeFolder<A, A>

• nodeOrdinalFold: TreeFolderOf<number>

• numericMax: TreeFolder<number, number>

• numericMin: TreeFolder<number, number>

• numericProduct: TreeFolder<number, number>

• numericSum: TreeFolder<number, number>

• paths: TreeFolderK<NonEmptyArray2TypeLambda>

• postOrder: TreeFolderK<NonEmptyArrayTypeLambda>

• predicate: (M: Monoid<boolean>) => <A>(predicate: Predicate<A>) => TreeFolder<A, boolean>

• preOrder: TreeFolderK<NonEmptyArrayTypeLambda>

• some: BooleanFolder

• unzip: <A, B>(t: TreeF.TreeF<[A, B], [Tree<A>, Tree<B>]>) => [Tree<A>, Tree<B>]

• unzipTheseFold: <A, B>(
      self: TreeF.TreeF<These.These<A, B>, These.These<Tree<A>, Tree<B>>>,
  ) => These.These<Tree<A>, Tree<B>>

  Unzip a single level in a tree of These<A, B> into a pair of potentially non-congruent optional trees of type A and B.

• xor: BooleanFolder