Common postfix representations of pointer/reference operations

Question

In some C-based languages (including C/C++ themselves and Rust), taking pointers/references and dereferencing is done with prefix operators & and *. I've noticed that this often entails extraneous parentheses when the (de-)referenced expression is passed to a postfix operator, such as array subscript ([]) or attribute resolution (./::).

I believe using postfix operators for (de-)referencing could solve this issue (similar to Rust's postfix .await). However, simply reusing the same operators in a postfix form results in syntactic ambiguities. For instance, is a*-b multiplication or subtraction?

My question is, what other syntax do such operations have in other languages? Specifically, I'm interested in approaches that avoid ambiguity and, preferably, also preserve some familiarity to C programmers.

Answer 1

A few more examples.

Pascal

program pointer_example;  
var i  : Integer;  
    ip : ^Integer;     (* Pointer to integer; ^ is prefix *)
begin
    i := 0;
    (* Neither ISO 7185 Standard Pascal nor ISO 10206 Extended
       Pascal describe a way to get a pointer to a variable, but
       this is a common extension. See comments below. *)
    ip := @i;          (* Get a pointer to an integer; @ is prefix *)
    ip^ := ip^ xor 1;  (* Dereference is a postfix operator. *)
                       (* Also note that ^ is not used for any other purpose. *)
end.

Fortran

program pointerExample
implicit none
   integer, pointer :: p1  ! p1 is a pointer to integer
   integer, target :: t1   ! t1 is an integer target

   ! You can only take the address of a variable that has the "target"
   ! attribute. Fortran has very strict aliasing rules, and this signals
   ! that the variable may be aliased.
   !
   ! This is kind of the opposite of the (now deprecated) "register"
   ! keyword in C, which is a signal that you cannot take the address
   ! of it, and it will never be the alias of another variable.

   t1 = 1
   p1=>t1                  ! p1 points to t1
   p1 = 2                  ! Fortran has no pointer arithmetic, so there
                           ! is no need for special "dereference" syntax.
end program pointerExample

BLISS

! BLISS is unusual in that the name of a variable denotes
! a pointer to it. If this sounds weird to you, consider that in
! C, the name of an array denotes a pointer to its first member.
!
! Note that BLISS only really has one "type": the machine word.
MODULE POINTERS (MAIN = CTRL) =
BEGIN
FORWARD ROUTINE
    TEST;
ROUTINE TEST =
    BEGIN
        LOCAL
            X,
            Y;
        ! This assigns 1 to the variable X.
        X = 1;
        ! This assigns the address of the variable X to the
        ! variable Y, with no explicit "reference" operator.
        Y = X;
        ! If you want to assign the value in X to the variable Y,
        ! you need to explicitly dereference X.
        X = .Y;
        ! Dereference on the lhs means assigning through a pointer.
        ! Store 2 in the memory location stored in Y.
        .Y = 2;
    END;
ELUDOM

Answer 2

This is almost certainly why the -> operator exists in C and C++, since a->b is merely syntactic sugar for (*a).b*.

C++ doesn't have an equivalent postfix for overloaded subscript or call, but you could easily create something like a->[index] in your own language. You could also allow the operator to be chained for more layers of indirection (so (**a).b == a->->b), although that may be pushing it.

Alternatively, you could make dereferencing itself postfix. The main downsides are deviation from the norm and potentially slightly more difficulty parsing (a* and a& look like the beginning of a multiplication and bitwise AND respectively, though a*., a&,, a&), a*;, and probably all other valid syntax using dereference are obviously not operations).

* ...except for this special case where a C++ class provides 2 semantically different overloads, but that kind of garbage is like #define true false

Answer 3

Rust has a postfix syntax for acquiring shared and mutable references ─ it's nothing special, though. You just call the .borrow() or .borrow_mut() method, as long as the Borrow or BorrowMut trait is in scope, respectively.

Example (playground link):

struct Foo;
fn accepts_shared_ref(_x: &Foo) {}
fn accepts_mut_ref(_x: &mut Foo) {}

fn main() {
    use std::borrow::{Borrow, BorrowMut};
    
    let mut x = Foo;
    accepts_shared_ref(x.borrow());
    accepts_mut_ref(x.borrow_mut());
}

For dereferencing, there are also the .deref() and .deref_mut() methods, but these don't have a blanket implementation for every type because that would violate the language's ownership model.

Answer 4

Pascal uses postfix ↑ or ^ for dereference.

As I understand it, standard Pascal doesn't have an address operator (you can only form pointers to dynamically allocated objects). However some implementations provide this as an extension, using prefix @.

Confusingly, ISO Pascal apparently allows @ as an alternative token for ↑, on an implementation-defined basis. If so then postfix @ would also be a dereference.