type PrintfFormat<'Printer,'State,'Residue,'Result>(value:string) =

member x.Value = value

type PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple>(value:string) =

inherit PrintfFormat<'Printer,'State,'Residue,'Result>(value)

type Format<'Printer,'State,'Residue,'Result> = PrintfFormat<'Printer,'State,'Residue,'Result>

type Format<'Printer,'State,'Residue,'Result,'Tuple> = PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple>

/// Basic idea of implementation:

/// Every Printf.* family should returns curried function that collects arguments and then somehow prints them.

/// Idea - instead of building functions on fly argument by argument we instead introduce some predefined parts and then construct functions from these parts

/// Parts include:

/// Plain ones:

/// 1. Final pieces (1..5) - set of functions with arguments number 1..5.

/// Primary characteristic - these functions produce final result of the *printf* operation

/// 2. Chained pieces (1..5) - set of functions with arguments number 1..5.

/// Primary characteristic - these functions doesn not produce final result by itself, instead they tailed with some another piece (chained or final).

/// Plain parts correspond to simple format specifiers (that are projected to just one parameter of the function, say %d or %s). However we also have

/// format specifiers that can be projected to more than one argument (i.e %a, %t or any simple format specified with * width or precision).

/// For them we add special cases (both chained and final to denote that they can either return value themselves or continue with some other piece)

/// These primitives allow us to construct curried functions with arbitrary signatures.

/// For example:

/// - function that corresponds to %s%s%s%s%s (string -> string -> string -> string -> string -> T) will be represented by one piece final 5.

/// - function that has more that 5 arguments will include chained parts: %s%s%s%s%s%d%s => chained2 -> final 5

/// Primary benefits:

/// 1. creating specialized version of any part requires only one reflection call. This means that we can handle up to 5 simple format specifiers

/// with just one reflection call

/// 2. we can make combinable parts independent from particular printf implementation. Thus final result can be cached and shared.

/// i.e when first call to printf "%s %s" will trigger creation of the specialization. Subsequent calls will pick existing specialization

open System

open System.IO

open System.Text

open System.Collections.Generic

open System.Reflection

open Microsoft.FSharp.Core

open Microsoft.FSharp.Core.Operators

open Microsoft.FSharp.Collections

open LanguagePrimitives.IntrinsicOperators

#if FX_RESHAPED_REFLECTION

open Microsoft.FSharp.Core.PrimReflectionAdapters

open Microsoft.FSharp.Core.ReflectionAdapters

open System.IO

[<Flags>]

type FormatFlags =

| None = 0

| LeftJustify = 1

| PadWithZeros = 2

| PlusForPositives = 4

| SpaceForPositives = 8

let inline hasFlag flags (expected : FormatFlags) = (flags &&& expected) = expected

let inline isLeftJustify flags = hasFlag flags FormatFlags.LeftJustify

let inline isPadWithZeros flags = hasFlag flags FormatFlags.PadWithZeros

let inline isPlusForPositives flags = hasFlag flags FormatFlags.PlusForPositives

let inline isSpaceForPositives flags = hasFlag flags FormatFlags.SpaceForPositives

/// Used for width and precision to denote that user has specified '*' flag

[<Literal>]

let StarValue = -1

/// Used for width and precision to denote that corresponding value was omitted in format string

[<Literal>]

let NotSpecifiedValue = -2

[<System.Diagnostics.DebuggerDisplayAttribute("{ToString()}")>]

[<NoComparison; NoEquality>]

type FormatSpecifier =

{

TypeChar : char

Precision : int

Width : int

Flags : FormatFlags

}

member this.IsStarPrecision = this.Precision = StarValue

member this.IsPrecisionSpecified = this.Precision <> NotSpecifiedValue

member this.IsStarWidth = this.Width = StarValue

member this.IsWidthSpecified = this.Width <> NotSpecifiedValue

override this.ToString() =

let valueOf n = match n with StarValue -> "*" | NotSpecifiedValue -> "-" | n -> n.ToString()

System.String.Format

