The notation in the GP is Haskell-ish type notation, which is certainly different to the majority of languages out there today, but it's actually fairly simple

The notation in the GP is Haskell-ish type notation, which is certainly different to the majority of languages out there today, but it's actually fairly simple (difficult to learn, but simple). Quick glossary: :: Defines a new function signature. The left hand side is the function name, and the right hand side is the signature. a -> b A function which converts something of type a to type b m a A generic m of type a. In Java/C# this might be written as m<a>. eg, `Array String` means an array of string elements, and might be written in C# as Array<String>. Types starting with a lowercase letter (m, a, b) generally mean the type is generic - as in the function will take any type. It might be helpful to define a function you already know: string_to_int :: String -> Int Or, for changing an Array of something to an Array of something else: map :: (a -> b) -> Array a -> Array b Here, we're defining a function that: 1. Takes a function that converts an 'a' to a 'b' (a -> b) 2. Takes an array of 'a' 3. Returns an array of 'b' Notice that 'a' and 'b' can be anything! Since the first parameter* is a function that handles the conversion from a to b, the map function actually doesn't need to know what type a and b are. Let's say we pass in the `string_to_int` as the first parameter, now the type checker will actually infer the following function type: map :: (String -> Int) -> Array String -> Array Int * Haskell functions actually only ever have one parameter, it uses Currying to accept multiple arguments: https://en.wikipedia.org/wiki/Currying https://en.wikipedia.org/wiki/Currying