arialdomartini

// heading numbers on the margin


#show raw: it => {
  box(
      fill: rgb("#f6f8fa"),
      stroke: rgb("#d1d9e0b3"),
      outset: (y: 3pt),
      inset: (x: 2pt),
      radius: 3pt,

arialdomartini

module FSharpBits.LambdaArray

open Xunit
open Swensen.Unquote

let newArray =
    fun i -> None

let setValue index value array =
    fun i ->

arialdomartini

module FSharpBits.ParserCombinators.ForTheRestOfUs.From7.FreeMonad2

open Xunit
open Swensen.Unquote

type User = { Id: string; Name: string }
type Result = string

type ExternalServiceInstruction<'a> =
    | GetBalance of int * (decimal -> 'a)

arialdomartini

;; This buffer is for text that is not saved, and for Lisp evaluation.
;; To create a file, visit it with C-x C-f and enter text in its buffer.


(set-face-attribute 'default nil :height 100)
(set-face-attribute 'default nil :height 200)


;; ---------------------- 

arialdomartini

Assumptions:

• Function returns a list of strings.

• Unless a requirement specifies spaces, it is intented to ignore them (e.g., "list is surrounded by an initial and an ending a" assumes that in this test any space in the initial and ending line is ignored.

• The order of requirements matter, as it influences the

arialdomartini

use std::fs::OpenOptions;
use std::io::Write;

use rand::{Rng, SeedableRng};
use rand_pcg::Pcg64;

fn fizz_buzz() -> impl Iterator<Item = String> {
    (1..).map(|i| {
        if i % 15 == 0 {
            "fizzbuzz".to_string()

arialdomartini

<Project>
  <PropertyGroup>
    <UseArtifactsOutput>true</UseArtifactsOutput>
  </PropertyGroup>
</Project>

arialdomartini

create database getting_started;
use getting_started;

create table employees (
    id int,
    last_name varchar(255),
    first_name varchar(255),
    primary key(id));
    
create table teams (

arialdomartini

let tree = Node(Leaf "one", Node(Leaf "two", Leaf "three"))
type WithCount<'v> = WithCount of (int -> 'v * int)


let build l r = Node(l, r)
let run (WithCount f) (count: int)= f count
 
let pure' v = WithCount (fun count -> (v, count))

let (<*>) f a = 

arialdomartini

import Data.Monoid

-- questo importa Monoid che, semplificato, definisce lo zero e la concatenazione:
class Monoid a where
  mempty :: a
  mappend :: a -> a -> a

--questo mi permette di definire whatever tipo come monoide

newtype MyMonoid = ...