Like foldMap, but with an effectful projection.

Like Getting, but allows for retrieving the r element in some Applicative context m.

Given an effectful projection from a into a monoid r, retrieve the sum of all a values in an s structure as targetted by the GettingM optic. Note that the Monoid constraint on r is implicit via Const, but we note it in the type for clarity.

toModulePath takes an include-relative path to a .proto file and produces a "module path" which is used during code generation.

Note that, with the exception of the '.proto' portion of the input filepath, this function interprets . in the filename components as if they were additional slashes (assuming that the . is not the first character, which is merely ignored). So e.g. "googleprotobuftimestamp.proto" and "google.protobuf.timestamp.proto" map to the same module path.

>>> toModulePath "/absolute/path/fails.proto"
Left "expected include-relative path"

>>> toModulePath "relative/path/to/file_without_proto_suffix_fails"
Left "expected .proto suffix"

>>> toModulePath "relative/path/to/file_without_proto_suffix_fails.txt"
Left "expected .proto suffix"

>>> toModulePath "../foo.proto"
Left "expected include-relative path, but the path started with ../"

>>> toModulePath "foo..proto"
Left "path contained unexpected .. after canonicalization, please use form x.y.z.proto"

>>> toModulePath "foo/bar/baz..proto"
Left "path contained unexpected .. after canonicalization, please use form x.y.z.proto"

>>> toModulePath "foo.bar../baz.proto"
Left "path contained unexpected .. after canonicalization, please use form x.y.z.proto"

>>> toModulePath "google/protobuf/timestamp.proto"
Right (Path {components = "Google" :| ["Protobuf","Timestamp"]})

>>> toModulePath "a/b/c/google.protobuf.timestamp.proto"
Right (Path {components = "A" :| ["B","C","Google","Protobuf","Timestamp"]})

>>> toModulePath "foo/FiLeName_underscore.and.then.some.dots.proto"
Right (Path {components = "Foo" :| ["FiLeName_underscore","And","Then","Some","Dots"]})

importProto searchPaths toplevel inc attempts to import include-relative inc after locating it somewhere in the searchPaths; toplevel is simply the path of toplevel .proto being processed so we can report it in an error message. This function terminates the program if it cannot find the file to import or if it cannot construct a valid module path from it.

Attempts to locate the first (if any) filename that exists on the given search paths, and constructs the "module path" from the given include-relative filename (2nd parameter). Terminates the program with an error if the given pathname is not relative.

A mapping from .proto type identifiers to their type information

Information about messages and enumerations

Whether a definition is an enumeration or a message

Returns True if the given primitive type is packable. The TypeContext is used to distinguish Named enums and messages, only the former of which are packable.

toPascalCase xs' sends a snake-case string xs to a pascal-cased string. Trailing underscores are not dropped from the input string and exactly double underscores are replaced by a single underscore.

toCamelCase xs sends a snake-case string xs to a camel-cased string.

Uppercases the first character of a string.

Examples

>>> toUpperFirst "abc"
"Abc"

>>> toUpperFirst ""
""

segmentBy p xs partitions xs into segments of Either [a] [a] with:

• Right sublists containing elements satisfying p, otherwise;
• Left sublists containing elements that do not satisfy p

Examples

>>> segmentBy (\c -> c == '_') "abc_123_xyz"
[Left "abc",Right "_",Left "123",Right "_",Left "xyz"]

suffixBy p xs yields Right (xs', suf) if suf is the longest suffix satisfying p and xs' is the rest of the rest, otherwise the string is given back as Left xs signifying xs had no suffix satisfying p.

typeLikeName xs produces either the pascal-cased version of the string xs if it begins with an alphabetical character or underscore - which is replaced with X. A CompileError is emitted if the starting character is non-alphabetic or if xs == "".

fieldLikeName field is the casing transformation used to produce record selectors from message fields. If field is prefixed by a span of uppercase characters then that prefix will be lowercased while the remaining string is left unchanged.

prefixedMethodName service method produces a Haskell record selector name for the service method method by joining the names service, method under concatenation on a camel-casing transformation.

prefixedFieldName prefix field constructs a Haskell record selector name by prepending prefix in camel-case to the message field/service method name field.

Given a DotProtoIdentifier for the parent type and the unqualified name of this type, generate the corresponding Haskell name

Bookeeping for qualified fields

Bookkeeping for fields

Bookkeeping for oneof fields

Bookkeeping for oneof subfields

Project qualified fields, given a projection function per field type.