Space Case Book Pages

[Eliecer Brathwaite]

Id like to create a personal space in Confluence, but I'd like to use it similarly to how I use Google Drive. The space should be private, so that only I can see/access it, but I would like to be able to share any page with specific users.

For example, I might have a proposal for a new product or feature in this space. I don't want to share it with the rest of the company, but I might grant view/edit permissions to the product manager to get their input and/or edit the page collaboratively.

Once you want to share a page with someone, you go in "Space Tools > Reorder pages" and you move the page you want to share on the top of your homepage, so the page doesn't inherit from the restriction anymore. Then you can create new restrictions on this page and just share the link of this page. What is also nice it's that the person won't access to the tree view and won't be able to browse other pages, especially the ones that you share with

Then you can create new restrictions on this orphan page and just share the link of this page. What is also nice it's that the person won't have access to the tree view and won't be able to browse other pages, especially the ones that you share with other people as they won't even appear in the tree view (as they will be orphean).

This is awesome. I'm new to confluence. I notice that when using this method I can't access the pages above the homepage - the page becomes orphaned. Either in pages link in sidebar or in page tree in homepage (this makes sense since macro only shows sub pages). I've found a macro to include page tree for all pages in a space. This might work. How have you got around the issue of linking to pages above home page?

Good catch Mike. The principle of the solution I described upthere was especially to not link to the pages that are orphaned, so it worked for Phoenix but in your use case, the solution you found it great

While this pitch doesn't support an explicit spelling for "this type doesn't have any internal cases right now, but it may add them in the future, so you can't match on it exhaustively" for non-resilient libraries, you could hypothetically mimic this using an extra case, say internal case reserved (which is a little bit tedious, but Rust libraries did use this pattern until Rust added first-class support for marking enums using #[non_exhaustive] ).

My preference would be to add the notion of non-exhaustive, non-resilient enums first, then add non-public cases as a feature built on top of that. It makes the user model simpler - rather than saying that only enums with non-public cases are not exhaustive, we introduce the idea that some enums cannot be exhaustively switched for "some reason" (which may be due to non-public cases, or for any other reason).

I would guess that most people who would use this feature would be using it to block exhaustive switching for regular-old API evolution. It would be nice if we could just do that instead of tiptoeing towards the obvious while having developers write clunky code in the mean time.

My preference would be to add the notion of non-exhaustive, non-resilient enums first , then add non-public cases as a feature built on top of that. It makes the user model simpler - rather than saying that only enums with non-public cases are not exhaustive, we introduce the idea that some enums cannot be exhaustively switched for "some reason"