(

"'{0}', Precision={1}, Width={2}, Flags={3}",

this.TypeChar,

(valueOf this.Precision),

(valueOf this.Width),

this.Flags

)

/// Set of helpers to parse format string

module private FormatString =

let inline isDigit c = c >= '0' && c <= '9'

let intFromString (s : string) pos =

let rec go acc i =

if isDigit s.[i] then

let n = int s.[i] - int '0'

go (acc * 10 + n) (i + 1)

else acc, i

go 0 pos

let parseFlags (s : string) i : FormatFlags * int =

let rec go flags i =

match s.[i] with

| '0' -> go (flags ||| FormatFlags.PadWithZeros) (i + 1)

| '+' -> go (flags ||| FormatFlags.PlusForPositives) (i + 1)

| ' ' -> go (flags ||| FormatFlags.SpaceForPositives) (i + 1)

| '-' -> go (flags ||| FormatFlags.LeftJustify) (i + 1)

| _ -> flags, i

go FormatFlags.None i

let parseWidth (s : string) i : int * int =

if s.[i] = '*' then StarValue, (i + 1)

elif isDigit (s.[i]) then intFromString s i

else NotSpecifiedValue, i

let parsePrecision (s : string) i : int * int =

if s.[i] = '.' then

if s.[i + 1] = '*' then StarValue, i + 2

elif isDigit (s.[i + 1]) then intFromString s (i + 1)

else raise (ArgumentException("invalid precision value"))

else NotSpecifiedValue, i

let parseTypeChar (s : string) i : char * int =

s.[i], (i + 1)

let findNextFormatSpecifier (s : string) i =

let rec go i (buf : Text.StringBuilder) =

if i >= s.Length then

s.Length, buf.ToString()

else

let c = s.[i]

if c = '%' then

if i + 1 < s.Length then

let _, i1 = parseFlags s (i + 1)

let w, i2 = parseWidth s i1

let p, i3 = parsePrecision s i2

let typeChar, i4 = parseTypeChar s i3

// shortcut for the simpliest case

// if typeChar is not % or it has star as width\precision - resort to long path

if typeChar = '%' && not (w = StarValue || p = StarValue) then

buf.Append('%') |> ignore

go i4 buf

else

i, buf.ToString()

else

raise (ArgumentException("Missing format specifier"))

else

buf.Append(c) |> ignore

go (i + 1) buf

go i (Text.StringBuilder())

/// Abstracts generated printer from the details of particular environment: how to write text, how to produce results etc...

[<AbstractClass>]

type PrintfEnv<'State, 'Residue, 'Result> =

val State : 'State

new(s : 'State) = { State = s }

abstract Finish : unit -> 'Result

abstract Write : string -> unit

abstract WriteT : 'Residue -> unit

type Utils =

static member inline Write (env : PrintfEnv<_, _, _>, a, b) =

env.Write a

env.Write b

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c) =

Utils.Write(env, a, b)

env.Write c

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c, d) =

Utils.Write(env, a, b)

Utils.Write(env, c, d)

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c, d, e) =

Utils.Write(env, a, b, c)

Utils.Write(env, d, e)

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c, d, e, f) =

Utils.Write(env, a, b, c, d)

Utils.Write(env, e, f)

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c, d, e, f, g) =

Utils.Write(env, a, b, c, d, e)

Utils.Write(env, f, g)

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c, d, e, f, g, h) =

Utils.Write(env, a, b, c, d, e, f)

Utils.Write(env, g, h)

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c, d, e, f, g, h, i) =

Utils.Write(env, a, b, c, d, e, f, g)

Utils.Write(env, h ,i)

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c, d, e, f, g, h, i, j) =

Utils.Write(env, a, b, c, d, e, f, g, h)

Utils.Write(env, i, j)

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c, d, e, f, g, h, i, j, k) =

Utils.Write(env, a, b, c, d, e, f, g, h, i)

Utils.Write(env, j, k)

static member inline Write (env : PrintfEnv<_, _, _>, a, b, c, d, e, f, g, h, i, j, k, l, m) =

Utils.Write(env, a, b, c, d, e, f, g, h, i, j, k)

