Nemerle name conventions

#pragma indent;
using Nemerle;
using Nemerle.Collections;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Linq;

namespace NameConvention.Macro

    [MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Assembly)] \
    macro ModifiersByName()
        NameConventionImpl.ModifiersByName(Macros.Manager())

    [MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Assembly)] \
    macro CapitalTypeNames(alertType : string)
        NameConventionImpl.CapitalTypeNames(Macros.Manager(), alertType)

    type NM = NemerleModifiers

    module NameConventionImpl
        fstChar(s : string) : char
            s[0]
        public ModifiersByName(manager : ManagerClass) : void
            def isPublic  = fstChar >> Char.IsUpper;
            def isPrivate = fstChar >> Char.IsLower;
            def canChange = m => m.modifiers.Modifiers & NM.AccessModifiers == NM.None
            def getModifier(member)
                match(member.Name)
                    | n when isPublic(n)  => NM.Public  |> Some;
                    | n when isPrivate(n) => NM.Private |> Some;
                    | _                   => None();
            def setModifier(member)
                when(member |> getModifier is Some(m))
                    member.modifiers.Modifiers |= m
            def types = manager.NameTree.NamespaceTree.GetTypeBuilders();
            def members = types.SelectMany(_.GetParsedMembers());
            members.Where(canChange).Iter(setModifier)

        public CapitalTypeNames(manager : ManagerClass, alertType : string) : void
            def isIncorrect = t => t.Name |> fstChar >> Char.IsUpper >> !_
            def msg = n => $"Incorrect type name '$n'. Type name must begin with a capital letter"
            def showMsg = match(alertType.Trim().ToLower())
                | "error"   => (loc, name) => Message.FatalError(loc, name |> msg)
                | "warning" => (loc, name) => Message.Warning(loc, name |> msg)
                | "info"    => (loc, name) => Message.Hint(loc, name |> msg)
                | p         =>
                    Message.FatalError($"Incorrect parameter $p to CapitalTypeNames macro."
                                       + "'Error', 'Warning' or 'Info' expected")
            def alert = t => showMsg(t.Location, t.Name)
            def types = manager.NameTree.NamespaceTree.GetTypeBuilders()
            types.Where(isIncorrect).Iter(alert)