Enum libzettels::SequenceStart

pub enum SequenceStart {
    RootOnly,
    Keyword,
    Fork,
    KeywordAndFork,
    KeywordOrFork,
}

User configuration that defines which zettels should be considered as the start of a sequence.

What's a sequence?

One feature that distinguishes a Zettelkasten from other hypertext systems is that it has sequences that are defined by the cascade of followup zettels who have followups of their own. A sequence can be compared to a "line of thought" or an argumentation. For example, consider this abstract description of a line of thought:

A problem
└── Considerations of the problem
    └──  An approach to a solution
        └──  Implications of this approach  

If each step in this line of thought is a zettel, each designating the next zettel as a followup, then the whole is a sequence.

In this example, the question which zettel is to be considered the start of the sequence is trivial: it's the first one, the "root" of the sequence.

But sometimes one line of thought leads to another. It branches or specializes:

A problem
└── Considerations of the problem
    └──  An approach to a solution
        └──  Implications of this approach  
└── A different perspective of the problem
    └──  A different approach to a solution
        └──  Implications of this other approach

One could consider the two followups of the sequence root to be the beginning of new sequences.

Sequences in libzettels

To identify a sequence, libzettel uses the path to the zettel that is the start of said sequence. To do this, libzettels needs criteria to determine whether to consider a zettel the start of a new sequence or not. That's the intended use of keywords in a Zettel. However, different users might handle their Zettelkasten differently and might apply keywords in different manners. To reflect this, SequenceStart is a part of Config.

A sequence root (i.e. a zettel that is not designated by another zettel as a followup) is always considered the start of a sequence. How other zettels are treated is set by the variants of SequenceStart.

Variants

RootOnly

No other zettels are considered to be the start of a sequence, only sequence roots (i.e. "orphans", zettels that are not designated by another zettel as a followup).

Keyword

Default

In addition to sequence roots, zettels are considered to be the start of a sequence if they have a keyword. This is the default behaviour.

Fork

In addition to sequence roots, zettels are considered to be the start of a sequence if they are not the only followup of their predecessor in a sequence, thus forming a "fork" or branch.

KeywordAndFork

In addition to sequence roots, zettels are considered to be the start of a sequence if they are not the only followup of their predecessor in a sequence AND have a keyword.

KeywordOrFork

In addition to sequence roots, zettels are considered to be the start of a sequence if they are not the only followup of their predecessor in a sequence OR have a keyword.

Trait Implementations

impl Debug for SequenceStart

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SequenceStart

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<SequenceStart> for SequenceStart

fn eq(&self, other: &SequenceStart) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Serialize for SequenceStart

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SequenceStart