Composable types 3. Objects and patterns 4. Composability at compile time 5. Hierarchies and computation ## COMPOSABLE? What does "composable" mean? Composable, reusable, extensible, flexible extension • run computations over hierarchies ## COMPUTATION AND TRAVERSAL When structures are flat, we're already good at separating computation and traversal. auto total_length(const vector& operation passed in). ## HIERARCHICAL COMPUTATION When structures are hierarchical, we're much less good at separating computation and traversal. Consider how to sum the lengths in a

Defining Functions 6 2.3 Defining New Types 8 2.4 Records and Structures 10 2.5 Mathematics and Computation 12 3 Basic Programming 15 3.1 Evaluating Expressions 15 3.2 Recursive Definitions 17 independent of any sort of ambient state of computation. There is no notion of storing a result in memory or changing the value of a global variable; computation is just evaluation of expressions. This paradigm be explicitly bounded, though, of course, we can consider the result of iterating an arbitrary computation n times for any given natural number n. Lean provides flexible mechanisms for structural and well-founded

jpg) A Simple Computation $$ A=\alpha(x\times y^{\mathrm{T}})+\beta A $$ A Simple Computation \[\begin{aligned}A=\alpha(x\times y^{\mathrm{T}})+\beta A\\ \boxed{ ## A Simple Computation Scalar $$ A $$ ## A Simple Computation $$ A = \alpha(x \times y^\mathrm{T}) + \beta A $$ ## A Simple Computation $$ A = \alpha(x \times y^\mathrm{T}) + \beta A $$ ## A Simple Computation $$ \begin{align [Image](/uploads/documents/5/f/a/e/5faeee231a2711671514ff574648f1f0/p21_1.jpg) AArch64 ## A Simple Computation $$ A=\alpha(x\times y^{\mathrm{T}})+\beta A $$ #include ![Image](/uploads/docum

Discussion 13 2.4 Muon Optimizer 14 3 General Infrastructures 15 3.1 Fine-Grained Communication-Computation Overlap in Expert Parallelism 15 3.2 Flexible and Efficient Kernel Development with TileLang 16 optimizations. First, we design and implement a single fused kernel for MoE modules that fully overlaps computation, communication, and memory access. Second, we employ TileLang (Wang et al., 2026), a Domain-Specific quantization-aware training for MoE expert weights and the indexer QK path to reduce memory and computation. Fifth, for the training framework, we extend the autograd framework with tensor-level checkpointing

to suspend a computation spanning multiple functions, we need to suspend them all one by one ☐ Stackless ☑ We can only suspend one function at a time If we want to suspend a computation spanning multiple outer_function(); int main() { Async r = outer_function(); // ... r.resume_computation(); Result result = r.get_result(); } Async outer_function(); int main() { Async r = outer_function(); // ... r.resume_computation(); Result result = r.get_result(); } Async

test new ideas • Automatically compute gradients • Run it all efficiently on GPU to speed up computation ## V arious Frameworks ## • Various Deep Learning Frameworks  ## • Preview of Numpy & PyTorch & Tensorflow ## Computation Graph  Numpy import includes a lot of loss functions. - It allows building networks whose structure is dependent on computation itself. - NLP: account for variable length sentences. Instead of padding the sentence to a fixed

language, all Haskell types include $ \perp $ . That is, a value of any type may be bound to a computation that, when demanded, results in an error. When evaluated, errors cause immediate program termination pattern is matched against the value, and if the match fails or diverges, so does the overall computation. 3. Matching the wildcard pattern _ against any value always succeeds, and no binding is done computed twice, once at each of two different overloadings. If the programmer does actually wish the computation to be repeated, an explicit type signature may be added: let { len :: Num a => a; len = genericLength

sequence actions, feeding the output of one computation into the input of the next. IO is an abstract type, however, so we can't access the result of a computation directly. Instead, we sequence operations -> f b ## Monads and do-notation The Monad interface allows us to encapsulate binding and computation, and is the basis of do-notation introduced in Section “do” notation (page 13). It extends Applicative — matching intermediate values Very often, we need to match on the result of an intermediate computation. Idris provides a construct for this, the with rule, inspired by views in Epigram $ ^{1} $ , which

sequence actions, feeding the output of one computation into the input of the next. IO is an abstract type, however, so we can't access the result of a computation directly. Instead, we sequence operations -> f b ## Monads and do-notation The Monad interface allows us to encapsulate binding and computation, and is the basis of do-notation introduced in Section “do” notation (page 13). It extends Applicative — matching intermediate values Very often, we need to match on the result of an intermediate computation. Idris provides a construct for this, the with rule, inspired by views in Epigram $ ^{1} $ , which

sequence actions, feeding the output of one computation into the input of the next. IO is an abstract type, however, so we can't access the result of a computation directly. Instead, we sequence operations -> f b ## Monads and do-notation The Monad interface allows us to encapsulate binding and computation, and is the basis of do-notation introduced in Section "do" notation (page 13). It extends — matching intermediate values Very often, we need to match on the result of an intermediate computation. Idris provides a construct for this, the with rule, inspired by views in Epigram $ ^{1} $ , which