duckc
| Files | Last commit | Last update |
|---|---|---|
| 6 months ago | ||
| 8 months ago | ||
| 9 months ago | ||
| 9 months ago | ||
| 9 months ago | ||
| 4 months ago | ||
| 9 months ago | ||
| 4 months ago | ||
| 10 months ago | ||
| 8 months ago | ||
| 8 months ago | ||
| 1 year ago | ||
| 10 months ago | ||
| 10 months ago | ||
| 1 year ago | ||
| 9 months ago | ||
| 1 year ago |
Duck
the programming language for modern full-stack web-development
Website | Tour of Duck | Blog | Standard Library
⚠️ We're in an early Alpha Stage and not production ready yet.
Duck is a modern, compiled and batteries included programming language for full-stack web-development, that's built on top of the go ecosystem, it leverages the concepts of duck-typing onto a fast and reliable platform while introducing JSX like server-side templating and client-side react components as first-class citizens.
This repository hosts the source code for Duck. It contains the compiler, it's build tool dargo, the standard library and documentation.
✨ Key Features
- Compiles to Go: The program compiles down to a native Go binary, easy cross-compilation, and the performance of Go.
- Structural "Duck" Typing: Based on Go structs, but flexible. You don't need explicit interface declarations; if the shape matches, it fits.
- Compiletime enforced mutability checks: mutations to references are explicit and must be annotated, with the
&mut. - Web Native:
- SSR: Built-in HTML template parsing for server-side rendering.
- Components: Use React components directly within templates (with native JS support).
- Duckwind: Includes Duckwind, a feature-complete Tailwind CSS alternative written in Rust that integrates directly with the language.
🛠️ Installation
Duck supports MacOS, Linux and Windows. To manage your installation, use duckup, our official toolchain installer and version manager.
Homebrew
brew tap duck-compiler/duckup
brew install duckup
Unix install script
curl -fsSL https://duckup.sh | bash
Windows install script
powershell -c "irm https://win.duckup.sh | iex"
Manual duckup install
Download the latest release of duckup for your OS from the duckup repository.
Completing Installation
# To install the latest toolchain
duckup update
# To check if everything is setup correctly
duckup env
# To see if the installation was successful, run following command
dargo help
👋 "Hello, World" in Duck
# To create a new project, run
dargo new <project_name> # you can leave the project name empty and you'll be prompted for a project name
This will setup a project with src/main.duck looking somewhat like:
use std::io::{println};
fn main() {
println("Hello, World");
}
run.
# Compile and run your application:
dargo run
📖 Language Quick Tour
Structural Typing
Duck uses structural typing (duck typing) on top of Go structs. You don't need to define strict types for everything; partial matches work automatically.
type User = { name: String, email: String, age: Int };
// This function only cares that the argument has a 'name' field
fn print_name(u: { name: String }) {
println(u.name);
}
fn main() {
let u = User { name: "Duck", email: "robing@gmail.com", age: 5 };
// Works perfectly because 'User' satisfies the shape { name: String }
print_name(u);
}
Client Side Rendering with React
Duck is built for the web. You can define React components that include native JavaScript and reference them directly in your server side templates server-side templates.
component Counter(props: { initial_value: Int }) jsx {
// Write this component using jsx and preact
const [value, setValue] = useState(props.initial_value);
return (
<>
<div>
<div>Current value: {value}</div>
<button onClick={() => setValue((v) => v + 1)}>Increment</button>
<NoSSRProps some_client_value={"i was passed in the browser"}/>
</div>
</>
);
}
Server Side Rendering with Duckx
Templates are rendered on the server, but the can also contain react client components or other templates. You can pass props to a template which are never leaked to the client, as long as you don't display them in the html or use them as a className for example.
template SSRWithParam(props: { color: String, text: String }) duckx {
<div style="color: {props.color}">{props.text}</div>
}
Use SSR templates and CSR react components all together in one final template
template FullPage(props: { values: Int[] }) duckx {
<>
<!DOCTYPE html>
<html lang="en">
<head>
<title>My page written in Duck SSR</title>
<meta charset="utf-8"/>
</head>
<body>
<Simple/>
<Counter initial_value={54}/>
<SSRWithParam color={"green"} text={"green text"}/>
{
const z = give_me_a_value();
<p>I am a computed html. z: {z}</p>
}
<ul>
{*props.values.iter().map(fn(e: &Int) -> Html { <li>{*e}</li> }).into_list().as_ref()}
</ul>
</body>
</html>
</>
}
Creating the HTTP Server
fn main() {
std::web::HttpServer::new(.verbose)
.serve_template("/", FullPage({values: [10, 123, 45]}))
.listen(":8080");
}
All of the above can be written in a single .duck file and can be run via dargo run
et voilà you have a server-side rendered html featuring a interactive client-side rendered component listening on localhost:8080