module List =
    let map func =
        let rec subMap sum = function
            | []   -> sum
            | h::t -> subMap (func h :: sum) t
        subMap [] >> List.rev

module List =
    let map func =
        let rec subMap = function
            | []   -> []
            | h::t -> func h :: subMap t
        subMap

[<DataContract; KnownType "GetKnownTypes">]
type ImageAttachmentFormat =
    | JpegAttachmentFormat
    |  GifAttachmentFormat
    |  PngAttachmentFormat

    static member private GetKnownTypes () = Union.knownTypes<ImageAttachmentFormat>

module private Union =
    let knownTypes<'a> = typeof<'a>.GetNestedTypes (BindingFlags.Public ||| BindingFlags.NonPublic)
                      |> Array.filter FSharpType.IsUnion

type AttachmentFormatGroup =
    | ImageAttachmentFormatGroup of ImageAttachmentFormat list * Size    
    | AudioAttachmentFormatGroup of AudioAttachmentFormat list
    | VideoAttachmentFormatGroup of VideoAttachmentFormat list
    | FileAttachmentFormatGroup  of  FileAttachmentFormat list

type ThreadIdentity = int * int // BoardID * LocalID

type PostIdentity = ThreadIdentity * int // ThreadIdentity * LocalID

type TextBlock =
    | SimpleText of string * bool * bool // *Сделайте* меня развидеть **это**
    | Url        of string               // http://nimp.org
    | PostLink   of PostIdentity         // >>/0/12345

type PostMessage =
    | BydloCode of string * string // [code=haskell] average $ filter $ yoba $ foldl1 $ Тормозной быдлокод[/code]
    | Comment   of string          // >GREEN Text
    | Spoiler   of string          // [spoiler]Оп-хуй[/spoiler]
    | TextBlock of TextBlock list  // Block area
    

type RemoteServerExceptionDetail =    
    | BoardNotFoundExceptionDetail of int    
    | ThreadNotFoundExceptionDetail of ThreadIdentityData    
    | PostNotFoundExceptionDetail of PostIdentityData    
    | AttachmentNotFoundExceptionDetail of PostIdentityData    
    | InvalidPasswordExceptionDetail    
    | DuplicateAttachmentExceptionDetail of PostIdentityData    
    | EmptyPostExceptionDetail    
    | InvalidAttachmentDataExceptionDetail    
    | InvalidCaptchaSolutionExceptionDetail    
    | ObsoleteCaptchaExceptionDetail    
    | OverflowAttachmentSizeExceptionDetail of int * int    
    | OverflowCanvasSizeExceptionDetail of Size * Size    
    | OverflowMessageExceptionDetail of int * int    
    | UnsupportAttachmentFormatExceptionDetail of AttachmentFormat
    | UnknownCaptchaExceptionDetail

let inline parse str =
    (^a : (static member Parse : string -> ^a) str)

let v1 : int   = parse "2"
let v2 : float = parse "1,3"

int -> int -> int

let yoba = (+)
        >> (fun x -> x >> (+) 1)

let flip f a b = f b a

let yoba = (+)
        >> flip (>>) ((-) 1)

let yoba = (+)
        >> (<<) ((-) 1)

: yoba1 ( a b -- c ) + 1 swap - ;
: yoba2 ( a b -- c ) + 1 - neg ;
: yoba3 ( a b -- c ) [ 1 ] 2dip + - ;

let yoba1 r n = {1..n}
             |> Seq.sumBy (fun v -> r % v)

let yoba2 r n = {1..n}
             |> Seq.sumBy ((%) r)

let yoba3 r = fun n -> {1..n}
           >> Seq.sumBy ((%) r)

let yoba4 r = fun n -> Seq.init n ((+) 1)
           >> Seq.sumBy ((%) r)

let yoba5 r = fun n -> flip Seq.init ((+) 1) n 
           >> Seq.sumBy ((%) r)

let yoba6 r = flip Seq.init ((+) 1)
           >> Seq.sumBy ((%) r)
               
let yoba7 = (fun r -> Seq.sumBy ((%) r))
         >> (>>) (flip Seq.init ((+) 1))
             
let yoba8 = (%) >> Seq.sumBy >> (>>) (flip Seq.init ((+) 1))