Utils.Write(env, l, m)

/// Type of results produced by specialization

/// This is function that accepts thunk to create PrintfEnv on demand and returns concrete instance of Printer (curried function)

/// After all arguments is collected, specialization obtains concrete PrintfEnv from the thunk and use it to output collected data.

type PrintfFactory<'State, 'Residue, 'Result, 'Printer> = (unit -> PrintfEnv<'State, 'Residue, 'Result>) -> 'Printer

[<Literal>]

let MaxArgumentsInSpecialization = 5

/// Specializations are created via factory methods. These methods accepts 2 kinds of arguments

/// - parts of format string that corresponds to raw text

/// - functions that can transform collected values to strings

/// basic shape of the signature of specialization

/// <prefix-string> + <converter for arg1> + <suffix that comes after arg1> + ... <converter for arg-N> + <suffix that comes after arg-N>

type Specializations<'State, 'Residue, 'Result> private ()=

static member Final1<'A>

(

s0, conv1, s1

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) ->

let env = env()

Utils.Write(env, s0, (conv1 a), s1)

env.Finish()

)

)

static member FinalFastEnd1<'A>

(

s0, conv1

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) ->

let env = env()

Utils.Write(env, s0, (conv1 a))

env.Finish()

)

)

static member FinalFastStart1<'A>

(

conv1, s1

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) ->

let env = env()

Utils.Write(env, (conv1 a), s1)

env.Finish()

)

)

static member FinalFast1<'A>

(

conv1

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) ->

let env = env()

env.Write (conv1 a)

env.Finish()

)

)

static member Final2<'A, 'B>

(

s0, conv1, s1, conv2, s2

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) ->

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2)

env.Finish()

)

)

static member FinalFastEnd2<'A, 'B>

(

s0, conv1, s1, conv2

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) ->

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b))

env.Finish()

)

)

static member FinalFastStart2<'A, 'B>

(

conv1, s1, conv2, s2

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) ->

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2)

env.Finish()

)

)

static member FinalFast2<'A, 'B>

(

conv1, s1, conv2

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) ->

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b))

env.Finish()

)

)

static member Final3<'A, 'B, 'C>

(

s0, conv1, s1, conv2, s2, conv3, s3

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) ->

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3)

env.Finish()

)

)

static member FinalFastEnd3<'A, 'B, 'C>

(

s0, conv1, s1, conv2, s2, conv3

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) ->

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2, (conv3 c))

env.Finish()

)

)

static member FinalFastStart3<'A, 'B, 'C>

(

conv1, s1, conv2, s2, conv3, s3

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) ->

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3)

env.Finish()

)

)

static member FinalFast3<'A, 'B, 'C>

(

conv1, s1, conv2, s2, conv3

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) ->

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2, (conv3 c))

env.Finish()

)

)

static member Final4<'A, 'B, 'C, 'D>

(

s0, conv1, s1, conv2, s2, conv3, s3, conv4, s4

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D)->

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d), s4)

env.Finish()

)

)

static member FinalFastEnd4<'A, 'B, 'C, 'D>

(

s0, conv1, s1, conv2, s2, conv3, s3, conv4

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D)->

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d))

env.Finish()

)

)

static member FinalFastStart4<'A, 'B, 'C, 'D>

(

conv1, s1, conv2, s2, conv3, s3, conv4, s4

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D)->

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d), s4)

env.Finish()

)

)

static member FinalFast4<'A, 'B, 'C, 'D>

(

conv1, s1, conv2, s2, conv3, s3, conv4

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D)->

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d))

env.Finish()

)

)

static member Final5<'A, 'B, 'C, 'D, 'E>

(

s0, conv1, s1, conv2, s2, conv3, s3, conv4, s4, conv5, s5

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D) (e : 'E)->

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d), s4, (conv5 e), s5)

env.Finish()

)

)

static member FinalFastEnd5<'A, 'B, 'C, 'D, 'E>

(

s0, conv1, s1, conv2, s2, conv3, s3, conv4, s4, conv5

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D) (e : 'E)->

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d), s4, (conv5 e))

env.Finish()

)

)

