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);

arialdomartini

public class PrimeFactorTest
{
    [Property]
    bool boolean_factorization_in_prime_numbers(PositiveInt positiveNumber)
    {
        var n = positiveNumber.Item;
        
        var factors = factorize(n);
        
        return factors.AreAllPrime() && factors.Multiplied() == n;

arialdomartini

test
            "repeated characters are replaced with one"
            {
                let randomlyRepeat char =
                    gen {
                        let! randomLength = Arb.generate<int> |> Gen.map (fun i -> abs i + 1)
                        return String(char, randomLength)
                    }
                    
                let arbitrarilyRepeatCharactersInString s =