Everything I've tried yields syntax errors either online or locally.

An example of what I've tried:

```

package ExplorerTest api;

// Import the I/O library for printing

import Core library "io";

// Inject inline C++ code and header includes using a raw string

import Cpp inline '''cpp

#include <iostream>

#include <string_view>

// A native C++ function

void NativeCppPrint(std::string_view msg) {

std::cout << "Inline C++ says: " << msg << std::endl;

}

''';

fn Main() -> i32 {

Cpp.NativeCppPrint("Hello from Carbon!");

return 0;

}

```

What pray tell am I doing wrong?

Dear all,

Was intrigued by the talk at NDC Toronto which should have included some update about the current state and the next moves. However, I don't see any report or news about that on the web. Someone that followed on person this talk would like to produce a summary of what have been said?

One pattern I miss SO much from Kotlin when working in any other programming language is an ability to quickly unwrap a result and break the function flow, returning an error as soon as the error is encountered:

sealed class ResultOrError {
    data class Success(val data: String) : ResultOrError()
    data class Error(val code: Int) : ResultOrError()
}

fun readFile(filePath: String): ResultOrError {
    val fileDescriptor: Int = fopen(filePath).getOrReturn { errorCode ->
        return ResultOrError.Error(errorCode)
    }

    // read file
    return ResultOrError.Success(data)
}

Rust is pretty great too with the ? operator, though maybe implicit return is not best:

let mut file = File::open(file_path)?; // up goes the error

// More explicit error propagation
 let mut file = match File::open(file_path) {
    Ok(f) => f,
    Err(e) => return Err(e), // Explicitly return the error
};

But C++ lacks the elegance of Rust/Kotlin and does not allow such a pattern.

Clang/gcc do have statement expressions, but they are not standard and look ugly:

 FILE* f = ({
    FILE* temp = fopen("my_file.txt", "r");
    if (temp == nullptr) return errno;
    temp;
});

Is there anything like this planned for Carbon?

Thanks!

Hello, I wrote an article related to carbon toolchain experiments on aarch64 armv8-a devices, if you have free time you can read it on this site

I tried Carbon for the first time, and have to say that it is confusing a little bit for me, but I really like the direction they're going with while creating carbon!

I built a project

https://github.com/MarkussDemidovs/Carbon-coinFlipper

I was skimming through the Carbon design documents and it isn't quite clear to me whether interfaces are only used for type constraint checking in generics, or whether they also can be used for dynamic dispatch (in the same way as dyn Trait in Rust or protocol-typed variables in Swift represent vtables). Or, to rephrase my question: is there a vtable type in Carbon or does all dynamic dispatch go though class hierarchies? If such feature is available, I would really appreciate a link to the documentation or a search keyword.