https://docs.clarolang.com/ [ ] 1. Welcome to Claro! 2. 3. 4. User Guide 5. 1. Hello, World 6. 2. Getting Started! 7. 1. 2.1. Understanding the Starter Project 2. 2.2. Your First Program 3. 2.3. Intro to Modules 4. 8. 9. Reference Guide 10. 3. Common Programming Concepts 11. 1. 3.1. Variables & Primitive Types 2. 3.2. Separate Variable Declaration & Initialization 3. 3.3. Variable Reassignment 4. 3.4. String Formatting 5. 3.5. Control Flow 6. 1. 3.5.1. If-Else 2. 3.5.2. While 3. 3.5.3. For 4. 3.5.4. Repeat 5. 3.5.5. Pipes 6. 3.5.6. Pattern Matching 7. 1. 3.5.6.1. Matching Structured Data 2. 3.5.6.2. Wildcard Patterns 3. 3.5.6.3. Static Exhaustiveness Checks 8. 3.5.7. Collection Comprehension 9. 1. 3.5.7.1. Comprehension is More Than Syntax Sugar 12. 4. Types 13. 1. 4.1. Builtin Collections 2. 1. 4.1.1. Lists 2. 4.1.2. Sets 3. 4.1.3. Maps 4. 4.1.4. Tuples 5. 4.1.5. Structs 3. 4.2. Oneofs 4. 1. 4.2.1. "Narrowing" / Type Guards 5. 4.3. Atoms 6. 4.4. Aliases 7. 1. 4.4.1. Aliases are Not a New Type Declaration 8. 4.5. User Defined Types 9. 1. 4.5.1. Parameterized Types 2. 1. 4.5.1.1. Concrete Type Inference 3. 4.5.2. Recursive Types 4. 1. 4.5.2.1. Impossible Recursive Types 14. 5. Type Inference 15. 1. 5.1. Required Type Annotations 16. 6. Procedures 17. 1. 6.1. Functions 2. 6.2. Consumers 3. 6.3. Providers 18. 7. Lambdas & First Class Procedures 19. 1. 7.1. Lambdas are Restricted "Closures" 20. 8. Error Handling 21. 1. 8.1. Error Propagation 22. 9. Generics 23. 1. 9.1. Contracts 2. 1. 9.1.1. Implementing a Contract 2. 9.1.2. Multiple Type Params 3. 1. 9.1.2.1. (Advanced) Implied Types 4. 9.1.3. Dynamic Dispatch 3. 9.2. Generic Return Type Inference 24. 10. Copying Data 25. 1. 10.1. Mutability Coercion on Copy 2. 10.2. Performance Optimizations 3. 10.3. Known Copy Bugs 26. 11. Resource Files 27. 12. Module System 28. 1. 12.1. Module APIs 2. 1. 12.1.1. Procedure Signatures 2. 12.1.2. Type & Alias Definitions 3. 1. 12.1.2.1. Initializers 2. 12.1.2.2. Unwrappers 3. 12.1.2.3. Opaque Types 4. 12.1.3. Static Values 5. 1. 12.1.3.1. Flags 6. 12.1.4. HTTP Services 3. 12.2. Visibility 4. 12.3. Swapping Dependencies 29. 13. Concurrency 30. 1. 13.1. Graph Procedures 2. 13.2. Graph Procedure Composition 3. 13.3. Calling Graph Procedures 4. 13.4. (Advanced) Conditional Subgraph Execution 31. 14. Fearless Concurrency 32. 1. 14.1. Guaranteed Data-Race-Free Concurrency 2. 14.2. Guaranteed Deadlock-Free Concurrency 3. 1. 14.2.1. Blocking Procedures 2. 14.2.2. Re: "What Color is Your Function?" 3. 14.2.3. (Advanced) Blocking Generics 33. 15. Basic HTTP Servers 34. 16. JSON Parsing 35. 17. Build Time Metaprogramming 36. 1. 17.1. Source Code Templates 2. 17.2. (Literal) Code Reuse 3. 1. 17.2.1. Reusing Module APIs 2. 17.2.2. Reusing Source Code 3. 17.2.3. Abstract Modules 4. 37. 38. StdLib 39. 18. Default Modules 40. 1. 18.1. booleans 2. 18.2. deque 3. 18.3. doubles 4. 18.4. files 5. 18.5. floats 6. 18.6. futures 7. 18.7. fp 8. 18.8. ints 9. 18.9. lists 10. 18.10. longs 11. 18.11. maps 12. 18.12. math 13. 18.13. priority_queue 14. 18.14. random 15. 18.15. scanner 16. 18.16. sets 17. 18.17. std 18. 18.18. strings 19. 18.19. string_builder * Light * Rust * Coal * Navy * Ayu The Claro Programming Language (DRAFT) [ ] Welcome to Claro! [ClaroLogoFromArrivalHeptapodOfferWeapon-t] Claro is a statically typed JVM language that provides a well-lit path to building simple, highly concurrent, and scalable applications. Dependency Management Done Right --------------------------------------------------------------------- Claro was designed with modern build tooling in mind: * Swap any dependency without changing a single line of source code * Runtime "Dependency Injection" frameworks are a thing of the past * First class Module system Fearless Concurrency --------------------------------------------------------------------- Developed by a Xoogler taking inspiration from years of hands-on development experience with Google-internal backend web frameworks, Claro moves well beyond async/await. Claro's declarative, DAG-based structured concurrency model provides an easy-to-use abstraction to statically guarantee that programs are: * Non-blocking * Data-race free * Deadlock free * Optimally scheduled * Scalable by default Data Oriented --------------------------------------------------------------------- * Strict separation between data and functionality * Mutability tracked at the type system level * Extremely flexible built in algebraic data types * Model arbitrary data structures with zero boilerplate Unapologetically Practical --------------------------------------------------------------------- * Bi-directional type inference * Robust standard library * Builtin external package manager * Build time metaprogramming Designed to Scale with You --------------------------------------------------------------------- * Incremental compilation out of the box * Code reuse made simple * Develop codebases of any size without devolving into a spaghetti labyrinth Actively In Development --------------------------------------------------------------------- Claro is in active development and is not yet ready for production use. While Claro has been in active development for more than 3 years, its design and implementation has been done entirely by its single maintainer, Jason Steving - while the foundation has been laid, contributions are welcome! Anyone with interest is actively encouraged to reach out and get involved!