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 = ...

arialdomartini

public class VersionTest
{
    private readonly ITestOutputHelper _outp;

    public VersionTest(ITestOutputHelper outp)
    {
        _outp = outp;
    }

    [Fact]

arialdomartini

f = 1: 1: zipWith (+) f (tail f)

arialdomartini

internal interface Either<L, R>
{
    Either<L, B> Bind<B>(Func<R, Either<L, B>> f);

    B Match<B>(Func<L, B> whenLeft, Func<R, B> whenRight);
}

internal sealed record Right<L, R> : Either<L, R>
{

arialdomartini

(defun my-dired--first-char-or-ask ()
  (if (member (char-after (line-beginning-position)) `(?\s ,dired-marker-char))
      (read-char "Which mark are you targeting? ")
    (char-after (line-beginning-position))))

(defun my-dired-swap-marks-ask ()
  (interactive)
  (let ((mark (my-dired--first-char-or-ask)))
    (my-dired-swap-marks (string mark))))

arialdomartini

Selezionati

No-s

• No mutable state
• no loops (for, while)
• no statements
• no mouse
• no primitives
• no else (only guards)
• no conditionals

arialdomartini

content
 .lines()
 .filter(|line| line.to_lowercase().as_str().contains(query))
 .collect()

content
 .lines()
 .map(|line| line.to_lowercase().as_str())
 .filter(|line| line.contains(query))
 .collect()

arialdomartini

module Main where

type Point = Int
type From = Point
type To = Point
type Segment = (From, To)
type Graph = [Segment]

hasPath :: Graph -> From -> To -> Bool
hasPath [] _ _ = False

arialdomartini

private delegate IEnumerable<string> ManipulateHistory(IEnumerable<string> history);

ManipulateHistory append(string tail) =>
    history => history.Append(new[] { history.Last() + tail });

ManipulateHistory delete(int k) =>
    history => history.Append(new[] { delete(history.Last(), k) });

string delete(string last, int k) => last.Substring(0, last.Length - k);