pirrmann

let (|Operator|_|) s =
    match s with
    | "+" -> Some (+)
    | "-" -> Some (-)
    | "*" -> Some (*)
    | "/" -> Some (/)
    | _ -> None

let eval state input =
    match input, state with

pirrmann

type SyntaxToken = string

type X =
    {
        SomeProperty: string
    } with
    member this.AddModifiers(tokens:SyntaxToken array) =
        { this with
            SomeProperty = sprintf "%s + %s" (this.SomeProperty) (System.String.Join(",", tokens)) }

pirrmann

type ScopeAndRules = | ScopeAndRules of string * int list

type RulesBuilder() =
    member x.Yield(v) = []
    [<CustomOperation("scope", MaintainsVariableSpace=true)>]
    member x.Scope(source, scope) = ScopeAndRules(scope, []) :: source
    [<CustomOperation("rule", MaintainsVariableSpace=true)>]
    member x.Rule(source, rule) =
        match source with
        | ScopeAndRules(scope, rules) :: tail -> ScopeAndRules(scope, rule :: rules) :: tail

pirrmann

module TestCasesBuilder

open Microsoft.FSharp.Reflection

type TestCasesBuilder() =
    member x.Zero() = Seq.empty
    member x.Yield<'T>(t:'T) =
        let value =
            if FSharpType.IsTuple(typeof<'T>)
            then t |> FSharpValue.GetTupleFields

pirrmann

//An implementation of basic non-negative integers, based on https://gist.github.com/akimboyko/7019648,
//but rewritten in a more F# idiomatic way
module Naturals
open System

type Natural =
    | Zero
    | Succ of Natural

    member x.IsZero' = x = Zero