unisonweb/unison
1
0
Fork 0
mirror of https://github.com/unisonweb/unison.git synced 2024-09-11 10:35:57 +03:00
Code Issues Projects Releases Wiki Activity
trunk
unison/unison-src/transcripts/doc-formatting.md

255 lines
6.1 KiB
Markdown
Raw Permalink Normal View History

#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
This transcript explains a few minor details about doc parsing and pretty-printing, both from a user point of view and with some implementation notes. The later stuff is meant more as unit testing than for human consumption. (The ucm `add` commands and their output are hidden for brevity.)
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
\:] to escape :] in doc literals
2019-11-30 18:58:31 +03:00
Docs can be used as inline code comments.
Add Author and License metadata types to builtins (#1228) * Fix #1056 and add author and license metadata types * Transcript demonstrating that the codebase is empty at first
2020-02-13 18:59:53 +03:00
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> builtins.merge
Add Author and License metadata types to builtins (#1228) * Fix #1056 and add author and license metadata types * Transcript demonstrating that the codebase is empty at first
2020-02-13 18:59:53 +03:00
```
\:] to escape :] in doc literals
2019-11-30 18:58:31 +03:00
```unison
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
foo : Nat -> Nat
foo n =
update transcripts
2022-12-02 08:51:11 +03:00
_ = [: do the thing :]
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
n + 1
\:] to escape :] in doc literals
2019-11-30 18:58:31 +03:00
```
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view foo
\:] to escape :] in doc literals
2019-11-30 18:58:31 +03:00
```
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
Note that `@` and `:]` must be escaped within docs.
\:] to escape :] in doc literals
2019-11-30 18:58:31 +03:00
```unison
escaping = [: Docs look [: like \@this \:] :]
```
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view escaping
\:] to escape :] in doc literals
2019-11-30 18:58:31 +03:00
```
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
(Alas you can't have `\@` or `\:]` in your doc, as there's currently no way to 'unescape' them.)
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```unison
-- Note that -- comments are preserved within doc literals.
commented = [:
example:
#936 pretty-print doc literals - small fix
2020-01-17 00:50:25 +03:00
-- a comment
f x = x + 1
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
:]
```
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view commented
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
### Indenting, and paragraph reflow
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
Handling of indenting in docs between the parser and pretty-printer is a bit fiddly.
```unison
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
-- The leading and trailing spaces are stripped from the stored Doc by the
-- lexer, and one leading and trailing space is inserted again on view/edit
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
-- by the pretty-printer.
doc1 = [: hi :]
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view doc1
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
```unison
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
-- Lines (apart from the first line, i.e. the bit between the [: and the
-- first newline) are unindented until at least one of
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
-- them hits the left margin (by a post-processing step in the parser).
-- You may not notice this because the pretty-printer indents them again on
-- view/edit.
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
doc2 = [: hello
- foo
- bar
and the rest. :]
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view doc2
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```unison
doc3 = [: When Unison identifies a paragraph, it removes any newlines from it before storing it, and then reflows the paragraph text to fit the display window on display/view/edit.
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
For these purposes, a paragraph is any sequence of non-empty lines that have zero indent (after the unindenting mentioned above.)
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
- So this is not a paragraph, even
though you might want it to be.
And this text | as a paragraph
is not treated | either.
Note that because of the special treatment of the first line mentioned above, where its leading space is removed, it is always treated as a paragraph.
:]
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
```
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view doc3
#936 pretty-print doc literals - unindent docs after parsing - unfinished Causes some bogus changes to docs.output.md which I need to debug.
2019-12-14 21:15:32 +03:00
```
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```unison
doc4 = [: Here's another example of some paragraphs.
\:] to escape :] in doc literals
2019-11-30 18:58:31 +03:00
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
All these lines have zero indent.
\:] to escape :] in doc literals
2019-11-30 18:58:31 +03:00
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
- Apart from this one. :]
```
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view doc4
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
\:] to escape :] in doc literals
2019-11-30 18:58:31 +03:00
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```unison
-- The special treatment of the first line does mean that the following
-- is pretty-printed not so prettily. To fix that we'd need to get the
-- lexer to help out with interpreting doc literal indentation (because
-- it knows what columns the `[:` was in.)
doc5 = [: - foo
- bar
and the rest. :]
```
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view doc5
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
```unison
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
-- You can do the following to avoid that problem.
doc6 = [:
- foo
- bar
and the rest.
:]
```
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view doc6
#936 pretty-print doc literals - spec out modified paragraph reflow/wrapping Currently Unison takes doc literals like [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] and renders them as [: example usage: - note the call to bar - we pass it 1 foo = bar 1 baz :] due to the paragraph reflow/wrapping function. Also, this function only works the first time you use it on a doc: if you `edit` a doc and mess with it, you won't get the wrapping refreshed the next time you view. That's because the pretty-printing works by inserting newlines, which are treated as paragraph breaks by Unison the next time it sees the code. I'm planning to fix this by - only doing paragraph reflow/wrapping for lines with zero indent (where zero is the left-most non-whitespace column of the doc) - normalizing docs during parse, including removing newlines that are within a paragraph. See unison-src/transcripts/doc-formatting.md in this commit for more details of how this shakes out. Not the .md.output because that's showing the current behavior without this change implemented. Hopefully this is just a few more lines of code to implement, and then #936/#994 is good to merge.
2019-12-17 02:32:36 +03:00
```
#936 pretty-print doc literals - draft of parse-time doc normalization - needs debugging
2019-12-22 01:07:11 +03:00
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
### More testing
```unison
-- Check empty doc works.
#936 pretty-print doc literals - draft of parse-time doc normalization - needs debugging
2019-12-22 01:07:11 +03:00
empty = [::]
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
expr = foo 1
#936 pretty-print doc literals - draft of parse-time doc normalization - needs debugging
2019-12-22 01:07:11 +03:00
```
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - draft of parse-time doc normalization - needs debugging
2019-12-22 01:07:11 +03:00
```
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view empty
#936 pretty-print doc literals - draft of parse-time doc normalization - needs debugging
2019-12-22 01:07:11 +03:00
```
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
```unison
test1 = [:
The internal logic starts to get hairy when you use the \@ features, for example referencing a name like @List.take. Internally, the text between each such usage is its own blob (blob ends here --> @List.take), so paragraph reflow has to be aware of multiple blobs to do paragraph reflow (or, more accurately, to do the normalization step where newlines with a paragraph are removed.)
Para to reflow: lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor ending in ref @List.take
@List.take starting para lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor.
Middle of para: lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor @List.take lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor.
- non-para line (@List.take) with ref @List.take
Another non-para line
@List.take starting non-para line
- non-para line with ref @List.take
before a para-line lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor.
- non-para line followed by a para line starting with ref
@List.take lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor.
a para-line ending with ref lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor @List.take
- non-para line
para line lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor lorem ipsum dolor
@List.take followed by non-para line starting with ref.
@[signature] List.take
@[source] foo
@[evaluate] expr
@[include] doc1
stop doc literal normalization unindenting lines that start with @[...]
2020-01-26 18:51:11 +03:00
-- note the leading space below
@[signature] List.take
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
:]
```
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view test1
#936 pretty-print doc literals - last tests and fixes
2020-01-17 00:55:41 +03:00
```
Part of a fix for #1363 - preservation of spaces after @ directives in first line when unindenting Still need to dig into impact on docs.output.md.
2020-03-17 02:06:17 +03:00
```unison
-- Regression test for #1363 - preservation of spaces after @ directives in first line when unindenting
reg1363 = [: `@List.take foo` bar
baz :]
```
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
Part of a fix for #1363 - preservation of spaces after @ directives in first line when unindenting Still need to dig into impact on docs.output.md.
2020-03-17 02:06:17 +03:00
```
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view reg1363
Part of a fix for #1363 - preservation of spaces after @ directives in first line when unindenting Still need to dig into impact on docs.output.md.
2020-03-17 02:06:17 +03:00
```
Another fix to doc literal whitespace handling Stop eating spaces that immediately follow @[source], @[evaluate] or @[include] directives on the same line, while unindenting. Also fix docs.md so its example isn't asking for line-wrapping.
2020-04-13 19:27:58 +03:00
```unison
-- Demonstrate doc display when whitespace follows a @[source] or @[evaluate]
-- whose output spans multiple lines.
test2 = [:
Take a look at this:
@[source] foo ▶ bar
:]
```
```ucm:hide
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> add
Another fix to doc literal whitespace handling Stop eating spaces that immediately follow @[source], @[evaluate] or @[include] directives on the same line, while unindenting. Also fix docs.md so its example isn't asking for line-wrapping.
2020-04-13 19:27:58 +03:00
```
View is fine.
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> view test2
Another fix to doc literal whitespace handling Stop eating spaces that immediately follow @[source], @[evaluate] or @[include] directives on the same line, while unindenting. Also fix docs.md so its example isn't asking for line-wrapping.
2020-04-13 19:27:58 +03:00
```
But note it's not obvious how display should best be handling this. At the moment it just does the simplest thing:
```ucm
Replace '.' references with scratch/main
2024-06-12 01:22:09 +03:00
scratch/main> display test2
Another fix to doc literal whitespace handling Stop eating spaces that immediately follow @[source], @[evaluate] or @[include] directives on the same line, while unindenting. Also fix docs.md so its example isn't asking for line-wrapping.
2020-04-13 19:27:58 +03:00
```
Reference in New Issue Copy Permalink