static member FinalFastStart5<'A, 'B, 'C, 'D, 'E>

(

conv1, s1, conv2, s2, conv3, s3, conv4, s4, conv5, s5

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D) (e : 'E)->

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d), s4, (conv5 e), s5)

env.Finish()

)

)

static member FinalFast5<'A, 'B, 'C, 'D, 'E>

(

conv1, s1, conv2, s2, conv3, s3, conv4, s4, conv5

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D) (e : 'E)->

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d), s4, (conv5 e))

env.Finish()

)

)

static member Chained1<'A, 'Tail>

(

s0, conv1,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) ->

let env() =

let env = env()

Utils.Write(env, s0, (conv1 a))

env

next env : 'Tail

)

)

static member ChainedFastStart1<'A, 'Tail>

(

conv1,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) ->

let env() =

let env = env()

env.Write(conv1 a)

env

next env : 'Tail

)

)

static member Chained2<'A, 'B, 'Tail>

(

s0, conv1, s1, conv2,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) ->

let env() =

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b))

env

next env : 'Tail

)

)

static member ChainedFastStart2<'A, 'B, 'Tail>

(

conv1, s1, conv2,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) ->

let env() =

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b))

env

next env : 'Tail

)

)

static member Chained3<'A, 'B, 'C, 'Tail>

(

s0, conv1, s1, conv2, s2, conv3,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) ->

let env() =

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2, (conv3 c))

env

next env : 'Tail

)

)

static member ChainedFastStart3<'A, 'B, 'C, 'Tail>

(

conv1, s1, conv2, s2, conv3,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) ->

let env() =

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2, (conv3 c))

env

next env : 'Tail

)

)

static member Chained4<'A, 'B, 'C, 'D, 'Tail>

(

s0, conv1, s1, conv2, s2, conv3, s3, conv4,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D)->

let env() =

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d))

env

next env : 'Tail

)

)

static member ChainedFastStart4<'A, 'B, 'C, 'D, 'Tail>

(

conv1, s1, conv2, s2, conv3, s3, conv4,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D)->

let env() =

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d))

env

next env : 'Tail

)

)

static member Chained5<'A, 'B, 'C, 'D, 'E, 'Tail>

(

s0, conv1, s1, conv2, s2, conv3, s3, conv4, s4, conv5,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D) (e : 'E)->

let env() =

let env = env()

Utils.Write(env, s0, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d), s4, (conv5 e))

env

next env : 'Tail

)

)

static member ChainedFastStart5<'A, 'B, 'C, 'D, 'E, 'Tail>

(

conv1, s1, conv2, s2, conv3, s3, conv4, s4, conv5,

next

) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (a : 'A) (b : 'B) (c : 'C) (d : 'D) (e : 'E)->

let env() =

let env = env()

Utils.Write(env, (conv1 a), s1, (conv2 b), s2, (conv3 c), s3, (conv4 d), s4, (conv5 e))

env

next env : 'Tail

)

)

static member TFinal(s1 : string, s2 : string) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (f : 'State -> 'Residue) ->

let env = env()

env.Write(s1)

env.WriteT(f env.State)

env.Write s2

env.Finish()

)

)

static member TChained<'Tail>(s1 : string, next : PrintfFactory<'State, 'Residue, 'Result,'Tail>) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (f : 'State -> 'Residue) ->

let env() =

let env = env()

env.Write(s1)

env.WriteT(f env.State)

env

next(env) : 'Tail

)

)

static member LittleAFinal<'A>(s1 : string, s2 : string) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (f : 'State -> 'A ->'Residue) (a : 'A) ->

let env = env()

env.Write s1

env.WriteT(f env.State a)

env.Write s2

env.Finish()

)

)

static member LittleAChained<'A, 'Tail>(s1 : string, next : PrintfFactory<'State, 'Residue, 'Result,'Tail>) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (f : 'State -> 'A ->'Residue) (a : 'A) ->

let env() =

let env = env()

env.Write s1

env.WriteT(f env.State a)

env

next env : 'Tail

)

)