where pattern-matching on E values would be exhaustive inside the module (you have access to case f so you can see that f exists but you don't need to match on it due to Never) but non-exhaustive outside it (from the outside, E has some non-public case, so matching is non-exhaustive).

I'm not saying we should necessarily adopt this, but that's one alternative. If we choose that alternative, having a separate mechanism for non-exhaustive non-resilient enums is pure sugar and (arguably?) not necessary.

Given that there are two alternatives, one of which (arguably?) cleanly describes non-exhaustive enums, my current thinking is to wait for the discussion to settle down for a bit before considering adding another pitch as a dependency.

As you saw, in Cory's pitch Extensible Enumerations for Non-Resilient Libraries, the idea of "version-locked dependencies" came up where potentially the enum could be exhaustive for a set of modules which are "version-locked" and non-exhaustive outside it. I don't want to go too much into the weeds here, but something like that could fit into a more general access control model (strawman syntax):

If you want to add @nonExhaustive as a mechanism for governing where the exhaustivity-relation of cases is visible, you'd even be able to select @nonExhaustive(module) vs @nonExhaustive(workspace). [I don't want to derail this thread by discussing a more general access control model further, if you want to discuss it, let's do that over DM or in a new thread. ]

There's also the question about should this be an attribute or should the defaults be changed/warnings be added to remove the language dialect. That's a much more difficult question to answer... I don't have a good sense for what solution the core team would like to see here.

I understand what you're saying about adding non-exhaustive non-resilient enums first. However, I think that if we have some low-hanging fruit -- in terms of getting rough consensus from Swift developers and approval from the core team -- that can improve QoL for people, there's a good argument to be made that we should pick the low-hanging fruit first, instead of tackling the bigger challenge.

where pattern-matching on E values would be exhaustive inside the module (you have access to case f so you can see that f exists but you don't need to match on it due to Never ) but non-exhaustive outside it (from the outside, E has some non-public case, so matching is non-exhaustive).

Isn't this like saying Swift doesn't need namespaces because we have enum Namespace ? And wouldn't it mean that would couldn't switch exhaustively even internally? It seems like a real version of the feature would work even better, just like real versions of namespaces.

Isn't this like saying Swift doesn't need namespaces because we have enum Namespace ? And wouldn't it mean that would couldn't switch exhaustively even internally? It seems like a real version of the feature would work even better, just like real versions of namespaces.

I understand the desire for simplicity, but I'm not entirely sure that justifies adding this restriction. Even without the restriction, the rule can has a relatively simple formulation "you can always exhaustively match if all cases are accessible."

I'm not entirely sure what you mean... Just to clarify, I'm not suggesting that we synthesize a RawRepresentable conformance that can only be used to initialize public cases. Instead, I'm suggesting that we don't support synthesis, but library authors are free to write the conformance if they'd like to do so. Are you suggesting that we should support conformance synthesis, even though it makes it easy for clients to create non-public cases?

I agree that it is separable, but I'm not sure why I should separate it out. Are you saying that this pitch is already too big without it? Or are you saying that it is better to have multiple smaller proposals rather than a single bigger proposal (say for easier review)?

As you must've seen earlier in the thread, there's also discussion on a potential @nonExhaustive and @unknown in nested positions. The more pitches/proposals there are, the more overhead there is for me, especially since some of the discussions will be overlapping. If this one pitch balloons into four pitches, I may have a hard time keeping up. It would be nice if we could keep things down to say two pitches (say this one, and maybe another one for @unknown in nested positions). I hope we don't get to a stage where I need to draw a complex diagram for dependencies between pitches.

agree that it is separable, but I'm not sure why I should separate it out. Are you saying that this pitch is already too big without it? Or are you saying that it is better to have multiple smaller proposals rather than a single bigger proposal (say for easier review)?

I agree that RawRepresentable should be synthesized; my simple argument is that in most cases the implementation people will want will be the default one :P. Although it can be used to skirt access control, as noted above, non-public cases are rather a matter of signalling intent for cases without associated values anyway (since one can simply store a non-public value for later), rather than enforcing that users never can create a value. I have a feeling that in most cases where RawRepresentable is needed, support for non-public cases will be required as well, so this is just creating additional work while leading to the same result in the end.

I think versioning is a better way to handle framework evolution. If users can be sure they are working with a specific framework version, they don't need to bother about unknown future cases. I would love to have versioning for Apple frameworks as well, decoupled from iOS versioning. Embed frameworks inside the apps (as Swift runtime used to do in early days), but share copies of the same framework version between apps to reduce device space usage.

I think overall it's a good idea - it naturally provides unconditional upcasting and conditional downcastning without writing any boilerplate code. But for enums I think it makes more sense to have 'supertyping' instead:

In Microsoft Word, you can hide the white space at the top and bottom of each page and reduce the amount of gray space that appears between pages in print layout view. Gray space to the left and right of the page is not affected. This behavior is controlled by the White space between pages option.

When you select the White space between pages option, Word controls the white space of any newly created documents as well as the current document according to the following rules and special cases:

Behavior Explanation

--------------------------------------------------------------------------

Per Window When the option is set and multiple

documents are open at the same time,

the document with focus is affected; other

open documents are not affected.

Per Document When you save and close a document, the

setting is retained in the document.

If the document is open when you create

a new document, the new document acquires

the setting. For example, if white space

is hidden in the document you open,

white space will be hidden in new

documents you create.

Per user option Set on a per user basis. The setting is

stored in the HKEY_CURRENT_USER registry

key with other Options settings.

Backwards compatibility If you open the document in Word 2000 or

Word 97, the setting is ignored. However,

because the setting is stored in the

document, you can edit the document in

Word 97 or Word 2000, save the file, and

this setting will not be lost when you

reopen the document in Word 2002 or in a later version.

Special zoom behavior When you zoom to show more than one page

in print layout view, the white space in

the document will be displayed

regardless of the state of the option.

The "White space between pages" option is

unavailable (dimmed). Adjusting the Zoom

percentage to show one page returns the

view to the previous state.

Special page element behavior Adding a page border, page numbers, header,

or footer resets the "White space between

pages" option. To hide the white space,

click to clear the "White space between

pages" check box.

Special process behavior When finding or replacing text or when

proofing the document in the foreground,

if Word finds an item in the header or

footer area, Word switches to Normal view

and displays the item in a pane below the

document. The state of "White space between

pages" option does not change.

3a8082e126