static member StarFinal1<'A>(s1 : string, conv, s2 : string) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (star1 : int) (a : 'A) ->

let env = env()

env.Write s1

env.Write (conv a star1 : string)

env.Write s2

env.Finish()

)

)

static member PercentStarFinal1(s1 : string, s2 : string) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (_star1 : int) ->

let env = env()

env.Write s1

env.Write("%")

env.Write s2

env.Finish()

)

)

static member StarFinal2<'A>(s1 : string, conv, s2 : string) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (star1 : int) (star2 : int) (a : 'A) ->

let env = env()

env.Write s1

env.Write (conv a star1 star2: string)

env.Write s2

env.Finish()

)

)

/// Handles case when '%*.*%' is used at the end of string

static member PercentStarFinal2(s1 : string, s2 : string) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (_star1 : int) (_star2 : int) ->

let env = env()

env.Write s1

env.Write("%")

env.Write s2

env.Finish()

)

)

static member StarChained1<'A, 'Tail>(s1 : string, conv, next : PrintfFactory<'State, 'Residue, 'Result,'Tail>) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (star1 : int) (a : 'A) ->

let env() =

let env = env()

env.Write s1

env.Write(conv a star1 : string)

env

next env : 'Tail

)

)

/// Handles case when '%*%' is used in the middle of the string so it needs to be chained to another printing block

static member PercentStarChained1<'Tail>(s1 : string, next : PrintfFactory<'State, 'Residue, 'Result,'Tail>) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (_star1 : int) ->

let env() =

let env = env()

env.Write s1

env.Write("%")

env

next env : 'Tail

)

)

static member StarChained2<'A, 'Tail>(s1 : string, conv, next : PrintfFactory<'State, 'Residue, 'Result,'Tail>) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (star1 : int) (star2 : int) (a : 'A) ->

let env() =

let env = env()

env.Write s1

env.Write(conv a star1 star2 : string)

env

next env : 'Tail

)

)

/// Handles case when '%*.*%' is used in the middle of the string so it needs to be chained to another printing block

static member PercentStarChained2<'Tail>(s1 : string, next : PrintfFactory<'State, 'Residue, 'Result,'Tail>) =

(fun (env : unit -> PrintfEnv<'State, 'Residue, 'Result>) ->

(fun (_star1 : int) (_star2 : int) ->

let env() =

let env = env()

env.Write s1

env.Write("%")

env

next env : 'Tail

)

)

let inline (===) a b = Object.ReferenceEquals(a, b)

let invariantCulture = System.Globalization.CultureInfo.InvariantCulture

let inline boolToString v = if v then "true" else "false"

let inline stringToSafeString v =

match v with

| null -> ""

| _ -> v

[<Literal>]

let DefaultPrecision = 6

let getFormatForFloat (ch : char) (prec : int) = ch.ToString() + prec.ToString()

let normalizePrecision prec = min (max prec 0) 99

/// Contains helpers to convert printer functions to functions that prints value with respect to specified justification

/// There are two kinds to printers:

/// 'T -> string - converts value to string - used for strings, basic integers etc..

/// string -> 'T -> string - converts value to string with given format string - used by numbers with floating point, typically precision is set via format string

/// To support both categories there are two entry points:

/// - withPadding - adapts first category

/// - withPaddingFormatted - adapts second category

module Padding =

/// pad here is function that converts T to string with respect of justification

/// basic - function that converts T to string without applying justification rules

/// adaptPaddedFormatted returns boxed function that has various number of arguments depending on if width\precision flags has '*' value

let inline adaptPaddedFormatted (spec : FormatSpecifier) getFormat (basic : string -> 'T -> string) (pad : string -> int -> 'T -> string) =

if spec.IsStarWidth then

if spec.IsStarPrecision then

// width=*, prec=*

box(fun v width prec ->

let fmt = getFormat (normalizePrecision prec)

pad fmt width v)

else

// width=*, prec=?

let prec = if spec.IsPrecisionSpecified then normalizePrecision spec.Precision else DefaultPrecision

let fmt = getFormat prec

box(fun v width ->

pad fmt width v)

elif spec.IsStarPrecision then